Rhombus

rhombus

Plain Rectangular Box Kites

The art of rolling a leaf

THE POPLAR-WEEVIL

In this article, we will look at the process of building a diagram with the help of Elkjs and React Flow libraries. We hope our tutorial will be useful for you and will shed some light on using React Flow and Elksj. We will be (a library for creating apps based on nodes) for visualization (rendering). And we will for calculating the elements’ positions. Before starting the actual process of building a diagram, let’s first review the main concepts and terminology that we will be using in this article. using React Flow use Elkjs Dependencies required for the project: react react-dom react-flow-renderer elkjs First, we need to create an empty React project and install the abovementioned dependencies. The main terms used in React-flow: — a draggable unit that can be connected to other nodes. Node — a connection between two nodes. Edge —  a sort of a node port that is used for connecting nodes. You start the connection with one handle and end it with another. Handles Getting back to the initial topic, say, we need to build the following diagram: The diagram consists of eight nodes of three types: a circle - elements that are used to indicate start and end (circleNode) a rectangle - elements that are used to describe a certain process (rectangleNode) a rhombus - an element of choice (rhombusNode) Now let’s create a Flow.js file where we will describe the Flow component. It will be responsible for rendering the elements of the diagram. We will import the <ReactFlow /> component from 'react-flow-renderer' import ReactFlow from 'react-flow-renderer';

function Flow() {
 return (
   <ReactFlow
     nodes={nodes}
     edges={edges}
  />
  
 );
} In order for everything to function properly, you will need to pass over nodes and edges to <ReactFlow>. Below you can see the initial data that we will use in our app ( the initialData.js file) export const initialNodes = [
 {
   id: "1",
   type: "circleNode",
   data: { label: "Request PTO" },
   position: { x: 250, y: 25 }
 },

 {
   id: "2",
   type: "rectangleNode",
   data: { label: "manager reviews data" },
   position: { x: 240, y: 125 }
 },
 {
   id: "3",
   type: "rhombusNode",
   data: { label: "Pending manager approval" },
   position: { x: 250, y: 250 }
 },
 {
   id: "4",
   type: "rectangleNode",
   data: { label: "PTO request approved" },
   position: { x: 150, y: 350 }
 },
 {
   id: "5",
   type: "rectangleNode",
   data: { label: "PTO request denied" },
   position: { x: 400, y: 350 }
 },
 {
   id: "6",
   type: "rectangleNode",
   data: { label: "Notify teammate1" },
   position: { x: 150, y: 450 }
 },
 {
   id: "7",
   type: "rectangleNode",
   data: { label: "Notify teammate2" },
   position: { x: 400, y: 450 }
 },
 {
   id: "8",
   type: "circleNode",
   data: { label: "End" },
   position: { x: 250, y: 550 }
 }
];

export const initialEdges = [
 {
   id: "e1-2",
   source: "1",
   target: "2"
 },
 {
   id: "e2-3",
   source: "2",
   target: "3"
 },
 {
   id: "e3-4",
   source: "3",
   target: "4"
 },
 {
   id: "e3-5",
   source: "3",
   target: "5"
 },
 {
   id: "e4-6",
   source: "4",
   target: "6"
 },
 {
   id: "e5-7",
   source: "5",
   target: "7"
 },
 {
   id: "e6-8",
   source: "6",
   target: "8"
 },
 {
   id: "e7-8",
   source: "7",
   target: "8"
 }
]; Each Node and Edge should have a unique identifier. The node will also need the position and data. For Edge, obligatory parameters will also include source and target. More information on the options can be found here: , Options. Node Edge Since the diagram uses elements of different forms and sizes, the layout of nodes by default will not be suitable. In order to create a node with custom settings, we will use a - Custom Node. As we already defined three types of elements, we will create three Custom Node components in separate files: React Flow feature CircleNode.jsx import { Handle, Position } from "react-flow-renderer";

const CircleNode = ({ data, id }) => {
 return (
   <div className="circleNode">
     {data.handles[0] ? (
       <Handle type="target" position={Position.Top} id={`${id}.top`} />
     ) : null}
     {data.handles[1] ? (
       <Handle type="source" position={Position.Bottom} id={`${id}.bottom`} />
     ) : null}
   </div>
 );
};
export default CircleNode; RectangleNode.jsx import { Handle, Position } from "react-flow-renderer";

const RectangleNode = ({ data, id }) => {
 return (
   <div className="rectangleNode">
     {data.handles[0] ? (
       <Handle type="target" position={Position.Top} id={`${id}.top`} />
     ) : null}

     {data.handles[1] ? (
       <Handle type="source" position={Position.Bottom} id={`${id}.bottom`} />
     ) : null}
   </div>
 );
};
export default RectangleNode; RhombusNode.jsx import { Handle, Position } from "react-flow-renderer";

