<?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 Symbiont.io on Medium]]></title>
        <description><![CDATA[Stories by Symbiont.io on Medium]]></description>
        <link>https://medium.com/@Symbiont.io?source=rss-fb910bb7fa04------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/2*EcM1F31RsOIetN9jEzfudA.png</url>
            <title>Stories by Symbiont.io on Medium</title>
            <link>https://medium.com/@Symbiont.io?source=rss-fb910bb7fa04------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 11:56:25 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@Symbiont.io/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[Safety and Ease-of-Use in SymPL, a DSL for Enterprise Smart Contracts]]></title>
            <link>https://medium.com/symbiont-io/safety-and-ease-of-use-in-sympl-a-dsl-for-enterprise-smart-contracts-d3183b0adee1?source=rss-fb910bb7fa04------2</link>
            <guid isPermaLink="false">https://medium.com/p/d3183b0adee1</guid>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[symbiont]]></category>
            <category><![CDATA[smart-contracts]]></category>
            <dc:creator><![CDATA[Symbiont.io]]></dc:creator>
            <pubDate>Mon, 27 Apr 2020 00:00:00 GMT</pubDate>
            <atom:updated>2020-04-30T14:51:38.618Z</atom:updated>
            <content:encoded><![CDATA[<p><em>By: Larry Diehl</em></p><p><a href="https://symbiont.io/technology">Symbiont Assembly</a> is, first and foremost, an application platform for decentralized applications-called smart contracts, so there must be a programming language we use to write these applications. There are two main ways of accomplishing this goal: re-using a <em>general-purpose</em> language, such as Java, Golang, or Scala, or using a <em>domain-specific</em> programming language (DSL), like Bitcoin Script, or Solidity. In the enterprise blockchain space, there is some debate as to which strategy is better.</p><p>At Symbiont, we’ve chosen to develop a domain-specific language, called <em>SymPL</em> (Symbiont Programming Language), for writing smart contracts targeting the <a href="https://symbiont.io/technology">Assembly blockchain platform</a>. The goal of this post is to describe the motivation behind the high-level design of the SymPL smart contract DSL. Specifically, I’ll describe how SymPL is able to provide best-in-class language safety while <em>also</em> being more familiar and easier to use than other smart contract DSLs.</p><p>Symbiont’s customers are today using SymPL to write complex and rich privacy-preserving smart contract applications for the Assembly platform, and deploying them in mission-critical use cases. They depend on the strong safety features provided by the language to ensure that their smart contracts operate correctly and securely. They are able to build larger, more sophisticated applications, faster and more easily, than if they had to learn the unfamiliar or cumbersome programming paradigms that are often associated with the level of safety SymPL provides.</p><p>There are many reasons why a blockchain platform supporting distributed applications should use a specially designed DSL, rather than shoehorn an existing language into that role:</p><ul><li>The semantics for a smart contract language should execute deterministically (e.g. no rand function) so the network can agree on a consistent view of data.</li><li>The language semantics should provide resource-tracking, to prevent a bad computation from executing a denial-of-service attack (DOS) against the decentralized network.</li><li>The language should have privacy and concurrency mechanisms to safely but effectively share sensitive data. While concurrency support is common in non-blockchain languages, privacy support is not.</li><li>The language should help in preventing errors via safety mechanisms (e.g. a type system and static analysis tools). Bugs in a blockchain environment tend to be especially costly due to the often financial or otherwise critical nature of distributed applications.</li></ul><p>Each of these points deserves its own blog post, but this post will focus on the last point, which is widely applicable to <em>any</em> modern programming language intended to minimize implementation bugs. Specifically, it will focus on motivating and describing the type system of SymPL, by first looking at ideal systems and then coming back to reality by integrating industry trends to help ease adoption.</p><h3>Safety and Ease-of-Use</h3><p>Type systems are somewhat humorously referred to as the most successful application of formal methods in industry software, helping ensure that operations, such as functions or methods, respect their expected interfaces (i.e., types). Hence, it is sensible to use a typed programming language to write safety-critical applications.</p><p>If we want to maximize safety of applications at all costs, we might base a smart contract language on a purely functional language like Haskell to avoid bugs resulting from complex imperative interactions. Going further, we might even choose a dependent type system, as that of <a href="https://wiki.portal.chalmers.se/agda/pmwiki.php">Agda</a> or <a href="https://coq.inria.fr/">Coq</a>, where types are expressive enough to act as logical specifications of correct software.</p><p>While purely functional, and even dependently typed, languages approach an ideal for ensuring safety, they also exclude a large population of software developers due to their lack of familiarity. While academia has long valued pure functional languages, object-oriented and even dynamic languages have seen more adoption in industry. This is especially true in the web development field, where languages like Ruby, Javascript, and Python are commonplace.</p><p>When designing SymPL, our goal was to strike a balance between safety and ease of use, by introducing cutting-edge type system features to a broad audience in a way that isn’t at all off-putting and that maximizes user friendliness. We are able to “square the circle” and provide safety and ease-of-use in a way that hasn’t been done before really anywhere (when taking the combination of all features the language provides into account), and that’s especially useful in the smart contract language space, which patently requires both.</p><h3>Features of SymPL</h3><h4>Subtyping and Flow Sensitivity</h4><p>Subtyping, a method by which a “subtype” (e.g. the even integers) can be implicitly casted to a “supertype” (e.g. the integers, or even and odd integers) has been a popular technique used to assign types to object-oriented programs. More recently, <a href="https://en.wikipedia.org/wiki/Flow-sensitive_typing">flow sensitive typing </a>, where types can change or be “refined” based on how values are tested in conditional statements (or information flow), has become more popular. Finally, gradual typing, which allows types to gradually be added to a codebase while still operating with legacy dynamically typed code, has also surged in popularity. Popular dynamically typed languages like Python (via <a href="http://mypy-lang.org/">mypy</a>), Ruby (via <a href="https://sorbet.org/">Sorbet</a>), JavaScript (via <a href="https://flow.org/">Flow</a> and <a href="https://www.typescriptlang.org/">TypeScript </a>), and Racket (via <a href="https://docs.racket-lang.org/ts-guide/">Typed Racket </a>) have been retrofitted (or generalized, as is the case for TypeScript) with gradual flow-sensitive type systems.</p><p>While gradual typing is not desirable in a blockchain setting where bugs can be introduced via a dynamically typed escape hatch, the subtyping and flow sensitivity language design research coming from gradually typed languages can be applied to proper typed languages. This enables well-typed code to be written using idioms and the look-and-feel of mainstream dynamically typed and object-oriented languages.</p><h3>Boolean Connective Types</h3><p>We are absolutely not the first to try to appeal to idiomatic dynamically typed and object-oriented code via subtyping and flow sensitivity, and maximizing safety by eschewing gradual typing. <a href="https://ceylon-lang.org/">Ceylon</a>, <a href="https://kotlinlang.org/">Kotlin</a>, the forthcoming Scala 3 ( <a href="https://dotty.epfl.ch/blog/2019/12/20/21th-dotty-milestone-release.html#dotty-with-explicit-nulls-and-flow-typing">Dotty</a>), and even <a href="https://blogs.oracle.com/javamagazine/java-14-arrives-with-a-host-of-new-features">Java 14</a> all do the same. A common feature of most languages mentioned so far is union and/or intersection types, taking their name from set-theoretic operations, or boolean algebra connectives. Algebraic data types are powerful tools from the world of functional programming, but are still not quite at mainstream adoption. Luckily, they are generalized by boolean connective types, which have a natural interpretation familiar to any CS major. If types are thought of as sets of values, subtyping can be thought of as subset inclusion. Furthermore, types (or sets of values) can be combined with familiar set-theoretic union and intersection operations, or union and intersection types (e.g. int is a subtype of Union[int, str]). Although such types may seem exotic, they are intuitive to use by just thinking about their set-theoretic interpretation.</p><h3>Purity over OO vs FP</h3><p>While flow sensitivity is a safe way to appeal to familiar dynamically typed idioms, support for a more familiar object-oriented (OO) versus a functional programming (FP) programming style is still contentious. Languages like <a href="https://www.scala-lang.org/">Scala</a> and <a href="https://ocaml.org/">OCaml</a> have demonstrated that with the right language design, both styles can elegantly be supported. Mechanisms such as record subtyping or row polymorphism demonstrate that there are more similarities to both approaches than meets the eye when rendered in terms of core language features. Furthermore, while pure functional programming (as popularized by Haskell) is associated with ease of static analysis / formal reasoning / formal methods, it is primarily <em>purity</em> that enables this. Although it is not widely considered, pure object-oriented (or mixed OO/FP) programming also works well!</p><h3>SymPL’s Core Language</h3><p>We have found that it is possible to program in a mixed OO/FP style that is familiar to dynamically typed programmers, while also facilitating extensions to support formal reasoning. This is achieved by programming in a high-level, safe-but-familiar surface language (i.e., SymPL), which can be type checked in a principled way via translation (or, elaboration) to a well-designed, minimal core language.</p><p>SymPL’s design should be contrasted in particular to that of Haskell-inspired blockchain languages like <a href="https://cardanodocs.com/technical/plutus/introduction/">Plutus</a> and <a href="https://daml.com/">DAML</a>, which essentially use a variant of <a href="https://en.wikipedia.org/wiki/System_F#System_F%CF%89">System Fω</a> as their core language, which is <a href="https://stackoverflow.com/a/21220357/73080">similar to</a> the core language used by the GHC compiler for Haskell. System Fω is a small and principled functional programming language that is well-studied and understood in the academic programming language theory (PLT) community.</p><p>While System Fω is a beautiful core language for functional programming, that user base is small compared to that of programmers more comfortable with object-oriented and even dynamically typed languages. SymPL’s core language is a strict generalization of System Fω, called System Fω&lt;: (read as “System F-omega-sub”), which <a href="https://en.wikipedia.org/wiki/System_F-sub">extends</a> System F ω with subtyping. Additionally, the core language of SymPL supports boolean connective types (union, intersection, and even negation types), record subtyping, and equirecursive types. The combination of these allows for:</p><ul><li>Safe implicit casts between compatible data, via subtyping.</li><li>A familiar object-oriented programming interface coexisting with a pure functional core language, via record subtyping.</li><li><a href="https://en.wikipedia.org/wiki/Flow-sensitive_typing">Flow-sensitive </a>refinement of types under branches of conditionals, via boolean connective types.</li><li>Safe representations of common datatypes like JSON without additional constructor wrappers, via equirecursive types.</li><li>An <a href="https://en.wikipedia.org/wiki/Standard_ML#Module_system">SML-inspired parameterized module system </a>, supporting abstraction and information hiding, via higher-order and higher-rank type quantification.</li></ul><h3>SymPL as “Python-esque”</h3><p>Having a powerful, principled core language is valuable, but you still need an approachable high-level surface language for users to work with on a daily basis. In designing the surface language of SymPL, we took particular inspiration from Python, which has in recent years grown to be among the most popular programming languages out there. Python, more than any other of the most popular languages, emphasizes strong readability and usability, having an almost pseudocode-like simplicity when implementing algorithms. This is especially important when smart contract code must be understood and agreed upon by multiple parties. Furthermore, <a href="http://mypy-lang.org/)">mypy</a>, Python’s gradual type checker, already incorporates union types and flow-sensitive typing, though not intersection or negation types. This makes it easy for Python developers to learn SymPL due to familiarity.</p><p>SymPL is not Python, but was merely strongly inspired by it and has also historically used Python for various aspects of its implementation. It’s definitely similar enough to make the learning process easy. Some of the biggest differences are as follows:</p><ul><li>Execution and timeout, via gas, are deterministic to be able to run in a blockchain environment.</li><li>Gradual typing has been replaced by static typing to prevent unsafe dynamically typed code from being introduced.</li><li>Unsafe and difficult-to-reason-about features are not included, such as runtime redefinition/patching via metaprogramming, method overriding, and call-by-reference (we use call-by-value).</li><li>The addition of intersection types to express that a type implements multiple interfaces.</li><li>The addition of an SML-style module system to support creating <a href="https://en.wikipedia.org/wiki/Abstract_data_type">abstract data types </a>(ADT’s), for contract authors to precisely control the interfaces they export to the public without access to implementation details via encapsulation.</li><li>The introduction of (equi)recursive types, which can be used to safely represent familiar untagged JSON (via untagged union types) data popular in dynamically typed language, but can also be used to represent <a href="https://en.wikipedia.org/wiki/Algebraic_data_type">algebraic data types </a>from functional programming (by encoding disjoint unions as untagged unions with added tags).</li></ul><h3>Examples</h3><p>Having described the motivations and features of the language, I’ll now show some examples to help you get a taste of it. You’ll notice the strong similarity in syntax to Python, which makes SymPL extremely easy to learn, read and write in.</p><p>Below we will demonstrate some noteworthy features of SymPL that help build a bridge between the functional, object-oriented, and dynamic programming language communities, <strong><em>none of which are available in conventional functional languages</em></strong> like <a href="https://cardanodocs.com/technical/plutus/introduction/">Plutus</a> or <a href="https://daml.com/">DAML</a>:</p><ul><li><strong>Positive and negative flow-sensitive type refinement</strong>, appealing to idiomatic dynamically typed intuitions that do not manually <strong>unpack</strong> data (e.g. out of an Optional type).</li><li><strong>(Equi)recursive and union types</strong>, also appealing to idiomatic dynamically typed intuitions that do not manually <strong>pack</strong> data (e.g. using explicit constructors of a JSON type).</li><li><strong>Record subtyping</strong>, appealing to object-oriented programmers by enabling a safe and pure encoding of <strong>classes</strong> (e.g. a Person class with name attributes and a full_name method that performs formatting).</li><li><strong>Intersection types</strong>, appealing to dynamic and object-oriented programmers by enabling a safe way to perform <a href="https://en.wikipedia.org/wiki/Duck_typing"><strong>duck typing</strong></a>, or functions with generic arguments that satisfy some interface (e.g. taking an argument that at least has first_name and last_name attributes, but may have more arguments irrelevant to computing formal_name).</li></ul><h3>Positive Type Refinement</h3><p>Let’s start with an example of flow-sensitive typing, which most commonly occurs via an Optional type to represent potentially failing, or nullable, computations. In dynamically typed programs it is idiomatic for a function to either return a value of an expected type if it succeeds, or None if it does not. Functions using results of such partial/optional computations need to first inspect whether the expected data is really there, or else handle a default case. Consider the example below, which returns the string representation of a doubled number, or the empty string as a default case:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JdcEXvJ2TejQqH9enhhL9w.png" /><figcaption><a href="https://gist.githubusercontent.com/symbiont-larry-diehl/f798d62c90126bbad4719e5d027a9133/raw/c1d6beb396aaf14c71e60c05a0a9cb4622c7608d/pos_type_ref.py">view raw</a></figcaption></figure><p>In the “then” branch of the code above, the type of the variable x has been refined from Optional[int] to int, allowing the inner multiplication ( x * 2) to be well-typed. This in contrast to many functional languages, which would need to manually unpack (i.e., from a Some or Just tagged constructor) a partial computation via a destructor or pattern matching. Note that we are also in favor of using destructors and pattern matching, but SymPL provides options that appeal to the intuitions of a large user base.</p><p>Let’s dive a little deeper to understand what’s going on underneath the hood of SymPL. The Optional[int] type is actually just a synonym for the union type Union[int, None]. In the &quot;then&quot; branch, the type of x is refined by intersecting it with the type in the conditional test. Hence, x has type Intersection[Union[int, None], int]. By distributivity, this is equivalent to Union[ Intersection[int, int], Intersection[None, int] ]. The left intersection simplifies to int and the right simplifies to Bottom, which is an error type that has no inhabiting values, leaving us with Union[int, Bottom]. Because Bottom acts as an identity value for set-theoretic union, x just has type int at the end, hence x * 2 is a well-typed expression. Without knowing all these laws, it&#39;s often easier to just appeal to set-theoretic intuitions by interpreting types as sets of values and Union and Intersection types as set-theoretic operations. This explains why Intersection[int, int] simplifies to int, because the set of integers intersected with itself is the entire set of integers. Similarly, Intersection[None, int] simplifies to Bottom because the intersection of the singleton set containing None and the set of integers is the empty set, which is represented by the type Bottom. Finally, Union[int, Bottom] simplifies to int because unioning the integers with the empty set ( Bottom) does not add any new elements. Even though union and intersection types are somewhat exotic from an academic perspective, they are in practice easy to use for industry programmers because set theory is commonly taught in CS programs.</p><p>Finally, for experts I’ll note that unlike <a href="https://kotlinlang.org/">Kotlin</a>, SymPL’s flow-sensitivity construct is <a href="https://semantic-domain.blogspot.com/2019/08/on-relationship-between-static-analysis.html#compositionality">compositional and does not break type preservation</a> properties related to substitution. This is because flow-sensitive conditionals are desugared into a <strong>binding</strong> type-case construct that shadows in the example above and avoids said issues, as done in <a href="https://www.cduce.org/">CDuce</a>.</p><h3>Negative Type Refinement</h3><p>Next let’s take a look at an alternative way we could have written the previous example by using another aspect of flow sensitivity. This time we will check whether the input is an instance of None instead of int:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*O9g8-sgJezth7vCiJMPebg.png" /><figcaption><a href="https://gist.githubusercontent.com/symbiont-larry-diehl/f798d62c90126bbad4719e5d027a9133/raw/c1d6beb396aaf14c71e60c05a0a9cb4622c7608d/neg_type_ref.py">view raw</a></figcaption></figure><p>In the “then” branch x has been refined to have type Intersection[Union[int, None], None], although x is not used so it doesn&#39;t matter. More interestingly, in the &quot;else&quot; branch x has been refined to have type Intersection[Union[int, None], Negation[None]], which intersects the optional with a negation type. A Negation type represents the complement of a set. The complement of None includes all types that are not None. You can work through the equivalences yourself using <a href="https://en.wikipedia.org/wiki/De_Morgan%27s_laws">De Morgan&#39;s laws</a>, or appeal to set-theoretic intuitions via set-complements. In the end, the result is that the expression x * 2 is well-typed in the &quot;else&quot; branch because x was originally int or None, and we know that it is <em>not</em> None, so it must be int!</p><h3>(Equi)Recursive and Union Types</h3><p>Previously we saw how to use a Union type to represent a potentially failing ( Optional) computation. Now we will combine Union types with another SymPL feature, recursive types, to encode JSON:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zBfNDeJDdEMKlKX1OjOtEQ.png" /><figcaption><a href="https://gist.githubusercontent.com/symbiont-larry-diehl/f798d62c90126bbad4719e5d027a9133/raw/c1d6beb396aaf14c71e60c05a0a9cb4622c7608d/equi_union_types.py">view raw</a></figcaption></figure><p>The JSON type is defined as a Union of base types, or a list of recursively JSON values, or a Dict mapping to recursively JSON values. This allows a value of a base type like None to be considered JSON. But, a complex list or dictionary is still valid as long as it recursively only contains values that are also valid JSON. It is idiomatic to use values like the ones above as JSON in dynamically typed languages like Python, Ruby, or more relevantly JavaScript, from which JSON sprung. Using subtyping, union types, and equirecursive types, we can safely assign a type to what such languages mean by JSON. Note that this is different from typical functional languages, where JSON would be an algebraic type that would require packing values inside constructors like jsonBool and jsonList.</p><h3>Record Subtyping</h3><p>Even though SymPL’s core language of terms is functional, the type system still allows programming in an object-oriented style. Let’s imagine creating an Person class in the high-level language with a full_name method:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DKkXK1ZWFx-5qv4qjiSI1g.png" /><figcaption><a href="https://gist.githubusercontent.com/symbiont-larry-diehl/f798d62c90126bbad4719e5d027a9133/raw/c1d6beb396aaf14c71e60c05a0a9cb4622c7608d/record_sub1.py">view raw</a></figcaption></figure><p>Internally, this is translated into a primitive Record, which is like a Dict but with a static collection of fields. Python does not have a Record type, so below we are inventing syntax in order to demonstrate what happens when SymPL translates high-level code into its core language:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*k7AO3a8lpFh5pO0LnO0Mnw.png" /><figcaption><a href="https://gist.githubusercontent.com/symbiont-larry-diehl/f798d62c90126bbad4719e5d027a9133/raw/c1d6beb396aaf14c71e60c05a0a9cb4622c7608d/record_sub2.py">view raw</a></figcaption></figure><p>Now code can construct a value of type Person using the Person(...) constructor, and can access the first_name and last_name &quot;properties&quot; via record projections, and the full_name &quot;method&quot; by a record projection followed by a function call:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GUHgh1tPgmV3f5-SpuCEhQ.png" /><figcaption><a href="https://gist.githubusercontent.com/symbiont-larry-diehl/f798d62c90126bbad4719e5d027a9133/raw/c1d6beb396aaf14c71e60c05a0a9cb4622c7608d/record_sub3.py">view raw</a></figcaption></figure><p>Also, note that in the definition of the Person(...) constructor, the full_name method does not take an explicit self argument, and can instead more efficiently access its properties by capturing them in a closure within a lambda.</p><h3>Intersection Types</h3><p>Besides being used for flow-sensitivity, intersection types can also be used to enforce that a function argument implements multiple interfaces required for that function to be well-defined. For example, let’s say that we defined separate interfaces for having a first_name and a last_name, and wanted to define a formal_name function that really only required those properties to be present, but didn&#39;t need to operate on more complex People objects (which may have many more irrelevant properties):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2i18_G6hq81LOZ6BmCrW3w.png" /><figcaption><a href="https://gist.githubusercontent.com/symbiont-larry-diehl/f798d62c90126bbad4719e5d027a9133/raw/c1d6beb396aaf14c71e60c05a0a9cb4622c7608d/inter_types.py">view raw</a></figcaption></figure><p>Record types like HasFirstName and HasLastName can act as interfaces specifying which properties or methods are required of classes. Taking the Intersection of two interfaces creates a new interface that requires <strong>both</strong> inner interfaces to be satisfied (i.e., having both the first_name and last_name attributes). Finally, record subtyping allows a Person to be passed into a function ( formal_name) expecting a Intersection[HasFirstName, HasLastName]. This is because Person has both required attributes ( first_name and last_name), even though it also has additional attributes ( middle_name and full_name) that are are not required to satisfy the compound interface Intersection[HasFirstName, HasLastName].</p><h3>Additional Features</h3><p>We’ve barely scratched the surface when it comes to the features afforded to SymPL by its small but expressive core language System F ω&lt;:, and its familiar and easy-to-use, Python-esque surface language. More complex classes can be encoded by combining records with either recursive or existential types, as demonstrated in <a href="https://www.cis.upenn.edu/~bcpierce/tapl/">TAPL</a>. Algebraic data types can be encoded by combining recursive Union types with Record types, which act as tags for constructors. Exhaustive pattern match analysis can be performed by creating subtyping problems using union and intersection types, as done in <a href="https://ceylon-lang.org/">Ceylon</a>. Powerful abstraction and data hiding can be performed using an <a href="http://sml-family.org/">SML</a>-style or <a href="https://ocaml.org/">OCaml</a>-style parameterized module system via existential types. Polymorphic (or, generic) functions and parameterized types can be written to maximize code reuse, and so on and so forth.</p><p>Some other projects that SymPL takes inspiration from may be of interest to the curious reader, mainly <a href="https://www.cduce.org/">CDuce</a> for its semantic subtyping and <a href="http://whiley.org/">Whiley</a> for its incorporation of formal verification into the language ecosystem (it also shares the Python-esque look-and-feel of SymPL). Subtyping, a way for terms of more specific types to be implicitly casted to terms of more general types, is fundamental in helping SymPL be more familiar to a broader audience. In the future we plan to add static analysis and formal verification capabilities, which also feel natural in a language with subtyping due to <a href="https://en.wikipedia.org/wiki/Refinement_type">refinement</a> (or liquid) types inducing a form of a subtyping relationship.</p><h3>Conclusion</h3><p>Even though much of the programming language industry’s focus on safety and purity has been limited to functional languages like Haskell and OCaml, it turns out that subtyping and boolean connective types can make a type safe and secure language, like SymPL, accessible to a wider audience coming from an object-oriented and dynamically typed background.</p><p><em>Originally published at </em><a href="https://symbiont.io/blog/2020/4/27/safety-and-ease-of-use-in-sympl-a-dsl-for-enterprise-smart-contracts"><em>https://symbiont.io</em></a><em> on April 27, 2020.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d3183b0adee1" width="1" height="1" alt=""><hr><p><a href="https://medium.com/symbiont-io/safety-and-ease-of-use-in-sympl-a-dsl-for-enterprise-smart-contracts-d3183b0adee1">Safety and Ease-of-Use in SymPL, a DSL for Enterprise Smart Contracts</a> was originally published in <a href="https://medium.com/symbiont-io">Symbiont</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Hiring at Symbiont]]></title>
            <link>https://medium.com/symbiont-io/hiring-at-symbiont-d8cf55d75c73?source=rss-fb910bb7fa04------2</link>
            <guid isPermaLink="false">https://medium.com/p/d8cf55d75c73</guid>
            <category><![CDATA[symbiont]]></category>
            <category><![CDATA[corporate-culture]]></category>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[recruiting]]></category>
            <category><![CDATA[hiring]]></category>
            <dc:creator><![CDATA[Symbiont.io]]></dc:creator>
            <pubDate>Mon, 06 Apr 2020 00:00:00 GMT</pubDate>
            <atom:updated>2020-04-06T13:45:45.532Z</atom:updated>
            <content:encoded><![CDATA[<p><em>By: Evan Wagner</em></p><h3>Introduction</h3><p>Technical recruiting at Symbiont got off to a rocky start. Developing a repeatable process for hiring top-tier engineers in such a competitive job market was daunting to the point of seeming unachievable. Today, we have nearly 100 employees and we’ve stayed true to our initial objective: invest in engineering talent rather than building out a bulky sales function. In fact, our team has more than tripled in size in the last two years alone. This blog post explains in part how we got here, describing Symbiont’s recruiting philosophy and the process that implements it, as well as various lessons we learned along the way.</p><h3>The Difficulties of Recruiting in “Blockchain”</h3><p>Building an engineering team from scratch is always challenging, but in our industry it is especially tricky. First, the entire “blockchain” space revels in its esotericism and obfuscation. The blockchain technology space is still so new, and so different from everything that came before it, that it is steeped in unfamiliar terminology and unconventional development practices. More than a decade after the term “blockchain” itself was coined, we’re still inundated with meandering debates as to what a blockchain even is! This kind of ambiguity can make it difficult not only to communicate to potential hires what it is we are building, but additionally to distinguish our own technical vision from that of radically different engineering approaches that nominally fall under the same “blockchain” label.</p><p>The other major challenge has been the justifiably mixed reputation that the industry has among engineers in general. More than in many other industries, what falls under the umbrella of “blockchain”-whether it be the rampant charlatanism, get-rich-quick schemes, illegal securities offerings, etc.-has undeniably had a negative impact on how engineers outside of the space view the potential for companies in it to operate in an ethical fashion. We’ve had to work hard to distance ourselves from these bad actors, and prove that, on the contrary, we have a valuable mission and a product that is already making positive, impactful changes. Doing this was a critical precondition to attracting the full range of engineers we needed to realize our vision in building the engineering team we have today.</p><h3>Recruiting Philosophy and Corporate Culture</h3><p>But it’s not enough to know how to attract engineers to join your team and commit themselves to your mission. We also needed to create a recruiting strategy that would allow us to actualize the corporate culture that we had set out and worked to foster from day one among the founders. That culture is centered on the importance and impact of the individual, and emphasizes personal autonomy and empowerment. We believe that when a company embraces these values it can thrive without byzantine reporting structures and give every team member a greater sense of purpose and significance, making them even greater assets to the organization. We acknowledge that this puts great responsibility on everyone who joins us, and that anyone on the team who does not thrive in an environment like ours imperils not only themselves, but the broader organization. For this reason, we would always rather not hire someone than hire the wrong person.</p><h3>The Process</h3><p>With all of the above considerations in mind, we had to come up with a pragmatic system for communicating to recruits who Symbiont is in order to slowly build up a team of highly talented engineers that would fit well in our corporate culture. Two additional constraints stood out:</p><ol><li><strong>A balance must be struck between brevity and thoroughness. </strong>In technical recruiting especially, it is foolhardy to think a candidate will stay in limbo to complete an unduly lengthy process, instead of accepting one of the several offers they usually have at hand.</li><li><strong>Hiring cannot easily be automated and therefore does not scale well.</strong> Naively, recruiting scales in the amount of time one dedicates to it. But the process’s resistance to automation poses the question whether and how it can be optimized.</li></ol><p>How any organization reacts to these conditions must motivate its entire recruiting strategy, for together they parameterize whom and how it hires. With regards to (1), when forced to choose between thoroughness and brevity, Symbiont has taken the principled stance of risking losing candidates in exchange for greater certainty in the hires we do make. In respect to (2), Symbiont quickly came to the conclusion that attempting to optimize recruiting by borrowing principles from software engineering is something of a category error. Instead of process automation, therefore, we focus on improving the precision of our job descriptions and making sure each step in our recruiting process is a meaningful gate.</p><p>In general, we eschew abstraction in our recruiting process in order to maximize the quality of hires at the cost of hiring velocity. The nature of our technology is that it is extremely complicated, nuanced and challenging to develop; the nature of our market, institutional finance, is that the sales cycle is naturally long; our product often touches the back- and middle-office and, contrary to recent trends, is self-hosted, not SaaS. All of this means that security and correctness-and not velocity-are paramount.</p><p>To that end, we had to accomplish two independent goals:</p><ol><li>Filter candidates out of our recruiting pipeline that we thought would not succeed at Symbiont</li><li>Get candidates excited about our mission and our approach!</li></ol><p>We quickly discovered that, unfortunately, these objectives are often at odds with one another. Any company, but above all one that is understaffed and early stage, is inclined to ignore signs that a candidate is not a good fit, and to say or to do whatever it takes to get them onboard. But recruiting is not transactional; getting someone to join is the first in an unending series of negotiations in order to ensure that they remain productive members of the team. We are not exempt from this temptation, and so, as an interview process comes to its conclusion, we do our best preemptively to surface what we see as potential points of friction; either between a candidate’s expectations and their stated role in the company, or the way we operate more generally.</p><p>The picture thus communicated strays meaningfully from how startups often represent themselves. For example, though far from spartan, we do not offer those perks which, in our opinion, in their extravagance contribute to the prevalent, yet cartoonish depiction of what it is like to work in tech. We make clear that as an early-stage company trying to solve some of the most intractable problems in institutional finance, we need to use what resources we have to achieve our business purposes.</p><p>When pitching Symbiont to any candidate, we always emphasize the aspects of the company that will make as clear as possible whether they are excited and motivated by what we believe are our most salient qualities. Our greatest asset in recruiting is, therefore, by far, the existing team, among whom are experts across a wide range of disciplines and industries. Those who want to join Symbiont tend to find the prospect of being the smartest person in the room much less exciting than being surrounded by others from whom they can learn. A corollary to this is that those who are motivated by upward mobility self-select out during the process. This, in part, is how Symbiont has been able to avoid having any middle management even as our headcount nears one hundred; our recruiting process clearly separates off those who are unaligned with our flat structure, which allows us to preserve and strengthen the latter.</p><h3>Conclusion</h3><p>Symbiont has always been an ambitious enterprise. Our objective is the replacement of core infrastructure for institutional financial markets, infrastructure that has often been in place for decades. To make that happen, we have needed to use some of the most innovative technologies around, and we’ve had to execute to the highest standards of quality, security and robustness. None of that would have been possible without hiring great engineers, and rallying everyone on our team around a shared culture and mission. Our philosophy for how we approach the challenges of growing a team, and our particular hiring process that has grown out of that philosophy, have served us well so far. We hope that in sharing our experiences we can help other companies avoid the trial-and-error we had to go through in order to build such a great team.</p><p><em>Originally published at </em><a href="https://symbiont.io/blog/2020/4/6/hiring-at-symbiont"><em>https://symbiont.io</em></a><em> on April 6, 2020.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d8cf55d75c73" width="1" height="1" alt=""><hr><p><a href="https://medium.com/symbiont-io/hiring-at-symbiont-d8cf55d75c73">Hiring at Symbiont</a> was originally published in <a href="https://medium.com/symbiont-io">Symbiont</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Achieving the Enterprise Blockchain Big Three]]></title>
            <link>https://medium.com/symbiont-io/achieving-the-enterprise-blockchain-big-three-cefe53b561cc?source=rss-fb910bb7fa04------2</link>
            <guid isPermaLink="false">https://medium.com/p/cefe53b561cc</guid>
            <dc:creator><![CDATA[Symbiont.io]]></dc:creator>
            <pubDate>Sun, 08 Mar 2020 12:01:01 GMT</pubDate>
            <atom:updated>2020-03-08T12:01:01.859Z</atom:updated>
            <content:encoded><![CDATA[<p><strong><em>By Katie Clay</em></strong></p><p>Symbiont is pushing the boundaries of blockchain technology, bringing it into the mainstream for enterprises. Each client of ours, whether it’s a big bank or another type of financial institution, will run an instance of our platform (we call these <em>nodes</em>). From there, each node transacts with each other in a more streamlined way than current methods. As a solutions engineer on the team, it’s exciting to be part of the organization leading the financial services infrastructure revolution and defining how enterprise blockchain platforms should be built.</p><p><strong>Consistency, Confidentiality, and Decentralization</strong></p><p>An enterprise blockchain model ideally should maintain consistency, confidentiality, and decentralization among all nodes in a given network. Any two of these attributes are tricky to support; finding the intersection of all three is a downright conundrum. Public blockchains are consistent and decentralized at the obvious cost of confidentiality. Many permissioned blockchains, while introducing confidentiality, must also introduce some degree of centralization (be it through operators, notaries, and the like) to verify consistency. How is it possible to integrate three qualities with seemingly opposing characteristics?</p><p><strong>Secure Channels</strong></p><p>Enter: secure channels. They work like this:</p><ol><li>Every node receives an encrypted value for every single transaction that takes place on the network.</li><li>Users can become part of a group-or <em>channel</em> — where the transactions are encrypted with a unique key for that channel.</li><li>When members of a particular channel create a transaction, only members from that same channel have the key to decrypt the encrypted value.</li></ol><p>All three enterprise blockchain virtues are preserved: <strong>consistency</strong> is achieved by each node having identical transaction logs, <strong>confidentiality</strong> is maintained through encryption, and <strong>decentralization</strong> is accomplished through not requiring centralized verification. Any potential eavesdropping node trying to peek at transactions will only ever see encrypted gibberish, eliminating the possibility of users — individuals authorized to perform transactions on a node — “hacking” their way in. Secure channels provide everything expected of a good permissioned blockchain.</p><p>Now that we know more about secure channels, that begs the question: how do users interact with them?</p><p>The user who creates a secure channel is automatically added to said channel, and also becomes that channel’s <em>owner</em>. Once a member of a secure channel, the user can invite others to the channel by sending them the key needed to encrypt/decrypt transactions for that channel. Once a key has been given, it can never be taken away; any users with the key can use it from that moment until the <strong>end of time</strong>. This could pose a problem if there are members you no longer want to share information with.</p><p>Owners of a channel can remedy this by changing (we call it <em>rotating</em>) the key necessary to encrypt/decrypt transactions in that channel. The owner who rotates the key is the only one who automatically receives the new key. Members of the original channel she wants to retain will need to be sent the new key again (or she can relish in her newfound solitude). Once keys are sent to the desired members (if any), knowledge sharing can resume. Owners also can elect to create/remove other owners in the channel, granting/eliminating the ability to rotate keys.</p><p><strong>Implications</strong></p><p>So, now that we know a bit more about our privacy model, why do we care?</p><p>Great question! Channels inform a huge part of how smart contracts are written. Defining transaction functionality is as straightforward as a standard coding project. In fact, many transactions can be written into the <em>PUBLIC</em> channel, which is our keyword for the secure channel everyone in the network is automatically part of.<em> </em>However, introducing channels also means introducing a bevy of security implications to think about:</p><ul><li>What transactions need (or don’t need) to be restricted to channels?</li><li>Are there users that should be added to certain channels from the get-go? How do you handle sending out keys to them?</li><li>When is it appropriate to add other owners to the channel?</li><li>What if information written into one channel is necessary for computations in another? (This is a blog post for another day.)</li><li>Should only certain members of a channel be allowed to write a transaction versus just read channel data? How do you lock down that functionality to just those members?</li><li>And the list goes on!</li></ul><p>With all of these considerations, secure channels are not only a fantastic security solution. They force you to elevate your coding and planning games, making you a better engineer in the process.</p><p>— — —</p><p><em>Shoutout to the wonderful Sarah Lee, Anna Savarin, and Nathan Wells for not only helping me with this blog, but for helping pave the way for women like me in this field! To all the women building something exciting, happy International Women’s Day!</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cefe53b561cc" width="1" height="1" alt=""><hr><p><a href="https://medium.com/symbiont-io/achieving-the-enterprise-blockchain-big-three-cefe53b561cc">Achieving the Enterprise Blockchain Big Three</a> was originally published in <a href="https://medium.com/symbiont-io">Symbiont</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Extreme Programming (Part Three): Incremental, Insured, Collective Engineering — Symbiont.io]]></title>
            <link>https://medium.com/symbiont-io/extreme-programming-part-three-incremental-insured-collective-engineering-symbiont-io-ab98614eb9f7?source=rss-fb910bb7fa04------2</link>
            <guid isPermaLink="false">https://medium.com/p/ab98614eb9f7</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[extreme-programming]]></category>
            <category><![CDATA[blockchain]]></category>
            <dc:creator><![CDATA[Symbiont.io]]></dc:creator>
            <pubDate>Fri, 14 Feb 2020 00:00:00 GMT</pubDate>
            <atom:updated>2020-02-14T14:55:26.608Z</atom:updated>
            <content:encoded><![CDATA[<h3>Extreme Programming (Part Three): Incremental, Insured, Collective Engineering — Symbiont.io</h3><p><em>By: Anna Savarin</em></p><p>Welcome back to our three-part series on XP, or eXtreme Programming, from the Mortgages team at Symbiont. Check out the earlier posts in the series, where my colleagues Alex Bennett and Jeffrey Lin shared the <a href="https://symbiont.io/blog/2019/10/31/extreme-mobbing-part-one-an-outcomes-driven-perspective">business owner</a> and <a href="https://symbiont.io/blog/2019/12/5/extreme-programming-part-two-test-driven-development-and-small-batch-development">product manager</a> perspectives. As an engineer on Symbiont’s Mortgages team, I will share my point of view on how our team has adopted XP practices and their impact on our work.</p><h3>Getting Started: Benefits of Incremental System Design</h3><p>Our client is asking our team to build powerful and complex software. Great! Where do we begin? Between the blinking cursor on our proverbial blank page and a fully functional product with thousands of users, hundreds of screens, and massive throughput of data, lies a long road. We are talking about years of work as well as teams of subject matter experts (SMEs), designers, and product, software, and infrastructure engineers.</p><p>Like any daunting task, the answer lies in breaking it down into smaller pieces. One way to tackle these pieces could be to build them one by one, to completion. However, those of us who write software know that life is not so simple: these pieces will interact with one another and reveal information about each other and the system as a whole. You cannot get away with building one and then calling it done — you will certainly learn something down the line that will cause you to revisit. So if you cannot predict how the pieces will interact, or how they will shape the overall design, it can be more effective to get to know your future system incrementally. In practice, this means building a small enough portion of each piece at a time to put a skeleton in place, something that partially works end-to-end. You can then continue to refine and adjust as you come back to your pieces and add more “meat” to them.</p><p>Often, even in agile environments, development teams are tempted to build components and modules in a depth-first sort of way. They overengineer the foundational layers, only to discover later that the target they have been optimizing for has diverged from how the business requirements and the code have evolved. We have all seen those giant architecture design documents and kick-off meetings followed by lengthy implementations. In the XP approach, your design will come together incrementally, as a continuous course correction informed by hindsight observation rather than a prediction. Your task as an engineer is to ensure that your system fits your requirements on exactly that day. The next day, when you inevitably learn something new, you will refactor your code to enhance your skeleton, and to make sure that your system has evolved to meet the new requirements.</p><p>Such an incremental approach has enormous advantages to both the engineering team and the client. When the time comes for you and your team to tease out architectural patterns, you do so based on facts of what is already written. Unlike heated and unproductive debates rooted in forward-looking intuition, this method facilitates convergence based on actual, existing code. It also offers early visibility into the system for engineers and for users. Engineers can de-risk parts of the system they do not understand by building a small enough portion to know which questions to ask and to answer.</p><p>From the client’s perspective, they have an improved experience as well. The incremental approach delivers value to the customer in the shape of small features that are enhanced incrementally. This establishes a continuous value stream consisting of these small pieces of functionality. Clients have the chance to step in and revise their requirements as development continues. This type of flexibility is key, as clients are also getting to know the future system, from the user perspective. This process gives them room to address the edge cases that inevitably come up. Engineers can take wrong turns that are low-cost. So can clients.</p><h3>Test-Driven Development and the Safety Net of Automated Tests</h3><p>With this description of the incremental approach, I hope to convey a sense of movement. The code is volatile; it bends and twists constantly. Refactoring is a continuous task, aimed not only at improving code maintainability, but also at formalizing the emerging patterns we observe, as well as fitting in new requirements that arise.</p><p>You might be wondering, how can we keep changing our code so much and be confident that our system still works? We have the comprehensive suite of our unit, integration, and end-to-end automated tests as insurance and crash pad. It is the result of the XP — and our — TDD (test-driven development) approach to writing software.</p><p>TDD is valuable not only for the resulting safety, but also for the mechanics of the development process itself. For an engineer, it can be easy to become overwhelmed when building or enhancing a feature: your mind can instantaneously sprawl out to dozens of use cases and edge cases, leaving you stuck and paralyzed. Writing a failing test somehow breaks this pattern, and focuses your attention on passing the one case. Perhaps this is because it puts you in the shoes of the consumer of your code — as a result of which you also design better interfaces. Writing that first failing test is much easier than that first line of code.</p><p>It is also easier to continue writing failing tests incrementally in order to keep working up to your requirements. You go from failing to passing — red to green — and, ding! You get that jolt of satisfaction, and you reach for more. Next test, and next test, and you are in that coveted developer flow, where you “wake up” hours later, with working code and an insurance policy for your future self.</p><p>The level of confidence you have when you go in for a refactor while insured by a test suite makes all the difference. Writing code becomes a source of pleasure, not anxiety. You are free to experiment, turn the whole thing upside down, make changes as deep as you like, and you can rest easy that your tests will validate that your code still works.</p><p>XP consists of many other practices and, frankly, I can rave about it for hours. In fact, there was too much to fit in one blog! In a follow-up piece, I’ll dive deeper into the collaborative aspect of XP and our unique approach to working together at Symbiont.</p><p>For all of its payoffs, XP is also hard. It sets a high bar for excellence of results, but it requires rigor and commitment from everyone involved. What I appreciate most about XP is that it embodies a kind of reverence and care for the product that you build. My sincere personal hope is that XP gains wider adoption in software development and everyone builds better products that users can trust as a result.</p><p><em>Originally published at </em><a href="https://symbiont.io/blog/2020/2/14/extreme-programming-part-three-incremental-insured-collective-engineering"><em>https://symbiont.io</em></a><em> on February 14, 2020.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ab98614eb9f7" width="1" height="1" alt=""><hr><p><a href="https://medium.com/symbiont-io/extreme-programming-part-three-incremental-insured-collective-engineering-symbiont-io-ab98614eb9f7">Extreme Programming (Part Three): Incremental, Insured, Collective Engineering — Symbiont.io</a> was originally published in <a href="https://medium.com/symbiont-io">Symbiont</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Smart Contracts on Permissioned Blockchains Pick Up where Satoshi Left Off]]></title>
            <link>https://medium.com/symbiont-io/smart-contracts-on-permissioned-blockchains-pick-up-where-satoshi-left-off-79772f268bb3?source=rss-fb910bb7fa04------2</link>
            <guid isPermaLink="false">https://medium.com/p/79772f268bb3</guid>
            <category><![CDATA[fintech]]></category>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[smart-contracts]]></category>
            <category><![CDATA[finance]]></category>
            <category><![CDATA[enterprise-blockchain]]></category>
            <dc:creator><![CDATA[Symbiont.io]]></dc:creator>
            <pubDate>Tue, 21 Jan 2020 20:36:48 GMT</pubDate>
            <atom:updated>2020-01-21T20:36:48.606Z</atom:updated>
            <content:encoded><![CDATA[<p>By Adam Krellenstein</p><h3>Trustless tokens are still the best use for a public blockchain.</h3><p>Ten years after the anniversary of the publication of the Bitcoin whitepaper — inarguably one of the most significant technical achievements in recent history — the community that it created, and that has rallied around its grand vision, is in a crisis. Having worked for the past decade to produce protocols that go far beyond Satoshi’s original efforts in scale and ambition, we are still struggling to answer fundamental questions about the nature of the technology and the role it should play in our society — -fundamental questions such as “What is a blockchain?” and “What is a blockchain good for?” We struggle to understand the relationship between Bitcoin and blockchain technology, between token systems and smart contracts, and between public blockchains and permissioned ones.</p><p>There is one camp that sees blockchain technology as being best suited for creating digital currencies (“tokens”) like Bitcoin itself, and there is another that sees the technology as promising for creating new kinds of decentralized computer applications (“smart contracts”). Simultaneously, another fight is going on about the value of different types of blockchain networks — -specifically, whether blockchains should be “public”, so that anyone can join the networks, or “permissioned”, where the membership of the network is more or less fixed. In fact, these two arguments are tightly linked: it turns out that token systems are more useful than smart contracts when layered on a public blockchain consensus protocol.</p><p>Looking back to the Bitcoin whitepaper today, it is striking that Satoshi was exactly right about the best use for a public blockchain: a digital currency and payment system. The white paper only talks about token systems and public blockchains, so we are left on our own to figure out how best to take his seminal invention and extend it to additional use cases in new domains. And many have tried to do just that. For my part, I’ve spent a lot of time thinking about these issues, having had the rare experience of working closely with both sides of both debates. First, as one of the creators of the cryptocurrency Counterparty, and then as one of the founders of Symbiont. Counterparty is a public blockchain smart contracts platform, albeit one focused on token issuance and trading, while Symbiont is a fintech company that develops and licenses its permissioned blockchain-based smart contracts system to improve the infrastructure of traditional financial markets.</p><p>What I noticed in my time working on Counterparty, and in watching Ethereum closely since its inception, was that even though both systems were built primarily to support powerful smart contracts applications, their primary uses have been in the creation and transfer of the simplest possible digital instruments — -tokens. With Counterparty, our vision was to create a trustless network for decentralized finance with no middlemen. We implemented smart contracts for token balances, the world’s first decentralized and trustless asset exchange, a platform for prediction markets using contracts for difference, a protocol for transparent elections, and a system for provably fair gaming. And we did it all as an extension of the Bitcoin blockchain itself, rather than as a separate network. Nevertheless, Counterparty’s adoption was always centered around its token issuance and trading functionality, rather than on the more advanced and more exciting applications that it enabled.</p><p>Similarly, it’s been three years since Ethereum launched and pretty much the only thing anyone is using it for could be easily managed by <a href="https://en.bitcoin.it/wiki/Colored_Coins">colored coins</a> (another way of adding support for simple tokens on top of Bitcoin). Ethereum has received a lot of attention and produced a lot of excitement for its theoretically limitless capabilities, but to date people are actually using it only for the simplest possible decentralized applications. Part of the reason that Ethereum’s adoption has been lackluster is that it’s quite hard to build real applications safely in their smart contract language, Solidity. Still, it’s surprising that the most advanced Ethereum smart contract with any adoption is a <a href="https://www.cryptokitties.co/">cat-themed trading card game</a>, not dissimilar to <a href="https://spellsofgenesis.com/">Spells of Genesis</a> or <a href="https://medium.com/@coin_and_peace/rarepepe-is-the-most-innovative-project-in-the-crypto-space-seriously-6d6b74749687">Rare Pepes</a>, which were launched on Counterparty long before. Ethereum, like Counterparty before it, has been used almost exclusively for tracking tokens despite its potential for doing much more.</p><p>The reason, I think, is that a smart contract system for the general public isn’t actually such a great idea<em>. </em>The value in taking a given application and putting it on a blockchain platform is chiefly found in making that application more broadly accessible and trustless. This is of enormous value for a simple instrument like digital cash, which benefits directly from wider adoption and purity of form. That is, Bitcoin, as a payment system and store of value without (easy) confiscation, debasement, etc., is a <em>better currency</em> than fiat insofar as it lacks the central points of control and interference. But for more complicated interactions among end users, where efficiency is more important than universality, it’s not too difficult or painful to rely on a “higher authority” to act in the role of a trusted intermediary. The interactions of individuals are not complex enough to justify being turned into decentralized computer programs, not yet.</p><p>In the realm of permissioned blockchains, on the other hand, smart contracts hold more promise. The target users aren’t individuals, they are large institutions, e.g. governments and corporations. The greatest benefit of permissioned blockchains is not more inclusiveness or transparency, but rather greater consistency and correctness than existing infrastructure, which is incapable of a providing single source of truth for multiple parties in a decentralized fashion. “Enterprise DLT” aims to take existing business logic managed by faxes and phones, then codify that logic as a shared computer application which automates workflows and reduces operational overhead. Large institutions tend to engage with their peers in intricate and complex ways, and, insofar as they are large institutions, there’s no natural third-party <em>qua </em>“higher authority” that they could rely on for global coordination. Ideally, this coordination would be managed by a blockchain and smart contract acting as a shared system of record and single source of truth, without giving a single party ‘superuser’ access to a central, canonical repository for mission-critical market data.</p><p>A blockchain is a way for multiple parties in a decentralized computer network to see a consistent view of the world, so blockchain technology can primarily be valuable <em>either </em>when replacing a consistent <strong>centralized</strong> system with a consistent <strong>decentralized</strong> one (the way Bitcoin replaces fiat currency), <em>or</em> when turning an <strong>inconsistent</strong> decentralized system into a <strong>consistent</strong> decentralized system (the way a smart contract would replace fragmented financial markets infrastructure). In the former case, the value created is in disintermediation of a central party; in the latter, it’s in the increased efficiency of a coherent, authoritative source of truth in a decentralized system. It’s fitting, then, that token systems — the simplest possible smart contracts — -should be as widely accessible as possible, whereas smart contracts are most useful in permissioned settings, where they are faster, cheaper, and easier to use, and where they can solve a particular business problem in a deliberate and controlled manner.</p><p>The conclusion that I’ve come to is that, just as was originally envisioned by Satoshi Nakamoto, the greatest use of a public blockchain is in fact as a digital currency and payment system. Generalizations of Satoshi’s innovations in the time since he launched Bitcoin, manifest partly in the growing enterprise DLT space, are not competitive with Bitcoin itself. Instead of replacing fiat currency with digital gold, they may be used to build new kinds of databases that can support workflows that are completely un-amenable to management within the context of a traditional client-server framework. Efforts to build complex smart contracts on public blockchain networks aren’t tackling problems inherent in the design of existing decentralized systems (the way Bitcoin did); but rather are striving to become more usable versions of centralized systems. They are, of course, anything but.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=79772f268bb3" width="1" height="1" alt=""><hr><p><a href="https://medium.com/symbiont-io/smart-contracts-on-permissioned-blockchains-pick-up-where-satoshi-left-off-79772f268bb3">Smart Contracts on Permissioned Blockchains Pick Up where Satoshi Left Off</a> was originally published in <a href="https://medium.com/symbiont-io">Symbiont</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Assembly™: The Blockchain for Enterprise Finance]]></title>
            <link>https://medium.com/symbiont-io/assembly-the-blockchain-for-enterprise-finance-cd6d1a803766?source=rss-fb910bb7fa04------2</link>
            <guid isPermaLink="false">https://medium.com/p/cd6d1a803766</guid>
            <category><![CDATA[enterprise-blockchain]]></category>
            <category><![CDATA[blockchain]]></category>
            <dc:creator><![CDATA[Symbiont.io]]></dc:creator>
            <pubDate>Tue, 21 Jan 2020 20:33:59 GMT</pubDate>
            <atom:updated>2020-01-21T20:33:59.717Z</atom:updated>
            <content:encoded><![CDATA[<p>By: Adam Krellenstein and Ben Spiegelman</p><p>Symbiont Assembly™ is a blockchain platform designed for enterprise finance. Today it is being used by some of the world’s largest financial institutions to not only create efficiencies in their existing workflows but also to help them completely reimagine their business models. In particular, Symbiont has partnered with large institutions within Index Data (Vanguard), Mortgages (Ranieri Solutions), and Syndicated Loans (Ipreo) to name a few.</p><p>Although each of our clients across different verticals have unique business logic and workflows, they all are using the same underlying blockchain software, Symbiont Assembly. Assembly is a proprietary blockchain platform that has been designed and developed by expert engineers in cryptography, distributed systems, financial engineering, and programming language design with direction from experienced leaders in capital markets and enterprise finance.</p><p>Assembly was built to solve problems within enterprise finance that arise when you have multiple institutions who need to:</p><p>Confidentially share data and logic</p><p>With a single source of truth and no central authority</p><p>Assembly is a blockchain and smart contracts platform (Blog — Smart Contracts and Institutional Finance) designed to model and automate complex multi-party workflows while maintaining a single source of truth in a decentralized environment and respecting the strictest privacy rules.</p><p>There are two primary types of blockchain platforms: public and permissioned. Assembly is a permissioned blockchain, which just means that it doesn’t allow for anonymous participation — you need to get permission before you can join a given network. A public blockchain, by contrast, allows anyone on the Internet to participate. Public blockchains (such as Bitcoin and Ethereum) need to have:</p><p>An integrated cryptocurrency, to incentivize honest behavior and</p><p>A proof-of-work mechanism (or something very similar), to protect against identity spoofing</p><p>Permissioned blockchains work the same way public blockchains do, except that instead of PoW they use a consensus protocol like PBFT (<a href="http://pmg.csail.mit.edu/papers/osdi99.pdf">http://pmg.csail.mit.edu/papers/osdi99.pdf</a>) or Mod-SMaRt (<a href="http://www.di.fc.ul.pt/~bessani/publications/edcc12-modsmart.pdf">http://www.di.fc.ul.pt/~bessani/publications/edcc12-modsmart.pdf</a>), which is much faster, more energy efficient, and offers stronger transaction finality (<a href="https://en.bitcoinwiki.org/wiki/Chain_Reorganization">https://en.bitcoinwiki.org/wiki/Chain_Reorganization</a>).</p><p>Assembly has a number of innovations which make it especially appropriate for use in financial markets. First, transactions on the network are encrypted so that only specifically authorized participants in the network are able to view the contents of the messages. Assembly never reveals private transaction data to any central authority; all encryption is fully peer-to-peer. Users are able to employ the Assembly blockchain network for all of their private communications, with the network maintaining a perfect audit trail of everything that happens on it, rather than have to relegate private communication to being “off-ledger”. Even better, this privacy scheme comes with strong consistency guarantees, which are necessary to avoid recreating the very reconciliation problems that the blockchain platform was meant to solve.</p><p>Second, unlike many other “DLT” platforms, Assembly is truly decentralized even as it provides for strict transaction confidentiality. Other DLT platforms aren’t blockchains, and they aren’t decentralized. They rely on trusted third parties to maintain consistency (e.g. prevent double-spends) in the network. These central authorities serve as single points of failure and generally compromise the core value proposition of blockchain technology, which is to provide a security model that cannot be achieved with traditional, centralized systems. With Assembly, every node executes each transaction independently (for those transactions it can decrypt), and every node signs each transaction it creates.</p><p>Finally, with Assembly, powerful smart contracts — decentralized applications — automate complex multi-party workflows with fine-grained authorization logic. They prevent both unintentional and malicious behavior of anyone on the network from disrupting the correct operation of the system. This is something only a blockchain can do: prevent errors from ever occurring, instead of attempting to detect and fix them after the fact. A system which does any less is a centralized system under a new name, and its users would be better served by sticking with existing technology.</p><p>Within finance, institutions are generally unwilling to trust a central entity to completely control market infrastructure and to be relied upon as the primary source of truth for all information on the instruments that they create and trade. Assembly enables the participants in the network to maintain the peer-to-peer nature of their transactions with no central authority, while also receiving the benefits of a shared database with end-to-end privacy. Our partners and clients are using Assembly to build the next wave of financial infrastructure without having to surrender control of their data or their direct relationships with their clients. Together we hope to build a more efficient, transparent and safe infrastructure for the financial services industry and the end user.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cd6d1a803766" width="1" height="1" alt=""><hr><p><a href="https://medium.com/symbiont-io/assembly-the-blockchain-for-enterprise-finance-cd6d1a803766">Assembly™: The Blockchain for Enterprise Finance</a> was originally published in <a href="https://medium.com/symbiont-io">Symbiont</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Smart Contracts and Institutional Finance]]></title>
            <link>https://medium.com/symbiont-io/smart-contracts-and-institutional-finance-82cb0db8af0a?source=rss-fb910bb7fa04------2</link>
            <guid isPermaLink="false">https://medium.com/p/82cb0db8af0a</guid>
            <category><![CDATA[smart-contracts]]></category>
            <category><![CDATA[finance]]></category>
            <category><![CDATA[finance-and-banking]]></category>
            <category><![CDATA[financial-services]]></category>
            <category><![CDATA[blockchain]]></category>
            <dc:creator><![CDATA[Symbiont.io]]></dc:creator>
            <pubDate>Tue, 21 Jan 2020 20:32:29 GMT</pubDate>
            <atom:updated>2020-01-21T20:32:29.071Z</atom:updated>
            <content:encoded><![CDATA[<p>By Adam Krellenstein and Ben Spiegelman</p><p>The adoption of blockchain technology within institutional finance promises to massively improve speed, efficiency, transparency and correctness of critical financial market infrastructure. For too long, technological innovation in this industry has been largely limited to the front office, while the back office has been ignored and neglected. This is like building a second story on a house with a rotting foundation.<strong> Smart contracts are the applications of the next generation of financial market infrastructure</strong>, providing the means for finally abandoning antiquated systems which cannot keep up with the pace of innovation in the modern world.</p><p>A smart contract is a “contract” that governs the behavior of computers instead of people and organizations. And a blockchain, by virtue of being an internally consistent, decentralized system, can serve as a platform on which stateful decentralized applications, such as smart contracts, can run. With blockchain technology, financial instruments can be objects in the smart contracts.</p><p><strong>When a blockchain is used as the system of record for financial instruments, a smart contract will do more than just improve operational workflows; it will transition traditional financial markets onto a digital infrastructure shared by all market participants. </strong>Blockchain technology enables financial instruments to suddenly take a digital form for the first time.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/0*CmMU6GTWK7A2_AXH.png" /></figure><p><strong>Financial markets are naturally decentralized</strong>, so the infrastructure for trading and tracking ownership of assets should be, too. Financial markets have historically relied upon point-to-point communication using faxes and telephones to synchronize all of the different financial ledgers that may be found in each marketplace. But this is extremely inefficient, in particular because of the 1) analog nature of these media and 2) the consistency issues that arise from not having a single source of truth.</p><p>Financial markets are sometimes forced to rely upon partially centralized infrastructure because a central database can provide a single source of truth in otherwise decentralized ecosystems. The Depository Trust &amp; Clearing Corporation (DTCC), which provides clearing and settlement services to some financial markets, is a great example of partially centralized infrastructure. It is a whole entity dedicated solely to hosting a central database for establishing a single source of truth in the ownership of securities. But the DTCC is just a band-aid:<strong> participants in securities markets still maintain their own internal ledgers </strong>which are often out of sync with the DTCC’s ledger.</p><p>Even when there is supposed to be a single canonical ledger hosted by a central authority, all of the market participants still want to maintain their own ledgers, so reconciliation problems persist. Financial markets are then forced to exist in an awkward hybrid state, with the same reconciliation issues as would have existed otherwise (or worse!). These infrastructure problems manifest as long trade settlement times, difficulties in proxy voting, incorrect share ownership, and many other issues.</p><p>Symbiont, with its Assembly blockchain platform, is using smart contracts to model the complex business logic and multi-party workflows of traditional financial instruments that may themselves live wholly on a blockchain network.<strong> These smart contracts can model the complete lifecycle of a financial instrument.</strong> With a loan, for instance, they can keep track of ownership, trades, interest payments, interest rate changes, who is in default, notifications, approval workflows. A blockchain network, as an internally consistent decentralized system, may establish the canonical state of those instruments in a single network shared by all market participants.</p><p>Any software application can model that same behavior, but <strong>if it is not running on a decentralized system, then it cannot also serve as a single source of truth for an entire financial market.</strong> It will never be more than a hybrid solution that creates as many problems as it solves. When a blockchain platform is coupled with an expressive and powerful smart contract system that preserves the highest standard of security and confidentiality, there arises the possibility of transforming financial market dynamics: automating manual processes, cutting out unnecessary middlemen, improving transparency, shortening settlement times, augmenting security, eliminating errors and decreasing overall risk.</p><p>Assembly’s smart contract language is specifically designed for this purpose. It includes an advanced module system, supports <strong>contract versioning and upgrading</strong>, is <strong>fully deterministic</strong> and has built-in support for true <strong>end-to-end transaction privacy</strong>. The Symbiont smart contract language allows for the creation of large and sophisticated decentralized applications that actually prevent accounting errors from ever appearing instead of merely detecting discrepancies after the fact.</p><p><strong>Symbiont is at the forefront of the development of this exciting new technology</strong>, which allows us to reimagine an entire industry that has been burdened by technological half-measures, and to reshape it into an elegant form that fits its fundamental nature.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=82cb0db8af0a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/symbiont-io/smart-contracts-and-institutional-finance-82cb0db8af0a">Smart Contracts and Institutional Finance</a> was originally published in <a href="https://medium.com/symbiont-io">Symbiont</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Blockchain Technology and Institutional Finance]]></title>
            <link>https://medium.com/symbiont-io/blockchain-technology-and-institutional-finance-3f813ea10012?source=rss-fb910bb7fa04------2</link>
            <guid isPermaLink="false">https://medium.com/p/3f813ea10012</guid>
            <category><![CDATA[fintech]]></category>
            <category><![CDATA[finance]]></category>
            <category><![CDATA[blockchain-technology]]></category>
            <category><![CDATA[blockchain]]></category>
            <dc:creator><![CDATA[Symbiont.io]]></dc:creator>
            <pubDate>Tue, 21 Jan 2020 20:30:30 GMT</pubDate>
            <atom:updated>2020-01-21T20:30:30.426Z</atom:updated>
            <content:encoded><![CDATA[<p>By Adam Krellenstein</p><p>This is the first in a series of non-technical blog posts we will publish in the coming months, which will help users understand how Symbiont’s technology works and why we made design choices that make Symbiont different than competing platforms and a better choice for many uses in institutional financial markets. We’re built from the ground up for institutional finance. Smart Securities®, Intelligent Markets!</p><p>With interest in blockchain technology gripping the institutional financial sector today, there is a great deal of confusion about the true nature of the technology, and specifically how it is different from what has come before. The promise to dramatically improve financial infrastructure is well established, but it’s often not clear why the benefits associated with blockchain technology cannot be had with traditional technology.</p><p>The problem that the financial sector hopes to solve by using blockchain technology is that of duplication and reconciliation of administrative processes and data. To illustrate, standard practice in the syndicated loan market involves a dozen banks receiving the same fax, each entering the same data contained on that fax into their internal ledgers, and then reconciling any discrepancies which arise. Blockchain technology solves the duplication-and-reconciliation problem by creating a distributed ledger: a single record of financial transactions that may be shared among multiple institutions. The adoption of a distributed ledger can solve very real, very great inefficiencies that financial institutions face in the coordination of all of their back-office systems and associated operational costs.</p><p>The naïve solution to this problem is to appoint a single entity to maintain a master set of records for the entire market to use. However, this third party must be trusted to keep all records accurately, securely and (if applicable) confidentially. A blockchain, by contrast, allows multiple parties to share records in a manner that all can trust as valid, simply by the design of the protocol.</p><p>But if the problem is solved by allowing parties to share a master copy of data, why not use just a distributed database instead of a distributed ledger? The majority of the most popular SQL and NoSQL databases can function as distributed databases, in fact… Problem solved? No.</p><p>A distributed database is a type of database that shares its data among multiple computers. We want a database that can share information among multiple institutions. That’s something else entirely. In fact, no existing database was designed to do this. Even the most scalable, globally distributed databases are all designed to be hosted by a single party, and this assumption is baked into their design at a very low level. You can’t just take an Oracle database, give each bank a node and call it a day. The security model is totally different. Everyone would be able to see and change everyone else’s data, as well as bring down the whole network on a whim.</p><p>For a distributed ledger to work what you really need is not only a distributed system but also a decentralized system: one that multiple, independent parties can use to share information. There are plenty of decentralized systems out there, though you may not think of them as such. Faxes are a great example of a decentralized system. Email, the Web, BitTorrent, and Git are others. The problem with any of these systems, though, is that everyone’s data is inconsistent, based on which messages or files each particular user happened to send and receive. What you really need is something like Google Docs, but without Google. And for finance!</p><p>There are two crucial pieces to building a distributed ledger: decentralization and a single source of truth.* Blockchain technology meets both of these requirements, and no other kind of software does.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/0*9-w_kWmMWIpKIpXT.png" /></figure><p>What blockchain technology allows for, beyond a distributed ledger, is nothing less than a fundamentally new class of computer systems: decentralized like email, but with a single source of truth like a traditional database. Note that so-called “permissioned blockchains” (such as the one Symbiont is building) are networks in which the identities of all of the participants are known to each other. There exists a more general kind of decentralized system which additionally allows for anonymous network participation (such as Bitcoin). Because of the stronger assumptions around the identity of network constituents, permissioned networks can be faster, scalable and more reliable than permissionless ones.</p><p>Blockchains aren’t magic; they aren’t a panacea. There are many problems which blockchain technology cannot solve, and many places where other technologies are more appropriate. The fact is that many companies in the “blockchain technology” space are building either 1) decentralized systems with no single source of truth, or 2) a centralized systems that rely on trusted third-parties to validate network events. In the case that either of these systems is sufficient, there exist well-established software solutions that will work better (and faster!) than any blockchain. Nevertheless, blockchain technology represents a real innovation in computer engineering. And, in the right circumstances, it can radically improve transparency, efficiency and security of the very core of financial markets infrastructure.</p><p>*The idea for this definition is taken shamelessly from an excellent blog post by Albert Wegner.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3f813ea10012" width="1" height="1" alt=""><hr><p><a href="https://medium.com/symbiont-io/blockchain-technology-and-institutional-finance-3f813ea10012">Blockchain Technology and Institutional Finance</a> was originally published in <a href="https://medium.com/symbiont-io">Symbiont</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Moving Cash Through a Blockchain]]></title>
            <link>https://medium.com/symbiont-io/moving-cash-through-a-blockchain-7137b2606492?source=rss-fb910bb7fa04------2</link>
            <guid isPermaLink="false">https://medium.com/p/7137b2606492</guid>
            <category><![CDATA[blockchain]]></category>
            <dc:creator><![CDATA[Symbiont.io]]></dc:creator>
            <pubDate>Tue, 21 Jan 2020 20:26:58 GMT</pubDate>
            <atom:updated>2020-01-21T20:26:58.624Z</atom:updated>
            <content:encoded><![CDATA[<p>By: Nathan Wells</p><p>When we at Symbiont show our platform to people in the finance industry one simple question comes up: “How does cash move through the blockchain?” Here’s a simple answer: it doesn’t. The immediate follow-up question is of course: “How do you expect us to trade securities without cash? Do you really expect us to use Bitcoin?” That requires a little bit more detail and consideration.</p><p>The short, and somewhat academic, answer is that we embed a token-based money system inside our smart contract system. A token is a representation of an asset in the “real world” on a system. In order to get these tokens, you’d go to your blockchain-enabled bank, move money into a specially designated blockchain account. Your bank would lock the funds, record a transaction via a smart contract on the blockchain, which deposits the tokens into your account on the blockchain network. These tokens can be redeemed by the bank at any time for money, in the form of a transfer into the account you already have with the bank, or some other transfer mechanism.</p><p>A short aside for those already familiar with Bitcoin and blockchain tokens: The way Symbiont has implemented tokens is very different (and, in our opinion, far superior) to the way Bitcoin has with color coins. We’ll explore the differences in a future blog post.<br>That seems a bit opaque, so let’s illustrate with an example: Let’s tell the story of Bob and Sam.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/60/0*HZ5FIRlRKZXkPhMS" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/0*DMsiFbhHpNlO3Lsz.png" /></figure><p>Bob is an investor with cash. Sam holds shares of private common stock of his startup.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/60/0*6yT6GzlxbXBNcRwr" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/0*paGGMRhtSW50KQ_o.png" /></figure><p>Bob and Sam are old childhood friends who meet up after many years in a bar. Sam tells Bob all about his startup, and Bob asks if he can get in on the action. Sam’s been wanting to take a vacation, so he decides it would be a good idea to get some cash. They flesh out a basic deal:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/60/0*Kg6Qz2cJHQEcGaM_" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/0*gnAzdCYupnM5R--D.png" /></figure><p>Here’s the problem, though: Sam’s shares are stored on the blockchain, while Bob’s cash is in a savings account at ABC Bank.</p><p>At this point, I’ll ask you to indulge me in pretending that we live only in a consumer banking world. There are analogues in investment banking, of course, but everyone has at least a basic understanding of how consumer banking works.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/60/0*cbtoE8xjM8YKXOy_" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/0*iTGvvgz4HBbHs1S9.png" /></figure><p>Luckily ABC Bank is connected to the blockchain network that holds Sam’s shares. Bob gets on a call with his local branch and tries to figure out how to make this work.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/60/0*MmtUCEVcO3GnTGyr" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/0*YYN80ASTtkVDhATw.png" /></figure><p>The customer support agent on the other end of the line explains that he can get blockchain cash by transferring his money into a special blockchain account. Blockchain cash is what’s referred to as a fiat token. It’s essentially an IOU that Bob can redeem for cash from ABC Bank. If he transfers the tokens to another person that has an account at ABC Bank (or another bank on the same blockchain), they can do the same! In other cases, a wire or ACH transfer can be set up.</p><p>Bob creates his blockchain account and has the customer support agent transfer money from his traditional checking account into the blockchain account. ABC bank puts the money into a locked account (acting as a custodian of the money) and issues USD tokens to Bob’s blockchain account.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/60/0*hUHmI9QmFw2wDzDX" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/0*uVu3W3xOypDS9r9r.png" /></figure><p>Once Bob’s confirmed the tokens are in his account, he tells Sam. Sam sets up an account for Bob on the blockchain node that tracks investors of his startup. Once Bob’s on the system, Sam initiates a trade of the shares and Bob confirms the trade. The assets (tokens and shares) are instantly transferred on the blockchain.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/60/0*ld5mN_FA4sxHjwf6" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/0*zTUNz-IGynA4hBgW.png" /></figure><p>Sam now wants to get the cash, so he can buy his plane tickets and make all his plans. He’s got an account at ABC Bank, so he just has to redeem his tokens (which showed up instantly once Bob confirmed), and the funds are deposited into his account.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/60/0*vo7Sjh9XDgGIgfoG" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/0*OZtW6FZASWP7FBv8.png" /></figure><p>Well, that was easy!</p><p>To review, Bob got tokens in exchange for his USD via his bank, which he exchanged on the blockchain with Sam for stock. Sam was then able to redeem the tokens for cash (and go on vacation).</p><p>There are a couple of great things about this: first, the token-based model works for any real-world assets; and secondly, the transaction settled immediately — practically unheard of in traditional exchanges. Another interesting side note: the stock asset itself, and the underlying contract, are stored and executed purely on the blockchain; but that’s a blog post for a different time.</p><p>See? It’s easy to move money around on the blockchain! If you’d like to see it in action, get in contact with us.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7137b2606492" width="1" height="1" alt=""><hr><p><a href="https://medium.com/symbiont-io/moving-cash-through-a-blockchain-7137b2606492">Moving Cash Through a Blockchain</a> was originally published in <a href="https://medium.com/symbiont-io">Symbiont</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Extreme Programming (Part Two): Test-Driven Development and Small-Batch Development]]></title>
            <link>https://medium.com/symbiont-io/extreme-programming-part-two-test-driven-development-and-small-batch-development-206ee523565c?source=rss-fb910bb7fa04------2</link>
            <guid isPermaLink="false">https://medium.com/p/206ee523565c</guid>
            <category><![CDATA[test-driven-development]]></category>
            <category><![CDATA[blockchain]]></category>
            <category><![CDATA[extreme-programming]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Symbiont.io]]></dc:creator>
            <pubDate>Thu, 05 Dec 2019 00:00:00 GMT</pubDate>
            <atom:updated>2019-12-05T17:31:39.417Z</atom:updated>
            <content:encoded><![CDATA[<p><em>By: Jeffrey Lin</em></p><p>Welcome back to a three-part series on Extreme Programming (XP), where different members of Symbiont’s mortgage team discuss our development methodology from distinct perspectives: business owner, product manager and engineer. In <a href="https://symbiont.io/blog/2019/10/31/extreme-mobbing-part-one-an-outcomes-driven-perspective">part one</a>, my colleague Alex Bennett shares his perspective on leading an XP team, the economics of pair/mob programming, and how XP practices can foster accountability across a team.</p><p>As a product manager on Symbiont’s mortgage team, I will provide my perspective on XP engineering principles in the second installment of the series. My goal is to cover two core tenants of XP: test-driven development (TDD) and small-batch development. More notably, I will discuss how these tenants have brought about more effective ways to gather requirements and project plan for our team.</p><h3>Test-driven development</h3><p>Test-driven development (TDD) is a results-based method of development, where engineers write software to test the outcomes of an implementation as the first step of developing any feature. Tests are meant to be simple and establish a clear scope for the development ahead. Aside from being a well-defined goalpost, tests can be executed against the code implementation at any time to validate if the success criteria have been met.</p><p><strong>Requirements can be test-driven and exist as true living documentation<br></strong>Our team has extended test-driven practices beyond engineers and further upstream into requirements gathering with subject matter experts (SMEs) and business analysts. Entrusting SMEs to define requirements eliminates room for interpreting the software’s expected outcome. Once they’re defined, requirements can be written in the form of executable tests rather than as unactionable abstracts. Tests, unlike written documentation, can be run to confirm the validity of code. The results of each test represent the true state of the application at that given point in time. These tests become true, living documentation. This practice is known in behavior-driven design as ‘specification by example.’ Although not endorsed directly by XP, ‘specification by example’ is a natural extension of test-driven development.</p><p><strong>Overcoming the hurdle of coding with non-technical SMEs and business analysts<br></strong>While our team believes it is essential to include SMEs and business analysts in the process of defining requirements, there is a high barrier to entry for writing tests with code. To overcome this hurdle and simplify the process, Symbiont uses FitNesse, an open-source software that abstracts code away and allows non-technical people to specify requirements in the form of tests. Built as a wiki, FitNesse is a repository of documentation where each page can also be made into an automated test script. Writing tests is an intuitive process, where users express requirements as inputs and outputs in tables. Here are two simple examples:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*4vdz3hmqDExSP3FL" /></figure><p>The engineering team starts with a “failing” FitNesse test. Their goal is to pass the test for feature completion, similar to the way unit tests are structured in TDD. Each time new code is deployed, the entire test suite is run automatically, and any failed tests will cause the breaking change to rollback.</p><p>Our team uses FitNesse as the single source of truth for requirement specifications. This commitment extends to the SMEs on our project. The benefits of ‘specification by example’ are diminished if the SMEs do not ensure requirements are reliable and up-to-date. So far, we have mapped out our application’s taxonomy and created hundreds of tests. FitNesse acts as the medium of communication for day-to-day collaboration between engineers, product and SMEs. During a cross-functional working session, SMEs can view the current state of the application and provide requirements changes directly in the tests without needing to dig into code or perform manual tests. Immediately after, engineers can leverage these tests for development without needing to interpret requirements from written specifications.</p><h3>Small-Batch Development</h3><p><strong>Using team experimentation to validate complex products<br></strong>The objective of small-batch development is splitting features into digestible pieces, which then allows for quicker development and feedback loops. Our product demands a highly collaborative environment across disciplines to fully utilize the properties of a blockchain and solve business needs within the mortgage space. The XP model provides a framework where features are kept lightweight to ensure more user engagement. The constant interaction with the business domain equips the engineering team to identify new ways of leveraging our blockchain platform. Earlier this year, our team created a lightweight demo with three end-to-end user journeys to validate with prospective clients and partners. Instead of building fully featured user journeys, we built just enough to meet our objective. Each user journey was pared down with SMEs to the minimum fidelity required for a demo. This allowed us to validate our value proposition without a fully functional application.</p><p><strong>Developing to inform planning<br></strong>Beyond the demo, Symbiont has extended small-batch development to guide long-term project planning by mapping out the rest of the application. Building small and across features has helped surface blindspots and previously unknown complexities. Where there are known uncertainties, the team uses development <em>spikes</em>, or time-boxed research efforts to help gain understanding. As the team gains expertise throughout the application, we can plan longer-term and make more informed decisions. This experimental process of small-batch development may seem counterintuitive, especially when working on a project with a fixed deadline. Instead of investing heavily in upfront planning, project plans following XP evolve to address newly identified priorities and delivery risks based on prior development efforts. Product development and planning become interwoven and are done throughout the project.</p><p><strong>Research-based approach<br></strong>You might be asking yourself: Why does Symbiont practice XP? Critics of XP point to the infrastructure and cultural investments required to sustain an XP team. Put simply, we use this methodology because it works. The synergies of small batch development and results-based development primes our team for solving complex multi-party workflows. Our decision is also grounded in evidence. <a href="https://www.amazon.com/Accelerate-Building-Performing-Technology-Organizations/dp/B07BMBYHXL">Recent research </a>, conducted between 2013 and 2017 and spanning 2,000 organizations, showed that practicing lean product management (i.e small-batch development, short client feedback loops, and authorized engineering engagement) improved software delivery. Nicole Forsgren, Jez Humble and Gene Kim, the authors of “Accelerate: Building and Scaling High Performing Technology Organization,” observed that these lean practices predicted higher organizational performance as measured by customer satisfaction, profitability and market share.</p><p>XP can be used as a starting point and framework to address projects with conditions of uncertainty. The framework, which promotes collective experimentation, requires deep commitment and trust from the entire team. Everyone, including SMEs and users, provide feedback on your application. To reap benefits from XP, it is essential to cultivate a very specific environment and culture. By adopting XP’s engineering principles, we have established new practices in gathering requirements and planning. This allows us to best solve the problems that exist within the mortgage market with Symbiont’s enterprise blockchain technology.</p><p><em>Originally published at </em><a href="https://symbiont.io/blog/2019/12/5/extreme-programming-part-two-test-driven-development-and-small-batch-development"><em>https://symbiont.io</em></a><em> on December 5, 2019.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=206ee523565c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/symbiont-io/extreme-programming-part-two-test-driven-development-and-small-batch-development-206ee523565c">Extreme Programming (Part Two): Test-Driven Development and Small-Batch Development</a> was originally published in <a href="https://medium.com/symbiont-io">Symbiont</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>