const RhombusNode = ({ data, id }) => {
 return (
   <div className="handles-container">
     <div className="rhombusNode"></div>
     <Handle type="target" position={Position.Top} id={`${id}.top`} />
     <Handle type="source" position={Position.Bottom} id={`${id}.bottom`} />
   </div>
 );
};
export default RhombusNode; We will use the Handle component to connect the custom node with other nodes. Then we will add new node types to the nodeTypes props. const nodeTypes = {
 circleNode: CircleNode,
 rectangleNode: RectangleNode,
 rhombusNode: RhombusNode
}; It is important that node types are remembered by useMemo or are defined outside of the component. In our case, we defined them outside of the component. Otherwise, React will be creating a new object during every rendering and that will lead to performance issues and bugs. At this stage, the Flow.jsx component looks something like this: import { useState } from "react";
import ReactFlow from "react-flow-renderer";
import { initialNodes, initialEdges } from "./initialData";
import CircleNode from "./CircleNode";
import RectangleNode from "./RectangleNode";
import RhombusNode from "./RhombusNode";

const nodeTypes = {
 circleNode: CircleNode,
 rectangleNode: RectangleNode,
 rhombusNode: RhombusNode
};

function Flow() {
 const [nodes, setNodes] = useState(initialNodes);
 const [edges, setEdges] = useState(initialEdges);

 return (
   <ReactFlow nodes={nodes} edges={edges} nodeTypes={nodeTypes} fitView />
 );
}

export default Flow; The file with .css styles: html,
body,
#root {
 width: 100%;
 height: 100%;
 margin: 0;
 padding: 0;
 box-sizing: border-box;
 font-family: sans-serif;
}
.circleNode {
 background-color: #02a9ea;
 background-image: url("https://img.icons8.com/doodle/48/000000/sun--v1.png");
 height: 50px;
 width: 50px;
 border-radius: 50%;
 border: 1px solid black;
}

.rhombusNode {
 display: block;
 position: absolute;
 transform: rotate(45deg);
 background-color: #a600ff;
 top: 10px;
 right: auto;
 width: 50px;
 height: 50px;
 border: 1px solid;
 z-index: -1;
}
.handles-container {
 position: relative;
 background-image: url("https://img.icons8.com/color/48/000000/decision.png");
 background-repeat: no-repeat;
 background-position: center;
 background-size: contain;
 height: 70px;
 width: 50px;
}
.rectangleNode {
 background-color: #ffd000;
 background-image: url("https://img.icons8.com/external-flaticons-lineal-color-flat-icons/45/000000/external-process-productivity-flaticons-lineal-color-flat-icons-2.png");
 background-position: center;
 height: 50px;
 width: 70px;
 background-repeat: no-repeat;
 border: 1px solid black;
} How the diagram looks: Let’s move on to the Elkjs integration. For that, we will add the automatic calculation of positions of the diagram’s elements and will transfer obtained values to React flow. The Elkjs library is a single ELK object. ELK has a constructor that can be used for the creation of: new ELK (options) - options - not obligatory One of ELK methods is - layout(graph, options) graph (obligatory) ELK JSON format - object configuration (if you need it) options Terms used in ELKjs: Graph: a set of nodes and edges and everything that is related to them (labels, ports, etc.). Node: - a node that does not contain child nodes. Simple Node Hierarchical Node - a node that contains child nodes. Edge: : connects two nodes in one simple graph. It is implied that the edge’s source and target nodes both have the same parent node.. Simple Edge : Hierarchical Edge a that exits (or enters) only one in order to get to its goal. In this way, a short connects nodes in nearby hierarchy layers. Short Hierarchical Edge: Hierarchical Edge Hierarchical Node Hierarchical Edge Long Hierarchical Edge: a hierarchical edge that is not a short hierarchical edge. Port: an obvious point of connection on a node to which edges connect. Root Node of a Graph: a minimal public ancestor element of all graph nodes. More on the structure : Graph Data Structure here The JSON graph format has five main elements: nodes, ports, labels, edges, and edge sections. All elements, except for labels, should have a unique identifier (string or integer). Nodes, ports and labels have coordinates (x, y) and sizes (width, height) A graph can be called a simple node, the child elements of which are nodes of the upper graph level. This is why in a graph, child elements (children)  are responsible for transferring a batch of objects (that are based on initialNodes) with features of id, width and height. Since the sizes of custom Nodes differ, we added the node.type check. The graph.js file import ELK from "elkjs";
import { initialNodes, initialEdges } from "./initialData";

const elk = new ELK();
const elkLayout = () => {
 const nodesForElk = initialNodes.map((node) => {
   return {
     id: node.id,
     width: node.type === "rectangleNode" ? 70 : 50,
     height: node.type === "rhombusNode" ? 70 : 50
   };
 });
 const graph = {
   id: "root",
   layoutOptions: {
     "elk.algorithm": "layered",
     "elk.direction": "DOWN",
     "nodePlacement.strategy": "SIMPLE"
   },

   children: nodesForElk,
   edges: initialEdges
 };
 return elk.layout(graph);
};

export default elkLayout; elk.layout(graph) - returns Promise. In case of its successful execution, we’ll get Graph. For our diagram: Now we need to transfer obtained coordinates to React Flow. New nodes is a batch of objects with a set of features of initialNodes and an additional “position”( that is obtained from child nodes graph by id). The process of constructing the batch is described by nodesForFlow(). New edges - a batch of graph.edges objects - is described by edgesForFlow(). Upon successful execution of returned elkLayout() Promise, we transfer the obtained graph to nodesForFlow() and edgesForFlow(). We then write down the execution results in state and use them as new nodes and edges for building a diagram. Flow.jsx looks like this: import { useState } from "react";
import ReactFlow from "react-flow-renderer";
import { initialNodes } from "./initialData";
import CircleNode from "./CircleNode";
import RectangleNode from "./RectangleNode";
import RhombusNode from "./RhombusNode";
import elkLayout from "./graph";

const nodeTypes = {
 circleNode: CircleNode,
 rectangleNode: RectangleNode,
 rhombusNode: RhombusNode
};

function Flow() {
 const [nodes, setNodes] = useState(null);
 const [edges, setEdges] = useState(null);
 const nodesForFlow = (graph) => {
   return [
     ...graph.children.map((node) => {
       return {
         ...initialNodes.find((n) => n.id === node.id),
         position: { x: node.x, y: node.y }
       };
     })
   ];
 };
 const edgesForFlow = (graph) => {
   return graph.edges;
 };

 elkLayout().then((graph) => {
   setNodes(nodesForFlow(graph));
   setEdges(edgesForFlow(graph));
 });

 if (nodes === null) {
   return <></>;
 }
 return (
   <ReactFlow nodes={nodes} edges={edges} nodeTypes={nodeTypes} fitView />
 );
}

export default Flow; The result: A link to the . codesandbox Also published . here

Creating a Simple Diagram by Using Elkjs and React Flow

Hello, guys. This is the second article about SOLID principles with Javascript examples. In my previous , I described what are patterns in general, what is SOLID, and why we should use them. If you haven't read it, pls, read it now and continue to read the current article after the previous one. article "O" -  Open-closed principle. This principle says: Entities (classes, modules, methods, files, etc.) should be open for extension, but closed for modification. From this definition is hard to understand what is going on, but let’s see a few examples. Imagine, the next situation: we have different shapes: circles, squares, triangles. And we should calculate all areas. How can we solve it? Of course, there are many ways how can we do it, but let’s consider the next solution: Let’s create classes for each shape. Nothing hard, just class with different size fields like size, width, height, radius, and type field.  We will use the type field when we will calculate the area of each shape. Let's create a function, which will calculate the sum of all areas, and after that, we will call this function: So, what do we have and where is the problem? Pls, take a look getTotalAreas function. From the first point of view, it seems that everything is ok. But, imagine, if we need to add another shape (circle, ellipse, rhombus) what should we do? We need to create a new class for each of them, define the type and add if/else condition to the getTotalAreas method. So, what problem you may ask. Remember: - Open-closed principle. Let's repeat once more: O This principle says: Entities (classes, modules, methods, etc.) should be open for extension, but closed for modification. In our getTotalAreas, we should make modifications each time, when we want to add a new shape. How can we fix it and make it correctly from the open-closed principle point of view? Let's make getArea method in each class. See the example below. Pls, pay attention that now, "type" field was removed because we don't need it more. And let's see, how getTotalAreas function was changed: Now, we follow the open-closed principle. Why? Because, when we will add another shape, for example, triangle, we will create a new Triangle class (open for extension), define getArea there and that's all. We don't need to change the getTotalAreas function (closed for modification). We need just put new arguments to the array during getTotalAreas call. Now, let's look at another example, more practical. Imagine your client accepting validation error messages in a specific format. Just, for example: And now, imagine, on the server-side, we use different services for validation, it could be our own validation checks and it could be external services that can return errors in different formats. Let me make mock errors, of course, it can be an async request to different external services, but for our purpose let's keep examples as easy as we can. And now, if you remember our format, which the client accept, let's transform all our errors, to the needed format: The result will be as our client expected: So, the problem is the same, we don't follow the open-closed principle. When we need to add a new validation from an external service, we should add new logic (if/else) to getErrors function, we do the modification. Remember? The Open-close principle says: Entities (classes, modules, methods, etc.) should be open for extension, but closed for modification. How can we fix it? One of the possible solutions we can create some general Validation error class. After, we can define some general logic there. Then, we can create for each error, own class (FacebookValidationError, GoogleValidationError). In each class, we can specify methods, like getErrors, or transformErrors, so each validationError class should follow this rule. And then, we will use this validation errors class in our mock function. Of course, now, we can change our function getErrors: Pay attention, in getErrors function, now, I accept errorsList as params, not hardcoded array inside the function. The result will be the same, but now, we follow the open-closed principle. When we want to add a new error, we will create a new validation class (open for extension) for this error and specify getErrors method, which will convert returned format from the external service, for the correct format. And then, we can use it in our getErrors general function, without any changes of this function (closed for modification). I really hope that you enjoyed this article and if you aren't familiar with SOLID and the second principle, this article helps you to understand why is it important and how you can use it with Javascript. I'll be waiting for you in my next article, about the third SOLID principle.

SOLID Principles in JavaScript: What Does the "O" Stand For?

Implementing permissioned blockchain solutions is both equally fascinating and really challenging. Every day, there are new articles in mainstream media outlets claiming how blockchain technologies are going to transform many industries but the reality is not that glamorous. While blockchains bring tremendous value to established enterprise business processes, most permissioned blockchain implementations are not getting passed the pilot phase. After the initial excitement, most teams realize that implementing permissioned blockchain applications at scale require tremendous levels of technological skills and quite a bit of infrastructure building in order to integrate the new Web3 technologies into existing enterprise stacks. Over the last year, our teams have been exposed to highly sophisticated permissioned blockchain scenarios each one with its own set of infrastructure challenges. While sharing our experiences with technologists that have seen several software revolutions, many of them draw parallels to the implementation of web applications in the early days of Netscape or database systems at the beginning of the Oracle or IBM DB2 days. In those instances, the use cases for real world applications of those technologies evolved way faster than the corresponding infrastructure. That dynamic contrasts with recent transformational technology movement such as cloud or mobile computing in which the infrastructure was very solid since the beginning. at Invector Labs What are the real challenges of permissioned blockchain solutions? From core infrastructure areas such as identity, data storage, integration or messaging to the processes for deploying and managing smart contracts; permissioned blockchain apps require developers to setup the right building blocks in place in order to be effective. At Invector Labs, we have been fortunate to experiment to many new blockchain protocols or tools that we regularly used to address the challenges of permissioned blockchain implementations. Unfortunately, that portfolio of tools and techniques looks completely different depending on the underlying blockchain stacks. The road towards any permissioned blockchain application starts with two fundamental decisions: The answer to the first question will determine the core development stack for your blockchain applications. At the moment, stacks like Hyperledger Fabric or variations of Ethereum such as Quorum or Parity are the dominant choices for permissioned blockchain solutions with platforms like R3 Corda or Hyperledger Sawtooth also seeing some level of traction. At least on paper, up and coming stacks like or seem like a great fit for permissioned blockchain solutions but they haven’t been proven in practice yet. Dfinity Hashgraph The answer to the second question will determine the core infrastructure for your permissioned blockchain applications. Provisioning and maintaining on-premise blockchain networks is far from being an easy endeavor and the most permissioned blockchain stacks don’t integrate well with platforms like Docker or Kubernetes. Blockchain as a Service(BaaS) platforms like , or the recent can really streamline the provisioning and management of blockchain networks and allow developers to focus on building dApps instead of infrastructure. Azure BaaS Kaleido AWS offering The following graph illustrates the decision-making process for the two aforementioned questions. The Real Challenges of Permissioned Blockchain Applications Selecting a blockchain platform and the corresponding runtime is just the beginning of the journey. Any permissioned blockchain solution more sophisticated than a glorified database will experience plenty of infrastructure challenges that are not directly addressed by the underlying platform. Let’s explore a few. Integration If you are using smart contracts in your permissioned blockchain application, chances are that you will be faced with the challenge of communicating with off-chain systems of APIs. Oracles are the component of blockchain architectures that handles external communications. However, implementing Oracles is a development intensive exercise. There are several technologies we have found helpful in this area: Chainlink provides a simple programming model for connecting Bitcoin or Ethereum smart contracts to external inputs. The framework also avoids relying on “centralized oracles” as a single point of failure. · Chainlink : A recent entrant in the Oracle race, Rhombus provides a very elegant model for connecting Ethereum smart contracts to external data systems. Rhombus supports different Oracle architectures based on activation modes such as scheduled or on-demand as well as push or pull data access modes. · Rhombus : Oraclize focuses on connecting APIs and data systems to different blockchains such as Ethereum, EOS, Hyperledger Fabric or BlockApps. Oraclize’s programming model is not as rich as some of the other alternatives but it compensates that with a strong support for different blockchains. · Oraclize : Data Access Permissioned blockchains are great for writing information but not so much for reading it. Most real world permissioned blockchain solutions need to interact with the data that is being recorded in the blockchain but that data is both difficult to access and very unintelligible. Here are some protocols that help with that challenge: The Graph provides a mechanism for exposing data processed by Ethereum smart contracts as a GraphQL endpoints. This allows external applications to query blockchain data using familiar GraphQL syntaxs. · The Graph : Data Privacy Many permissioned blockchain scenarios operate in regulated industries with strong data privacy constraints. As a result, protecting and enforcing access control on on-chain data is a key requirement of permissioned blockchain solutions. Below, I’ve listed some of the technologies we have found helpful in this area: The Quorum blockchain provides native support for private transactions using a form of zero knowledge proofs. · Quorum: The recently announced Aztec protocol provides a solid implementation of zero-knowledge privacy in Ethereum smart contracts. · Aztec : Data Storage Blockchains are not the best vehicle for storing large volumes of data. It is not uncommon for permissioned blockchain solutions to require external data storage. Unfortunately, many of the decentralized storage solutions that work well for public blockchains are not applicable in permissioned blockchain scenarios. Here are some solutions in this area: BigchainDB provides a decentralized database model optimized for the storage and query of transactions. Data in BigchainDB can be queried using the MongoDB query language which enables rich data access interactions. · BigchainDB : IPFS is the most popular storage system for blockchain applications but is often seen as a public blockchain solution. However, IPFS supports the configuration of private networks that constrained the communication to a group of well-known nodes. · IPFS Private Network: We are very intrigued by the upcoming launch of the AWS Quantum Ledger Database. The idea of immutability without consensus is certainly practical in many permissioned blockchain scenarios and, if nothing ese, the quantum ledger can become a complementary storage model for private decentralized apps. · AWS Quantum Ledger : Identity One of the main differences of permissioned blockchain solutions is that the identities of the participants in the network are relatively well-known. As a result, many of the complex consensus computation protocols are overkill of simply not needed in those scenarios. Furthermore, most enterprises already have user directories that they would like to leverage in permissioned blockchain solutions. The technologies listed below are helpful to handle identity in permissioned blockchain solutions: uPort has been steadily building a series of protocols and solutions for managing identities in decentralized applications. The current stack is compatible with Ethereum smart contracts and can be leveraged in permissioned blockchain applications · uPort : The Azure team has done a remarkable job extending the core protocols of different blockchain to leverage Azure Active Directory identities. A recent example of this work was the implementation of the . · Azure BaaS: proof-of-authority consensus protocol in Ethereum applications There are plenty of more challenges in permissioned blockchain applications in areas such as messaging, testing, versioning and many others. The protocols and tools listed in this article are some of the most effective solutions we have found in this real world implementations but there are plenty of up and coming technology stacks that might become relevant in the near future.

Five Challenges of Permissioned Blockchain Solutions and the Tools and Protocols that can Help You…

This post is an introduction to containers for non-technical folk. My company delivers machine learning models as containers. Without containers, we’d have a much harder time getting customer adoption, and our cost of customer acquisition would be extremely high. Machine Box Docker — I love these guys http://www.docker.com Docker might be the new electricity. Remember when it was difficult to run a company without electricity? Today, it’s going to be difficult to run a company without some kind of container strategy. Although there are some subtle differences between containers and the presence of an electric charge, the fundamental relationship between resources and output is the same. Allow me to start with the basics. We’re talking about software containers, not those plastic cubes and rhombuses you can put your clothes into. Containers were popularized by a company called Docker, who blew past a billion dollar valuation back in 2015. Perhaps the best way to explain what a software container is, is to compare it to something you might be more familiar with; a virtual machine. A virtual machine is essentially an operating system inside another operating system. You can run Windows inside of a MacOS for example, as a virtual machine. You spin up some software that understands what a virtual machine file looks like, open the file within this environment, and an entire operating system will boot up, isolated from its surroundings (sort of). It has benefits because you can scale this to accommodate large workflows where some specific software needs to be installed and run in a dedicated way. Its also an easy way for vendors of complex software to deliver their product to you without requiring lots of installation and configuration. https://www.geekwire.com/2017/review-parallels-desktop-12-mac-shows-virtual-machine-matters/ But when you spin up a virtual instance of Windows, you’re also spinning up all the stuff inside that operating system that you don’t need. All those drivers, applications, settings, and instances of Solitaire get booted up every time you run that VM. At scale, that is a lot of wasted resources. What are containers? This is where containers comes in. Docker describes it best: A container image is a lightweight, stand-alone, executable package of a piece of software that includes everything needed to run it: code, runtime, system tools, system libraries, settings. It excludes everything you don’t need. They are lean, mean, application machines. Properly architected containers don’t have a byte of unnecessary computerness™ inside. If you’ve made it this far, you might be asking yourself “If developers are making the containers, then what do I need Docker for?” Docker does many things, but primarily it is an agreement between an operating system, and what is inside your container. Just like the software that runs a virtual machine on your computer (of which there are many). How do I scale? Ok, so now you’ve gotten a hold of a container and it runs great on my computer, but how do I scale? Great rhetorical question! This is where the true ROI comes into play, and why companies must start seriously thinking about how they’re going to approach their infrastructure going forward as it pertains to containers. Keep a close eye on something called . Remember all that overhead you’re saving by using a container instead of a virtual machine? Well that really starts to save you money when you consider scaling. Kubernetes is a container orchestrator, which means you can use it to manage millions of containers to work together. This is how the cloud works today. Companies like Google use Kubernetes to manage billions of people searching things every second of every day around the world. Google is a single platform; a single website with a single purpose. Yet it can be used by everyone on Earth, all at once, and somehow not breakdown or bankrupt the company. Think of all the challenges that one is presented with when building a system to scale to that size; load-balancing, security, segmentation, data management, etc. It turns out, combining containers with tools like Kubernetes ( ) lets any company scale to Google’s size (sort of), without breaking the bank. That, my friends, is a return on your investment. Kubernetes there are others to It won’t be possible to provide the kind of scale customers expect without considering a container strategy. So hire a devlops engineer and get started sorting that out now. What is Machine Box? puts state of the art capabilities into so developers like you can easily incorporate natural language processing, facial detection, object recognition, etc. into your own apps very quickly. Machine Box machine learning Docker containers The boxes are , so when your app really takes off just add more boxes horizontally, to infinity and beyond. Oh, and it’s than any of the cloud services ( )… and . built for scale way cheaper and they might be better your data doesn’t leave your infrastructure and let us know what you think. Have a play

Why companies need a container strategy now

Making text awesome! Previously, on “Vector Illustration Basics for Android Developers” _It’s easier than you imagine!_hackernoon.com Vector illustration basics for Android developers - Part 1: Primitive Shapes _Again, simpler than you think_hackernoon.com Vector illustration basics for Android developers — Part 2: Strokes and paths _Still easy!_hackernoon.com Vector illustration basics for Android developers — Part 3: Boolean Operations _Fancy-sounding name, nothing complicated about it_hackernoon.com Vector illustration basics for Android developers — Part 4: z-ordering _Basic but very useful operations_hackernoon.com Vector illustration basics for Android developers — Part 5: Basic Transformations In this bonus part of my “Vector Illustration Basics for Android Developers” series, I’m going to share some tips for making your text stand out. Here’s a scenario for you: a friend comes to you and says “Hey, I hear you’ve been reading Antonis Tsagaris’ vector illustration basics series. What a guy. Anyway. I’ve written a musical called “Sprooglen: A Love Story”, which is about the forbidden love between a Swedish milkmaid and a kangaroo in mid-thirties Berlin and I want you to create the poster for me”. Even though you’re quite perplexed by the plot (everybody knows kangaroos have a deep-rooted hatred of milkmaids, especially Scandinavian ones) you agree to it. So you fire up Gravit Designer, select the Text tool on the top toolbar, it’s the letter “T” …click on the canvas and start writing. You depending on the canvas size change the size of the text select the text, go to “Appearance” on the right panel and change the size …and you have this starting point That’s pretty bad. Let’s fix that. First, select a nice font for the title and another one for the subtitle. After careful consideration I selected Cassanets for the title and Bariol Light for the subtitle, both lovely fonts by http://atipofoundry.com/ To apply a font in Gravit Designer, select the text and then on the Appearance panel, select the font you want to use from the drop-down. If you want to import a font, go to File → Import → Add fonts Here is the poster with the fonts applied (I have also made the background color black and the text white) Much better but… hey! I can hear you guys at the back of the class! I know you could have done this in Microsoft Word. Shut up. Let’s do a trick you cannot do in MS Word. Probably. Select the Pen tool and create an arc. Tap on a point on the canvas to place the first node and then, moving completely horizontally (using the Shift key down while moving the pointer will let you do that with ease) click on another point and, before you release the mouse button, drag the mouse to create the arc. It should look something like this Here comes the cool part: select the Text tool and then click on the arc. Now start writing and something wonderful will happen Yes! Now, let’s remove the nonsense talk and write “Sprooglen!” instead. Also, let’s apply Cassanets to the text again! You need to watch out for something here: if the length of the text is bigger then the length of the arc, the text is going to start wrapping around the arc in some rather funky ways. To deal with something like that, either increase the size of the arc or make the text smaller. You will also notice that when you click on the text that runs along a path, a little orange rhombus will appear at the leftmost side of the text. Use that symbol to move the text along the path. OK, now delete the surplus “Sprooglen!” from the top and make the arc’s stroke width equal to zero to make the stroke disappear but keep the arc. Then, move the curved “Sprooglen” to the top of the design. If you’ve been following the series so far and doing your exercises, this should be child’s play to you. We now have this Huh. Not half bad. But you know what would be awesome? Those “O”s in “SPROOGLEN” would look amazing if we were to enlarge them slightly to make them look like bulging eyes or something. For that, we’re going to need the help of our old friend known as… Convert to path Right now, all the text is just characters. Sure, you can do a lot with that: change their size, size, spacing etc. But to give you a taste of real flexibility, let’s convert them to a path. Converting the text to a path means that we can manipulate it like any vector object but it also means that we lose the ability to change the typeface later (since at this point the text stops being text and becomes indistinguishable to the graphics program from any other shape). So make sure that you’re sticking to the selected font. Ready? Select the text and then go to Modify Path Convert to Raw Path. → → Now your text is a vector shape but you still have one step to perform before the letters are individual shapes. Right now, the entire “Sprooglen!” word is a single shape. So keep it selected and then go to Modify Path →Split Path → Now each letter is a single shape and it’s time to get to work on those “O”s. Double-click each “O” until the nodes pop up. Nodes specify important points in a vector shape, where the path can be manipulated. You can add nodes to any shape to make it more complex but that is beyond the scope of this series. This is what the nodes look like on an “O” Select the topmost node of each “O” and drag it up until you have something like this I think the “eyes” effect is pretty cool! Your homework for today is to fill up the bottom of the poster with a skyline. But there’s a twist! Create the skyline using manipulated letters after you’ve converted them to paths. Let’s see who’s the most creative student around. One more thing… OK, one more cool thing before I retire this series forever (single tear running down my cheek). I’m going to create a tribute to my hometown Larnaca while showing you how to place an image inside text. Create a new project and write your short (preferably) text. Now apply the typeface you want and make it as big as you need it to be. I’m using Frontage Condensed 3D as my font and this is what I have Now, convert the text to a path, just like I showed you earlier. No need to split the path like before, though. Go to File Import →Place image and import the image you want to place in the text. Drop it anywhere on the screen. → On the left of the screen, you should see a panel called “Layers”. It should contain two layers, one called “Compound Shape” which is the converted text and another which will be the name of the image file you imported. We complete the trick by clicking, holding and then dragging the image layer into the text (compound shape) layer. This is the result I got. Of course, yours will be different depending on the image you selected and then placed inside the text And it’s a wrap, ladies and gentlemen. If you enjoyed this article and this series in general, be sure to clap and maybe even donate below. I’m creating a gorgeous book based on this series with expanded content which is now up for pre-order for the ridiculous price of a $3 donation. After release, it’ll go up to its normal price of $15 so STRIKE NOW while the iron is still hot. hot. (more info on the book and donation model follows below) Very HOLY UPDATE, BATMAN! Due to the overwhelmingly positive reaction to this series and the requests of various readers (thank you, your messages made my day!), I have started working on a book version of this series, with expanded content and various exercises that will get you started quickly and efficiently. The book will be released mid-March but you can pre-order it now by going to my BuyMeACoffee page (link below) and (including $3, obviously) Donating $6 or $9 will also get you e-mail support from me while you’re working on the exercises! Stuck? Shoot me an e-mail and I’ll respond at breakneck speed. donating any amount over $3 . and stay there forever (or at least until Michael Bay makes a good movie, which is practically forever), so if you enjoyed these articles and want a gorgeous-looking version with expanded content and more awful jokes, you know what to do! (hint: click the link below) After its release, the book will go to its regular price of $15 when you donate so I can contact you and send you the book as soon as it’s released! IMPORTANT: Leave me a message with your email address _I write about Android, life, the universe and everything._www.buymeacoffee.com Buy Antonis Tsagaris a Coffee - BuyMeACoffee.com

Vector illustration basics for Android developers — Bonus part: Working With Text

Scientific American Supplement, No. 711, August 17, 1889, by Various, is part of the HackerNoon Books Series. You can jump to any chapter in this book . IRIDESCENT CRYSTALS here IRIDESCENT CRYSTALS. By Lord Rayleigh. The principal subject of the lecture is the peculiar colored reflection observed in certain specimens of chlorate of potash. Reflection implies a high degree of discontinuity. In some cases, as in decomposed glass, and probably in opals, the discontinuity is due to the interposition of layers of air; but, as was proved by Stokes, in the case of chlorate crystals the discontinuity is that known as twinning. The seat of the color is a very thin layer in the interior of the crystal and parallel to its faces. The following laws were discovered by Stokes: (1) If one of the crystalline plates be turned round in its own plane, without alteration of the angle of incidence, the peculiar reflection vanishes twice in a revolution, viz., when the plane of incidence coincides with the plane of symmetry of the crystal. [Shown.] (2) As the angle of incidence is increased, the reflected light becomes brighter and rises in refrangibility. [Shown.] (3) The colors are not due to absorption, the transmitted light being strictly complementary to the reflected. (4) The colored light is not polarized. It is produced indifferently, whether the incident light be common light or light polarized in any plane, and is seen whether the reflected light be viewed directly or through a Nicol's prism turned in any way. [Shown.] (5) The spectrum of the reflected light is frequently found to consist almost entirely of a comparatively narrow band. When the angle of incidence is increased, the band moves in the direction of increasing refrangibility, and at the same time increases rapidly in width. In many cases the reflection appears to be almost total. Fig. 1 general scheme In order to project these phenomena a crystal is prepared by cementing a smooth face to a strip of glass whose sides are not quite parallel. The white reflection from the anterior face of the glass can then be separated from the real subject of the experiment. A very remarkable feature in the reflected light remains to be noticed. If the angle of incidence be small, and if the incident light be polarized in or perpendicularly to the plane of incidence, the reflected light is polarized in the manner. [Shown.] opposite Similar phenomena, except that the reflection is white, are exhibited by crystals prepared in a manner described by Madan. If the crystal be heated beyond a certain point the peculiar reflection disappears, but returns upon cooling. [Shown.] In all these cases there can be little doubt that the reflection takes place at twin surfaces, the theory of such reflection ( , Sept., 1888) reproducing with remarkable exactness most of the features above described. In order to explain the vigor and purity of the color reflected in certain crystals, it is necessary to suppose that there are a considerable number of twin surfaces disposed at approximate equal intervals. At each angle of incidence there would be a particular wave length for which the phases of the several reflections are in agreement. The selection of light of a particular wave length would thus take place upon the same principle as in diffraction spectra, and might reach a high degree of perfection. Phil. Mag. In illustration of this explanation an acoustical analogue is exhibited. The successive twin planes are imitated by parallel and equidistant disks of muslin (Figs. 1 and 2) stretched upon brass rings and mounted (with the aid of three lazy-tongs arrangements) so that there is but one degree of freedom to move, and that of such a character as to vary the interval between the disks without disturbing their equidistance and parallelism. The source of sound is a bird call, giving a pure tone of high pitch (inaudible), and the percipient is a high-pressure flame issuing from a burner so oriented that the direct waves are without influence upon the flame (see , xxxviii., 208; Proc. Roy. Inst., January, 1888). But the waves reflected from the muslin arrive in the effective direction, and if of sufficient intensity induce flaring. The experiment consists in showing that the action depends upon the distance between the disks. If the distance be such that the waves reflected from the several disks co-operate, the flame flares, but for intermediate adjustments recovers its equilibrium. For full success it is necessary that the reflective power of a single disk be neither too great nor too small. A somewhat open fabric appears suitable. Nature 2 It was shown by Brewster that certain natural specimens of Iceland spar are traversed by thin twin strata. A convergent beam, reflected at a nearly grazing incidence from the twin planes, depicts upon the screen an arc of light, which is interrupted by a dark spot corresponding to the plane of symmetry. [Shown.] A similar experiment may be made with small rhombs in which twin layers have been developed by mechanical force after the manner of Reusch. The light reflected from fiery opals has been shown by Crookes to possess in many cases a high degree of purity, rivaling in this respect the reflection from chlorate of potash. The explanation is to be sought in a periodic stratified structure. But the other features differ widely in the two cases. There is here no semicircular evanescence, as the specimen is rotated in azimuth. On the contrary, the colored light transmitted perpendicularly through a thin plate of opal undergoes no change when the gem is turned round in its own plane. This appears to prove that the alternate states are not related to one another as twin crystals. More probably the alternate strata are of air, as in decomposed glass. The brilliancy of opals is said to be readily affected by atmospheric conditions. Abstract of the Friday evening lecture delivered by Lord Rayleigh, F.R.S., at the Royal Institution, on April 12, 1889. If the reflection were perpendicular, the interval between successive disks would be equal to the half wave-length, or to some multiple of this. About HackerNoon Book Series: We bring you the most important technical, scientific, and insightful public domain books. This book is part of the public domain. Various (2004). Scientific American Supplement, No. 711, August 17, 1889. Urbana, Illinois: Project Gutenberg. Retrieved https://www.gutenberg.org/cache/epub/16972/pg16972-images.html This eBook is for the use of anyone anywhere at no cost and with almost no restrictions whatsoever. You may copy it, give it away or re-use it under the terms of the Project Gutenberg License included with this eBook or online at , located at . www.gutenberg.org https://www.gutenberg.org/policy/license.html

Stories, News & Mentions about RHOMBUS

Rhombus’s Stories on HackerNoon