<?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 Verifiablee on Medium]]></title>
        <description><![CDATA[Stories by Verifiablee on Medium]]></description>
        <link>https://medium.com/@verifiablee?source=rss-81810eb3b5a3------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/2*67ylUol0jlw4hiqgMF8xsw.png</url>
            <title>Stories by Verifiablee on Medium</title>
            <link>https://medium.com/@verifiablee?source=rss-81810eb3b5a3------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 18:49:24 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@verifiablee/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[  Introducing Niex — interactive Elixir code notebooks built with Phoenix LiveView]]></title>
            <link>https://verifiablee.medium.com/introducing-niex-interactive-elixir-code-notebooks-built-with-phoenix-liveview-a2be6fc2c520?source=rss-81810eb3b5a3------2</link>
            <guid isPermaLink="false">https://medium.com/p/a2be6fc2c520</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[elixir]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Verifiablee]]></dc:creator>
            <pubDate>Mon, 04 Jan 2021 12:25:22 GMT</pubDate>
            <atom:updated>2021-01-04T12:25:22.784Z</atom:updated>
            <content:encoded><![CDATA[<h3>🎉 Introducing Niex — interactive Elixir code notebooks built with Phoenix LiveView</h3><p>Over the past year, I’ve become throughly convinced that Elixir is the language of the future (I’ve written about it previously <a href="https://medium.com/swlh/3-simple-things-that-make-elixir-a-pleasure-to-use-and-one-that-doesnt-8cd9d28e89a8">here</a> &amp; <a href="https://medium.com/swlh/3-months-with-elixir-phoenix-2810f653f887">here</a>). And as I’ve worked with Elixir more &amp; more, it’s become my go-to language for just about everything. For example, I’ve started using it in some data analysis and other exploratory applications where I found myself needing something more than Elixir’s default <strong>iex</strong> REPL. In order to keep track of long chains of data loading &amp; manipulations, I was copy/pasting commands from text files, writing data out to intermediate files, etc — there must be a better way!</p><p>I found myself wishing for something like <a href="http://jupyter.org/">Jupyter</a>, but that I could easily interface with my own native Elixir code. So I started building <a href="http://github.com/jonklein/niex"><strong>Niex: an interactive code notebook for Elixir</strong></a>. Niex lets you organize code, data and text content in a persistent notebook that you can save for later use and share with others. It’s great for data analysis and other applications where you need to keep track of lots of input &amp; output, visualize results and save your work between sessions.</p><p>Here’s a quick sample of Niex in action:</p><figure><img alt="A look at Niex in action" src="https://cdn-images-1.medium.com/max/600/1*CCu-ej38bLdoWiUEArnBGg.gif" /></figure><p>Niex is similar to Jupyter notebooks commonly used with Python (and other language backends, including Elixir) but it’s written in native Elixir, so it’s easy to setup and to integrate with your existing Elixir code. You can even embed it in your own projects simply by including it as a dependency.</p><p>So if you’re using Elixir now and want a richer REPL experience, or if you’re new to Elixir and just want to take the language for a spin, give Niex a try — <a href="http://github.com/jonklein/niex">check out Niex on GitHub</a>!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a2be6fc2c520" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[4 Tips on Asking Customers to Provide Testimonial Videos]]></title>
            <link>https://verifiablee.medium.com/4-tips-on-asking-customers-to-provide-testimonial-videos-b4c19f538eaf?source=rss-81810eb3b5a3------2</link>
            <guid isPermaLink="false">https://medium.com/p/b4c19f538eaf</guid>
            <category><![CDATA[marketing]]></category>
            <category><![CDATA[testimonials]]></category>
            <category><![CDATA[video-marketing]]></category>
            <category><![CDATA[digital-marketing]]></category>
            <dc:creator><![CDATA[Verifiablee]]></dc:creator>
            <pubDate>Mon, 27 Jul 2020 14:32:04 GMT</pubDate>
            <atom:updated>2020-07-27T15:25:15.974Z</atom:updated>
            <content:encoded><![CDATA[<p>In a world of over-produced hype videos and clickbait news story headlines authentic customer voice is a breath of fresh air. Using real customer voice in your marketing is a great way to make real, emotional connections with prospective customers, and to show real-world examples of the problems your product can solve. Though there are lots of ways to use customer voice in your marketing, one of the most powerful is the customer testimonial video.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/0*8tc-CxXEFK6vXwSi.png" /></figure><p>Customers that love your product are often more than willing to help out and share their stories on camera. But to make sure you create the best possible content, what you ask, and how you ask it makes a huge difference. In this post, we go through a couple of tips that can help make sure you generate the best content possible.</p><h3>1. Make a personal connection</h3><p>One of the most important aspects of getting great testimonial content is simply asking the right way-and that starts with a personal connection.</p><p>Avoid generic or mass emails if you can. Though it can sometimes work for large or highly engaged audiences, these tend not to convert very well. Better is to foster a real connection with customers that love your product by sending a personal note. Speak directly to the details of how they’re using your product or service so they understand that their specific experience is important.</p><p>Customers respond best tothe person in your organization they have an existing connection with, so make sure the initial contact comes from that person. This seems obvious, but companies often get this wrong, making the initial contact from the person tasked with building the testimonial rather than somebody with a personal connection. Often the personal connection is with a customer success or service agent, but it could also be the salesperson who first interacted with them or the CEO they learned about the product from, for example.</p><h3>2. Explain why their story matters</h3><p>Engaged customers often want to help companies that they love and are willing to share their experiences. But they may not know what it is about their specific experience that’s so important. In order to help them frame their responses to your questions, you need to explain why their <em>specific</em> testimonial is important to your business.</p><p>The most important question is why you chose this specific customer. Do you want to focus in on the specific problem they’re solving with your product? A particular industry? A specific customer persona? Explaining why their story is important will help to frame the conversation and will lead to better, more cohesive content.</p><h3>3. Make an appointment &amp; provide clear instructions</h3><p>Just like you, your customers are busy. You often get just one shot at recording your footage, so make sure both you and your customer are well-prepared. It’s important to set aside ample time and provide clear instructions so that the opportunity is not wasted.</p><p>If you’re asking customers to capture footage in a “self-serve” fashion using their own devices, it’s important to make sure they set aside a specific time to do it properly so that it doesn’t get rushed or forgotten. One extremely effective way to do this is to reserve a time-slot via an appointment on their calendar, even though you will not actually be meeting.</p><p>Put detailed instruction into the invitation so that your customer knows exactly what you’re asking for. They should already have context as described in the previous step, but in the instructions you can give some light coaching and additional details of what you’re looking for. You should also make yourself available at the time of the meeting via chat or phone, just in case there are any questions. With clear &amp; simple instructions, it probably won’t be needed, but having your contact information lets customers know that you are there to assist them.</p><h3>4. Ask the right questions</h3><p>Asking the right questions for a customer testimonial is more art than science. Your customer testimonial will help tell a story to prospective clients, so as you put together a list of questions to ask a customer, start with the narrative that your testimonial will follow.</p><p>A common narrative to follow is the buyer journey that a customer might follow to solve a specific problem using your product. Frame the problem and talk about the before, during and after. What was it like before they used your product? How does your product help solve that problem? What is it like now that the customer is using your product?</p><p>Over time, you can repeat this process to grow your content library with testimonials that speak to other problems your product can solve, or to other target buyers. For example, your company’s “small business” narrative might be very different than the “big business” narrative, or you may want to build out different content for different types of problems your business can solve. Picking the right questions will help you tell the right stories for your target customers.</p><h3>Finally, use the right tools</h3><p>There are lots of ways to build customer testimonial videos. At the high end, you can work with video crews and production teams who have experience with this kind of content. This approach can build amazing content with great production values, but can also be very time consuming and very costly. If you have video editing experience, you can also build testimonial videos yourself. This is certainly most affordable but even <em>more</em> time consuming.</p><p>Of course, there are lots of great tools and services out there that help with particular aspects of testimonial production, such as the video capture or other editing. Using the right set of tools can vastly accelerate the process, reduce the cost and still produce great results.</p><p>If you’re looking for an end-to-end solution that automates the<em> whole </em>process and helps put the tips in this post into practice, we would humbly suggest you look at <a href="http://verifiablee.com/">Verifiablee’s testimonial automation</a>. Verifiablee automate the entire process including the collection, production &amp; publishing of beautiful fully-branded customer testimonials.</p><p>Whatever approach you take to building your content, keep these tips in mind in order to build out the best customer testimonial video content possible!</p><p><em>Originally published at </em><a href="https://blog.verifiablee.com/4-ways-to-get-customers-to-provide--great-testimonial-videos/"><em>https://blog.verifiablee.com</em></a><em> on July 27, 2020.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b4c19f538eaf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[3 Simple Things That Make Elixir a Pleasure to Use (and One That Doesn’t)]]></title>
            <link>https://medium.com/swlh/3-simple-things-that-make-elixir-a-pleasure-to-use-and-one-that-doesnt-8cd9d28e89a8?source=rss-81810eb3b5a3------2</link>
            <guid isPermaLink="false">https://medium.com/p/8cd9d28e89a8</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[elixir]]></category>
            <dc:creator><![CDATA[Verifiablee]]></dc:creator>
            <pubDate>Thu, 16 Jul 2020 16:13:09 GMT</pubDate>
            <atom:updated>2020-07-20T15:28:04.542Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*4UUb3BhU85SPkkdYkWzm0g.png" /></figure><p>As I <a href="https://medium.com/@verifiablee/3-months-with-elixir-phoenix-2810f653f887">wrote about previously</a>, I’ve been using Elixir for the past several months to build out <a href="https://verifiablee.com/">our new marking video automation platform</a>. In my other post, I talked about some of my initial reactions to Elixir &amp; Phoenix, and tried to give an objective breakdown of how the technologies work, particularly with a comparison to Ruby &amp; Rails, which I’ve used quite a bit in my career.</p><p>That story was not intended to be an Elixir cheerleader post. This story, on the other hand, <em>is</em> intended to be an Elixir cheerleader post. Here, I want to document some of the things I really love about working with Elixir and some of the reasons why I don’t think I’ll be headed back to Ruby any time soon. In particular, I want to describe a couple of neat language and ecosystem features that are really making Elixir a joy to work with.</p><blockquote>This story, on the other hand, <strong><em>is</em></strong> intended to be an Elixir cheerleader post.</blockquote><p>I know that some people reading through these features will shake their fists, “What about Haskell/Lisp/Rust/whatever-my-favorite-language-is?! They’ve had that feature <em>for years</em>!” And they’re right: <strong>none of these features by themselves are unique to Elixir, </strong>and that’s fine<strong> — </strong>but that’s not the point of the post. The point is to describe a particular collection of neat features, which, along with many, many others, make Elixir a pleasure to use.</p><h3>Control flow via pattern matching</h3><p>The first feature I’d like to discuss is <em>pattern matching, </em>and in particular, using pattern matching for control flow in Elixir. Let’s say we need to handle some incoming stream that can provide messages with a variety of message types. In other languages, I’d usually think about writing something like this in a case-statement:</p><pre>def process_message(message) do<br>  case message do <br>    %{type: :start, info: info}  -&gt; consume_start(info)<br>    %{type: :data, data: data}   -&gt; consume_data(data)<br>    %{type: :finish, info: info} -&gt; consume_finish(info)<br>    %{type: type} -&gt; Logger.warning(&quot;Unknown message type: #{type}&quot;)<br>  end<br>end</pre><p>Elixir also has a <em>case </em>statement, so we <em>could</em> do the same thing. But there’s another language feature we can use as well: pattern matching. We can use pattern match against the incoming data to provide a variety of implementations that match the structure of the incoming message:</p><pre>def process_message(%{type: :start, info: info}) do<br>  consume_start(info)<br>end</pre><pre>def process_message(%{type: :start, data: data}) do<br>  consume_data(data)<br>end</pre><pre>def process_message(%{type: :finish, info: info}) do<br>  consume_finish(info)<br>end</pre><pre>def process_message(%{type: type}) do<br>  Logger.warning(&quot;Unknown message type: #{type}&quot;)<br>end</pre><p>With this pattern matching in place, there’s no explicit flow-control statement — we’ve eliminated the <em>case </em>call completely. Whenever we call process message, it will just invoke the correct implementation based on our pattern matching:</p><pre>def receive_message(msg) do<br>  ...<br>  process_message(msg)<br>  ...<br>end</pre><p>This is conceptually similar to the multiple method dispatch found in many languages, in which multiple function implementations can be defined with different classes or types, but pattern matching goes much further. Here, we can actually dispatch on the <em>internal structure or values of the data</em>, not just the <em>type of the data.</em></p><p>The use of pattern matching for flow control can vastly improve the readability of code. Consider the following pseudo-code with a variety of outcomes based on nested conditionals:</p><pre>def run(msg, ctx) do<br>  if msg.state == &quot;ready&quot; do<br>    if length(msg.data) &gt; 0<br>      ...<br>    else<br>      ...<br>    end<br>  else if msg.state == &quot;pending&quot;<br>    ...<br>  else if msg.state == &quot;start&quot; &amp;&amp; !ctx.initialized<br>    ...<br>  else <br>    ...<br>  end<br>end</pre><p>Code like this can be busy and difficult to parse. With pattern matching, we can rewrite the conditional logic by dispatching to different functions based on the input:</p><pre>def run(%{state: &quot;ready&quot;, data: data}, ctx) when length(data) &gt; 0 do<br>  ...<br>end</pre><pre>def run(%{state: &quot;ready&quot;}, ctx) do<br>  ...<br>end</pre><pre>def run(%{state: &quot;pending&quot;}, %{initialized: false } = ctx) do<br>  ...<br>end</pre><pre>def run(_, _) do <br>  ...<br>end</pre><p>Note that in the first implementation, in addition to the pattern match, we have a <em>guard </em>(“when length(data) &gt; 0”) which lets us further refine the match. The last implementation, written as “run(_, _)” matches <em>any </em>value for the two arguments, so it behaves like our final “else” clause in the original example.</p><p>Elixir of course supports more common flow control constructs like “if/else” and “case”, so pattern matching is not used for all flow control. But in many cases, especially when the flow control logic becomes complex, this simple pattern-matching feature can make code simpler both to read <em>and </em>to write.</p><h3>The Pipe Operator</h3><p>I love functional programming, but one of it’s more annoying aspects is “parentheses hell” in which long chains of nested function calls are used to transform data. The result is a deeply nested and difficult to parse expression of functions, like:</p><pre>f(g(h(i(j(k(l(m(n)))))))))</pre><p>Is that right? I don’t even know — I got lost in those parentheses and didn’t even bother to check if they’re balanced. Even though the compiler would kindly tell me if I got it wrong, there’s no denying the ugliness and difficulty both in writing and reading code like that.</p><p>Sadly, through the years, many would-be virtuosos have been driven away from the field of software development by the wounds inflicted by parentheses like these in introductory computer science classes.</p><p>The worst part about expressions like these are that the starting-point of the expression is the inner-most value. That is to say, in the above example, the expression “n” is the starting point for the data, and one must then work backwards to see the chain of transformations applied. And this is just a simple example with each function taking a single argument — add in some other arguments and variable names and the whole thing becomes completely unreadable.</p><blockquote>Sadly, through the years, many would-be virtuosos have been driven away from the field of software development by the wounds inflicted by parentheses like these in introductory computer science classes.</blockquote><p>Though this pattern is common in functional programming languages, it is not exclusive to them — this type of ugly expression can rear its head in just about any language.</p><p>Fortunately, Elixir presents a solution to parentheses hell: the pipe operator. The pipe operator lets us invert this expression and build a pipeline for the data, like a UNIX pipe:</p><pre>n |&gt; m |&gt; l |&gt; k |&gt; j |&gt; i |&gt; h |&gt; g |&gt; f</pre><p>Behind the scenes, all this does is take the output of an expression and put it into the first argument of the following function.</p><pre>x |&gt; f() |&gt; g() == g(f(x))</pre><p>For a real world example, let’s say — just for illustrative purposes — we’re trying to do our own homemade parsing of a CSV configuration file (<a href="http://thomasburette.com/blog/2014/05/25/so-you-want-to-write-your-own-CSV-code/">which we should totally never do</a>, by the way, but it’s a good example).</p><p>To load the file, split the string into lines and then fields, and then process it, we might end up with an expression like this:</p><pre>Enum.map(<br>  Enum.map(<br>    String.split(File.read!(SomeModule.get_path), &quot;\n&quot;),     <br>      &amp;String.split(&amp;1, &quot;,&quot;)<br>  ), &amp;process_line/1<br>)</pre><p>Not the end of the world, but not pretty by any stretch of the imagination. It requires a bit of mental overhead just to find the innermost expression that is the starting point of our computation (“SomeModule.get_path” in this case)</p><p>Using the pipe operator, we can rewrite this expression as:</p><pre>SomeModule.get_path<br> |&gt; File.read!<br> |&gt; String.split(&quot;\n&quot;)<br> |&gt; Enum.map(&amp;String.split(&amp;1, &quot;,&quot;))<br> |&gt; Enum.map(&amp;process_line/1)</pre><p>The updated version reads cleanly top-to-bottom and is easy to understand. And no nested parentheses!</p><p>In addition to simply eliminating parenthesis hell, it also lets us more easily make modifications to the pipeline. One particularly useful example of this is in debugging. We can easily put a call to “IO.inspect” in the middle of the pipeline in those delicate situations in which we have no idea what the hell is going on:</p><pre>SomeModule.load_data<br>  |&gt; clean_data<br>  |&gt; parse_fields<br>  |&gt; complicated_and_error_prone_machine_learning_model_number1<br>  |&gt; <strong>IO.inspect<br></strong>  |&gt; complicated_and_error_prone_machine_learning_model_number2<br><strong> </strong> |&gt; save_processed_data</pre><p>We can put whatever we want into the middle of a pipeline — even an anonymous function for a more nuanced debugging experience. It might be considered bad form to do any real computation this way, but it works quite well for debugging and logging purposes:</p><pre>SomeModule.load_data<br>  |&gt; clean_data<br>  |&gt; parse_fields<br>  |&gt; complicated_and_error_prone_machine_learning_model_number1<br>  |&gt; (<strong>fn d -&gt; if is_bad_data(d), do: IO.inspect(d), else d).()<br></strong>  |&gt; complicated_and_error_prone_machine_learning_model_number2<br><strong> </strong> |&gt; save_processed_data<br></pre><p>Maybe don’t do that in shipping code, but: cool!</p><h3>Natural service boundaries via the OTP</h3><p>One of Elixir’s biggest assets is that it runs on the Erlang VM and uses the Open Telecom Platform (OTP), a runtime library and toolset which manages <em>processes </em>in the Erlang VM. Not to be confused with OS-level processes, Erlang VM processes are extremely lightweight, allowing for many thousands (or hundreds of thousands!) of processes to be run in a single application. Any non-trivial application written in Elixir makes extensive use of the process model to manage computation.</p><p>Processes can pass messages to one another, but they cannot operate on any shared state. Moreover, processes are <em>fully isolated</em> from one another in terms of error handling and fault tolerance. <strong>A failure or exception in one process does not cause the entire application to fail. </strong>In the sense that processes are fully isolated and share no state, interacting with processes within an Elixir application is a bit more like making calls to an external API than like calling a function on an object or struct in other languages.</p><p>The OTP is extremely powerful in and of itself, but one of its more nuanced benefits is that influences how you structure your code. Because there is full isolation and no shared state, the language itself encourages natural service boundaries and pushes developers towards well-isolated, composable, reusable components within an application. In a sense, Elixir/OTP applications get many of the benefits of a microservices architecture (isolation, flexibility, simplicity of components), but without many of the downsides (developer experience, architectural and runtime complexity, latency, etc). It also makes an eventual transition to <em>actual </em>microservices simple: an isolated process running inside of an Elixir app can easily be extracted and run in a separate application on a separate node.</p><p>To see these patterns in action, one can look at apps written with the Phoenix web framework. There are completely separate processes for things like individual web requests, websockets, database connections, connection pools, loggers and much more. Any of these individual processes can fail, even catastrophically, without affecting the application as a whole. And importantly, that guarantee is automatically made through the OTP, not through clever application design.</p><h3>Bonus — One thing that is not a pleasure in Elixir: string keys vs atom keys vs keyword lists</h3><p>Okay, even though this is a cheerleading post, I don’t love <em>everything</em> about Elixir — there are some things I still get tripped up on. One of my biggest annoyances is one that I commonly ran into in the Ruby world, that unfortunately rears its head with Elixir as well.</p><p>Elixir has a built in <em>map </em>data structure, similar to a <em>hash </em>in Ruby. And similar to Ruby’s <em>symbol </em>datatype, Elixir has <em>atoms </em>that are frequently used as keys for a hash:</p><pre>{:name =&gt; &quot;Bob&quot;, :age =&gt; 22}</pre><p>Atoms are so commonly used as keys that there’s a shorthand form of the above as well:</p><pre>{name: &quot;Bob&quot;, age: 22}</pre><p>Of course, maps can take <em>any</em> values as keys, so it’s also possible to use strings :</p><pre>{&quot;name&quot; =&gt; &quot;Bob&quot;, &quot;age&quot; =&gt; 22}</pre><p>The problem is that some interfaces and APIs expect string keys, some expect symbol keys, and some are fine with either — and it’s not always entirely clear by convention or context which is the case. Invariably there are times when one usage pattern collides with the other.</p><p>As an example, the <a href="https://github.com/elixir-ecto/ecto">Ecto library for data mapping</a> happily works with either string keys or atom keys, and atoms <em>do</em> seem like the better match for setting database attributes. So you might happily write your code that that interfaces with Ecto using symbols. But then you find that the Phoenix web framework passes in request parameters as strings. If you use a map of string-key parameters to create or update a model, it works just fine — but if you mix in your code that manipulates the input expecting symbols before it’s inserted into the database, you run into trouble and will need to reconcile the mismatch.</p><p>To add another wrinkle, Elixir has <em>another </em>data structure, the keyword list, which looks like a map and is typically used to specific optional or named parameters to a function call. Under the hood, the keyword list is really a list of tuples (which is confusing in its own regard):</p><pre>[{:x, 1}, {:y, 2}] == [x: 1, y: 2]</pre><p>The solution to all of this is, of course, to know the data the various APIs expect and to be explicit in how it’s used, but it does occasionally trip me up. Having multiple data structures capable of representing similar kinds of data is not a unique problem, but this particular domain of overlapping functionality, combined with Elixir’s dynamic typing system sometimes makes for unexpected surprises.</p><h3>A Pleasure</h3><p>In spite of my occasional misuse of strings &amp; atoms, I still find Elixir <em>a pleasure</em> to use. And these are just some of the <em>simple</em> things I like — there are lots of more profound reasons to love Elixir as well, like the <a href="https://phoenixframework.org/">Phoenix web framework</a>, the Elixir concurrency model and the rock solid foundation of the Erlang VM. But sometimes it’s the simple ergonomics of a language or technology that make the biggest differences for the developer experience, and Elixir definitely delivers.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8cd9d28e89a8" width="1" height="1" alt=""><hr><p><a href="https://medium.com/swlh/3-simple-things-that-make-elixir-a-pleasure-to-use-and-one-that-doesnt-8cd9d28e89a8">3 Simple Things That Make Elixir a Pleasure to Use (and One That Doesn’t)</a> was originally published in <a href="https://medium.com/swlh">The Startup</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[3 JavaScript Banana Peels I Slipped On this Week]]></title>
            <link>https://medium.com/swlh/3-javascript-banana-peels-i-slipped-on-this-week-460dc61a8195?source=rss-81810eb3b5a3------2</link>
            <guid isPermaLink="false">https://medium.com/p/460dc61a8195</guid>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Verifiablee]]></dc:creator>
            <pubDate>Fri, 03 Jul 2020 14:25:02 GMT</pubDate>
            <atom:updated>2020-07-03T20:21:18.245Z</atom:updated>
            <content:encoded><![CDATA[<p><em>This post written by Jon Klein, co-founder at </em><a href="https://verifiablee.com/"><em>Verifiablee</em></a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/791/1*Gb7NjAi2A1IDjjrPt6hj1w.png" /></figure><p>Among other languages, I’ve worked with JavaScript professionally for many years. And yet still, more frequently than I’d like to admit, I manage to introduce some scenario that leaves me — at least temporarily — scratching my head, questioning the very nature of my existence (or at least the nature of JavaScript, but anyway). This week, I ran into a couple of interesting ones I thought it would be good to document.</p><p>I considered describing these scenarios as “landmines I stepped on” or as “shooting myself in the foot”, but both descriptions seemed too… <em>dramatic</em> for the types of problems I encountered. I settled on “banana peels” because there is a perverse slapstick comedy about these kinds of errors. What’s interesting about these scenarios not just <em>that they </em>happened, but <em>why </em>they happened. Each of the scenarios involves making what I thought was a logical series of changes, only to be hit with some unexpected result. In each of these cases, I slipped — but the language (and in one case the React framework) itself left a banana peel on the floor for me to slip on.</p><p>Let me get one thing out of the way upfront — all of these things are dumb mistakes, and they’re pretty much all my fault. Though some languages make it easier than others to fall into traps like these, every language has traps, and I’m a pretty firm believer in “a bad carpenter blames his tools”. I document these issues here not to throw JavaScript (or myself) under the bus, but instead to highlight them in case others run into them. Also, by writing them down, maybe I’ll remember it next time I come across one.</p><h3>If “value” is defined, “value” is undefined. Of course.</h3><p>So let me start this one with an incomplete code snippet, as this is what I was looking at in my editor when I ran across the issue:</p><pre> const f = arg =&gt; {<br>   if(arg) {<br>     console.log(arg)</pre><pre>     ...<br>     ... some other code ...<br>     ...</pre><pre>  }<br>}</pre><p>When this function executed, I got the following error:</p><pre>console.log(arg)<br>            ^<br>ReferenceError: arg is not defined</pre><p>In conjunction with “if(arg)” check, this seems to be absolutely impossible at face value. I read over the preceding lines over &amp; over again, trying to figure out my error. It wasn’t until I looked <em>later </em>in the file that I realized my error.</p><pre>const f = (data) =&gt; {<br>  if(data) {<br>    console.log(data)</pre><pre>    ...<br>    ... some other code ...<br>    ...</pre><pre>    let data = ...</pre><pre>  }<br>}</pre><p>I had redefined data later on. Yep, dumb mistake on my part, for sure — but what made it a banana peel is the confusing error message, combined with the “distant” effect of the code far below. Instead of the interpreter saying “hey man, you seem to have redefined this variable”, it sort of pretended everything was okay, but resulted in an “impossible” result. Not cool.</p><p>In this case, I would have detected the issue using TypeScript — but alas, while part of this project is in TypeScript, I haven’t yet migrated the whole thing over. This particular file was of course, not done yet. <em>Note: just re-reading the above after I wrote it was enough of a push for me to convert the rest of the project to TypeScript, as I should have done earlier!</em></p><h3>Iterating with Async Functions</h3><p>Next up is a gotcha in JavaScript’s async/await keywords which are used to make asynchronous code simpler. Prior to async/await, a JavaScript developer might encounter some form of “callback hell” where a series of asynchronous calls is chained together using callbacks:</p><pre>getSomeDataAsync((data) =&gt; {<br>  processDataStep1Async(data, (data) =&gt; {<br>    processDataStep2Async(data, (data) =&gt; {<br>      processDataStep3Async(data)<br>    })<br>  })<br>}) </pre><p>JavaScript Promises improve on this pattern by allowing asynchronous <em>Promises</em> to be chained together:</p><pre>getSomeDataAsync(data)<br>  .then(processDataStep1Async)<br>  .then(processDataStep2Async)<br>  .then(processDataStep3Async)</pre><p>Async/await goes one step further to provide some additional syntactical sugar around the same promise implementation:</p><pre>data1 = await getSomeDataAsync(data)<br>data2 = await processDataStep1Async(data1)<br>data3 = await processDataStep1Async(data2)<br>data4 = await processDataStep1Async(data3)</pre><p>Looks lovely! But the implementation of async/await using Promises under-the-hood can result in some leaky abstractions and unexpected behaviors. In this case, I had an async function that did some work and looked sort of like this:</p><pre>const process = async (data) =&gt; {<br>  let files = await downloadFiles(data)<br>  return processFiles(files)<br>}</pre><pre>let result = await process(data)<br></pre><p>So far so good. The code waits for the files to download, an asynchronous process, then processes them, and the result is exactly what I expect. But then as my code evolved, I needed to process an <em>array</em> of data instead of a single item, and they need to process in order. No problem, I’ll just iterate over the array with map or forEach, right?</p><pre>const process = async (data) =&gt; {<br>  return data.forEach(async (item) =&gt; {<br>    let files = await downloadFiles(item)<br>    return processFiles(files)<br>  }<br>}</pre><pre>let result = await process(data)</pre><p>To my surprise, not only was result not what I expected, but my files didn’t even get downloaded — at least not right away. The problem of course is that forEach is internally not awaiting the result of the async function, so the result is an array of Promises, rather than an array of results.</p><p>In order to resolve this issue, I had to implement my own “async forEach”:</p><pre>const forEachAsync = async (l, f) =&gt; {<br>  for (let idx = 0; idx &lt; l.length; idx++) await f(l[idx], idx, l)<br>}</pre><p>Not a big deal, but again, an easy to miss gotcha dealing with async/await<em>. </em>The syntactical sugar of async/await made it easy for me to think it would work, but of course, pausing to consider that it’s using Promises work under-the-hood, it obviously does not work.</p><h3>React Effects &amp; Stateless Components</h3><p>This last one is not in the JavaScript language itself, but rather in React — but oh boy are there some banana peels there.</p><p>React has recently been making an increasingly firm push to using <em>stateless components, </em>rather than class components. A stateless component is one that is implemented as a single function, without an internal state, and without storing <strong>props </strong>on the object itself. Instead, the stateless component is just a function which takes in props and returns the rendered content:</p><pre>// Class component</pre><pre>const Component extends React.Component {<br>  render() {<br>    return &lt;h1&gt;Hello, {this.props.name}&lt;/h1&gt;<br>  }<br>}</pre><pre>// Stateless component</pre><pre>const Component = props =&gt; {<br>  return &lt;h1&gt;Hello, {props.name}&lt;/h1&gt;<br>}</pre><p>This is all well and good — it tends to make for more compact and more simple components. But it also misses out on state and a number of hooks into the React component life-cycle (such as componentDidMount, or componentDidUpdate) which are necessary for some components. In the past, this limited the types of components that could be easily implemented as “stateless”, so React introduced <em>hooks</em> that could (among other things) be used to implement the missing functionality for stateless components.</p><p>The most commonly used hooks are the clearly-named “useState” (used to add state to the component) and the opaquely named “useEffect” (used to… do effects, I guess? No, I don’t have a better name, but still, the name is a bit opaque).</p><p>Like many others who have <a href="https://blog.logrocket.com/frustrations-with-react-hooks/">written about the topic,</a> I <em>generally</em> like stateless components and hooks, but they <em>can</em> introduce some hidden and unnatural semantics into the behaviors of a component. In particular, there’s a lot of magic happening behind the scenes to enable the “simplicity” of state within a stateless components.</p><p>Okay, let’s get to a stripped down example of the code that tripped me up. In this case, I had a component that would trigger a data fetch when it changed:</p><pre>const Component = props =&gt; {<br>  let getData = (value) =&gt; {<br>    fetch(...)<br>  }</pre><pre>  return &lt;InputComponent onChange={getData} /&gt;<br>}</pre><p>That worked well, except of course, that I was hammering my server on every input change. This is a very common issue with this type of pattern, and the typical solution is to <em>debounce</em> the function, which prevents multiple inputs in rapid succession from triggering the fetch. This is something I’ve done hundreds of times–simple!</p><pre>const Component = props =&gt; {<br>  let getData = _.debounce((value) =&gt; {<br>    fetch(...)<br>  })</pre><pre>  return &lt;InputComponent onChange={getData} /&gt;<br>}</pre><p>Except of course, it doesn’t work. The issue is that with a functional component, the entire function body is executed with each render, so the function being returned by <em>debounce</em> is actually a new function each time. To work properly, we need to call the same debounced function each time. This is <em>somehow</em>, at the same time, completely obvious from looking at the code (we’re defining a local variable), and completely non-obvious from a typical JavaScript pattern perspective, particularly coming from a class-based component.</p><p>The deeper issue here is that React Effects can introduce an illusion of a stateful component, without actual persistent state. This works fine for the some of the straightforward “useState” or “useEffect” use cases, but can quickly break down when dealing with <em>actual state, </em>as in this example, or when dealing with callbacks or event handlers that deal with objects outside of the component.</p><p>In this case, there are of course workarounds to debouncing the fetch call, but the cure may be worse than the disease. In most cases, it involves writing extra code and handling to reconcile the of lifecycle of the stateless component with the world outside of the component. In the quest for simplicity, stateless components &amp; React hooks sometimes result in far more complex code.</p><h3>Conclusion: Banana Peels Everywhere</h3><p>Once again, I fully own up to the fact that running into these issues was my own fault. But in each case, I felt like I had been lead down a garden path, right onto a banana peel. Each of these examples was fairly simple to resolve, but if you thought all of these things were <em>obvious, </em>then you’re probably a better JavaScript programmer than I am.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=460dc61a8195" width="1" height="1" alt=""><hr><p><a href="https://medium.com/swlh/3-javascript-banana-peels-i-slipped-on-this-week-460dc61a8195">3 JavaScript Banana Peels I Slipped On this Week</a> was originally published in <a href="https://medium.com/swlh">The Startup</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Complex Systems: How to Think About a Pandemic]]></title>
            <link>https://verifiablee.medium.com/complex-systems-how-to-think-about-a-pandemic-6b6cd1483522?source=rss-81810eb3b5a3------2</link>
            <guid isPermaLink="false">https://medium.com/p/6b6cd1483522</guid>
            <category><![CDATA[complexity]]></category>
            <category><![CDATA[pandemic]]></category>
            <category><![CDATA[complex-systems]]></category>
            <category><![CDATA[coronavirus]]></category>
            <category><![CDATA[covid19]]></category>
            <dc:creator><![CDATA[Verifiablee]]></dc:creator>
            <pubDate>Wed, 13 May 2020 19:56:27 GMT</pubDate>
            <atom:updated>2020-05-13T19:56:27.839Z</atom:updated>
            <content:encoded><![CDATA[<h4><strong>Common themes from complex systems research <em>can</em> give us better tools to think about the pandemic and help make more informed decisions</strong>.</h4><p><em>This post written by Jon Klein, co-founder at </em><a href="https://verifiablee.com/"><em>Verifiablee</em></a></p><p>I have a Master’s degree in <em>Complex Adaptive Systems</em>. And when I tell people that, there’s typically a short pause, followed by the obvious question: “What are complex adaptive systems?”. And so I normally go on a long-winded spiel about biological systems or social interactions or turtles on lily pads or traffic jams and usually this helps people <em>kind-of-sort-of </em>understand what complex systems are all about.</p><p>Over the past 3 months though, explaining complex adaptive systems has become a lot easier: you know that global pandemic that we’re all living and breathing, that has changed every aspect of our daily lives? Yeah — that one. <strong><em>That </em></strong><em>is a complex adaptive system.</em></p><p>Simply stated, a complex system is a system made up of lots of interacting pieces, in which looking at the behaviors of individuals does not readily explain the behavior of system as a whole. Pandemics certainly fit the bill, and some of the most lucid thinking on managing this pandemic (and others before it) has come from <a href="https://www.endcoronavirus.org/about">people and institutions studying Complex Systems</a>. As the public debate on how and when to “reopen” unfolds, an understanding of complex systems reveals some themes that can help us make better decisions.</p><h3>Pandemics as Complex Systems</h3><p>One of the defining features of complex systems is that they often give rise to <em>emergent behaviors: </em>unexpected phenomena that emerge out of simple interactions<em>. </em>In the “<a href="https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life">Game of Life</a>”, for example, simple interactions between individual “cells” give rise to surprising higher level patterns like islands of stability, oscillating patterns, and even patterns that travel through space and time. Similarly, all sorts of emergent phenomena can arise when looking at a pandemic.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*2c5Mfwq7mu0xajlLCmsCDQ.gif" /><figcaption>Conway’s “Game of Life”, a well-known example of a complex system, albeit a “simple” complex system</figcaption></figure><p>To dig into how pandemics can be viewed as complex systems, let’s start with the most fundamental aspect: the spread of the disease. To understand the spread of the virus, we look at behaviors of the individual pieces (personal interactions, basic reproduction number of the virus, course of the disease); and we seek to understand the big picture <em>emergent </em>behaviors (the “curve” of infections, hospitalizations &amp; fatalities). Changes to the behaviors at the individual level can have profound impact on the behavior of the system. For example, reducing personal interactions, as we have done through social distancing, has had a clear impact on <em>flattening the curve </em>of infections.</p><p>Looking beyond just the spread of the disease there are actually several other connected complex sub-systems we might want to analyze: the economy, supply-chains, health care systems, even the biological mechanisms of the virus in the body. Depending on what aspect of the pandemic we seek to understand, we might seek to understand some of these things in isolation, or how they impact each other. And some common themes from complex systems research can help us in the process.</p><h3><strong>Theme #1: All models are wrong, some models are useful</strong></h3><p>One of the core tools of understanding complex systems is <em>modeling, </em>in which we attempt to simulate the various components and interactions in a system in order to see how the system as a whole behaves. There are all sorts of different simulation techniques one can apply to study complex systems (such as <a href="https://en.wikipedia.org/wiki/Mathematical_model">mathematical</a>, <a href="https://en.wikipedia.org/wiki/Statistical_model">statistical</a>, <a href="https://en.wikipedia.org/wiki/Agent-based_model">agent-based</a>, etc), but they all share a goal of giving a better understanding of how a system will behave given the behaviors of its components.</p><p>Though modeling is sometimes used to attempt to predict <em>specific</em> outcomes, it is arguably more useful as a tool to understand how complex systems work. Modeling lets us test our assumptions about a system, and once we’re confident in the model, we can change assumptions about individuals &amp; their behaviors and see how it impacts the system as a whole. For example, we might build models around the virus that are capable of helping us answer questions like: “how many more infections will we see if we re-open schools next week”, or “how many lives would be saved if we could hospitalize patients one day earlier?”</p><p>Some of the best known models for the spread of COVID-19 are those from the <a href="http://www.healthdata.org/covid/faqs">Institute for Health Metrics and Evaluation</a>. These models have been used to predict the number of cases and fatalities broken down by state and country, and have been widely referenced in making policy decisions around the pandemic. Some people have also been critical of the many updates and changes that the projections, even at times when the underlying assumptions don’t seem to have changed, and they questioned their utility: if the models get so much wrong, what are they good for?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*99ES0gB-kZphqSy3O9IJzw.png" /><figcaption>A table showing some of the IHME predictions as of May 10th, with differences from the May 4th predictions.</figcaption></figure><p>Though it’s reasonable to question the way any model is constructed, let’s be careful not to throw the baby out with the bathwater. <strong>Models can be “wrong” and still be useful</strong>. In this context, I use the word “wrong” meaning “not predictive of a precise outcome” — a model does not need to accurately predict a precise outcome of a system to be helpful in understanding the system and how the system behaves in response to changes in the underlying behaviors. Models can and should be updated to incorporate new data and changes in underlying assumptions. As we learn more about the virus and as policies and behaviors change, <em>we should expect to need to update the model</em>.</p><p>This is of course not intended to defend poorly built models or suggest that any arbitrary model is “useful”. Instead, it means to recognize that models are not perfect representations of the real world and that even a well-constructed model will need to change in response to new information. Models help us understand how complex systems work, along with their trends &amp; their behaviors — even though <a href="https://en.wikipedia.org/wiki/All_models_are_wrong">all models are wrong, some models are, indeed, very useful</a>.</p><h3>Theme #2: The data isn’t just noisy — sometimes it’s unknowable</h3><p>One of the biggest challenges in dealing with these types of systems is the fact that the data can be unreliable, and in many cases, it’s simply not knowable. Two of the most fundamental pieces of data in this pandemic are how many people are infected, and how many people have died. And in both cases, the actual values are currently unknowable and the data we do observe is subject to debate and interpretation.</p><p>In the case of the number of infected, <em>the most important factor in the number of observed infections is the number of tests being done</em>. And as is now abundantly clear, <a href="https://www.npr.org/sections/health-shots/2020/05/07/851610771/u-s-coronavirus-testing-still-falls-short-hows-your-state-doing">we are not doing enough testing</a>. Even though we’re not doing enough testing, surely we can extrapolate from the tests we <em>are </em>doing, right? We can try, but then we have to think about <em>who </em>gets tested. The people who get tested the most are <em>sick people</em>, and often those who are sick enough to go the hospital. The people getting tested are not a representative sample, so extrapolating from the number of positive tests is not straightforward and subject to interpretation. <a href="https://www.newscientist.com/article/2241313-what-the-first-coronavirus-antibody-testing-surveys-can-tell-us/">Antibody testing</a> of can help us get a better picture of the number of people who have been exposed to the virus, but it too suffers from the same sampling biases, not to mention <a href="https://www.the-scientist.com/news-opinion/why-the-accuracy-of-sars-cov-2-antibody-tests-varies-so-much-67513">wildly varying accuracy values</a>.</p><p>Likewise, the number of fatalities, which seems like it would be simple to track, is not. The fatalities that are counted, generally speaking, are those of patients being treated for a confirmed positive case of the virus. What about people who died outside of a hospital setting? What about people who died with “suspected” cases but were never confirmed with a positive test? What about terminally ill patients in which the virus pushed them over the edge? What about all of the “<a href="https://www.newscientist.com/article/mg24632804-100-how-many-people-have-really-died-from-covid-19-so-far">excess deaths</a>” that may or may be due to the virus, and which may or may not be counted in those other categories?</p><p>These may sound like edge cases, but the numbers are significant. Because of these issues and others in accurately counting fatalities, <a href="https://www.worldometers.info/coronavirus/us-data/">the definition and number of COVID-19 deaths are constantly evolving</a>, even retroactively as when New York City reported 3,778 additional deaths after the fact. While it’s easy to attribute inaccurate numbers to coverups by dishonest governments (which <a href="https://www.bbc.com/news/world-asia-china-52194356">in some cases</a> is quite plausible), more often than not I suspect that it’s because getting an accurate &amp; meaningful count is just <a href="http://really really hard. https://thehill.com/homenews/coronavirus-report/497324-fauci-real-coronavirus-death-toll-almost-certainly-higher-than"><em>really really hard</em></a>.</p><p>Beyond these two fundamental statistics, there are many other things we cannot possibly know <em>with certainty</em> right now (in some cases because they are derived from these already unknowable values):</p><ul><li>the basic reproduction number (R0) of the virus</li><li>the infection fatality rate (IFR) or case fatality rate (CFR) of the disease</li><li>the economic impact of the <em>shutdown</em></li><li>the economic impact of the <em>virus itself</em></li></ul><p>All of these numbers are active areas of research and hotly debated by well-informed and well-intentioned researchers (though not all contributions to the debate are well-informed and well-intentioned). As time goes on, the estimates of all of these values should improve. After the fact — perhaps years from now — we may have reasonably accurate values for some of them and a better understanding how the pandemic unfolded. For the time being, however, these and other important values cannot be definitively determined — and yet we need to make use of this data to make reasonable decisions on how to act.</p><h3>Theme #3: Embrace the Uncertainty — Outcomes are Probability Distributions</h3><p>Given that we’re using imperfect models, built on not-fully-knowable numbers, we should get used to treating predictions with a great deal of uncertainty. Just like a weather forecast, (the weather itself being a complex system), models of complex systems typically produce probability distributions of outcomes instead of absolutes. Well constructed formal models, like the IHME ones, have probability distributions built-in — we should be careful to include probability distributions in our own thinking and beliefs about the pandemic as well.</p><p>Rather than making policy decisions based solely on our current fixed set of assumptions about the world, we need to make decisions that acknowledge the uncertainty about those assumptions. We need to ask all sorts of questions like, “what would the result of this policy be if my assumption about the IFR is off by 50%?” or “what if we’re wrong about the number of asymptomatic carriers?”. In many cases, this kind of thinking can cause good, sound decisions to look like over-reaction. It also means that we must continually observe the results of policy decisions and be prepared to change in response to changes in the data. This kind of uncertainty may be unsettling and unpopular, but it is also necessary to properly navigate a complex system.</p><h3>Theme #4: Lookout for Phase Transitions, aka Tipping Points</h3><p>Phase transitions are states in a complex system in which the system-level behaviors can change suddenly and severely, often with a sharp and unexpected transition. A phase transition we’re all familiar with is that of water freezing to become ice, which happens at 32 degrees Fahrenheit at normal atmospheric pressure. The behavior of water at 31 degrees and at 33 degrees is fundamentally different, and for all practical purposes is an entirely different material.</p><p>What’s more, as we change the pressure the water is subjected to, we get an even more interesting picture:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*thL80tf-bOQCPxO-eIFxQA.png" /><figcaption>Phase transitions of water between liquid, solid and gas</figcaption></figure><p>This diagram shows the state of matter we observe for water at different pressure and temperature values. We see lines between the states which represent the <em>phase transitions</em>, and even a “triple point” where the states of gas, fluid and solid all meet. Around this point, tiny changes in temperature and pressure can change the behavior of the system entirely into three different states of matter. Just like phase transitions of matter, many complex systems have phase transition points at which the behavior of the system can suddenly and drastically change in response to what appear to be small changes in conditions.</p><p>There’s one critically important phase transition in the pandemic context that you’re probably already quite familiar with: the R0 number, or <a href="https://en.wikipedia.org/wiki/Basic_reproduction_number">basic reproduction number</a>. It’s a measure of — on average — how many new infections occur from a single case of the virus. The R0 number is another one of those <a href="https://www.chicagotribune.com/coronavirus/ct-nw-nyt-cb-r-naught-r0-value-coronavirus-infection-metric-20200511-7yqmodactbeadm3co3f65s6664-story.html">noisy and not-fully-knowable values and is constantly changing</a>, but importantly, there’s a major phase transition that happens at R0 = 1. With R0 greater than 1, the pandemic is expanding, and if it’s under 1, the spread of the disease is waning.</p><p>Looking for and understanding these phase transitions help us understand how &amp; when changes in underlying conditions give rise to important changes in systemic behaviors. There are many aspects of the pandemic which may be subject to unexpected tipping points, among others:</p><ul><li>hospitals utilization &amp; capacity</li><li>economic impact on businesses &amp; individuals</li><li>supply-chain stability</li><li>long-lasting behavioral changes post-shutdown</li><li>the course of the disease in individual patients</li></ul><p>All of these areas are experiencing major impacts already, but there’s a risk of sharp phase transition points giving rise to “sudden” and more drastic changes in behavior that we need to be aware of.</p><h3>What’s Next?</h3><p>As we navigate the “reopening” debate, that’s the question we’re all asking. And many people have already “picked sides” on the debate based on some belief about the fundamental nature of the virus, which is unfortunate. Though complex systems don’t give us any easy answers, complex systems thinking does reveal some common themes that can help in our understanding. Most of all, it can help us to stay flexible in our thinking and recognize that the behaviors of complex systems can an do change drastically over time, often in unexpected ways, and that we need to adapt.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6b6cd1483522" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[3 Months with Elixir & Phoenix]]></title>
            <link>https://medium.com/swlh/3-months-with-elixir-phoenix-2810f653f887?source=rss-81810eb3b5a3------2</link>
            <guid isPermaLink="false">https://medium.com/p/2810f653f887</guid>
            <category><![CDATA[rails]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[elixir]]></category>
            <category><![CDATA[phoenix-framework]]></category>
            <dc:creator><![CDATA[Verifiablee]]></dc:creator>
            <pubDate>Tue, 05 May 2020 17:16:00 GMT</pubDate>
            <atom:updated>2020-05-07T17:11:23.924Z</atom:updated>
            <content:encoded><![CDATA[<h4>In the career arc of the modern software engineer, rising from the ashes is a common theme.</h4><p>One of the joys of <a href="https://medium.com/@verifiablee/introducing-customer-testimonial-automation-with-verifiablee-ec1a59a9c7af">building a brand new product</a> is the opportunity to take a step back from the tools one has been using and evaluate new technologies and frameworks. This doesn’t mean switching tooling for the sake of something newer and sexier — it means being thoughtful about ones experiences and looking at new &amp; better ways to solve the problems one invariably encounters. So when we started to build out the <a href="https://verifiablee.com/">Verifiablee</a> app a couple of months ago, I decided it was the perfect opportunity to try out some new tooling I’d had my eyes on.</p><h3>Rails Battle Scars</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/1*iUmTg9F7esiNnC_A68CT-w.png" /><figcaption>Thomas the Tank Engine, series 1 episode 24: Off the Rails</figcaption></figure><p>Before going any further, I should probably clarify <em>what kind of app </em>we’re talking about here — different apps obviously have different needs. We have a couple of different services in our product, but the app I’m writing about now is a <strong>pretty typical modern web-app</strong>, with all the baggage that entails. That means that the core functionality is serving up web content with CRUD APIs, but also means things like 3rd party integrations, authentication, background jobs, asset pipelines, etc.</p><p>Because we were building a brand new product and wanted to bring it to market quickly, <em>developer productivity </em>was one of my biggest concerns. Having built many different products with <a href="https://rubyonrails.org/">Rails</a> over the years, and because of its emphasis on developer productivity, it certainly would have been a reasonable choice for this app. But, like most other seasoned Rails developers, I’m sporting my share of Rails battle scars, and was eager to explore alternatives.</p><p>There are of course lots of things I like about working with <a href="https://rubyonrails.org/">Rails</a> — otherwise I would have moved on long ago. In particular, I appreciate the focus on developer productivity and the ecosystem support. Many of the design decisions around Rails are oriented towards productivity and building products quickly, and this remains the framework’s biggest strengths in my opinion. On the other hand, like many others, I’ve witnessed the kinds of issues that can arise in Rails projects as they scale both in complexity and in usage. Rails apps for example, are fairly bloated from the start with respect to startup, runtime and memory performance, and these problems only grow as projects become more complex. Additionally, the dynamic free-for-all approach of the Ruby language, with it lack of static typing and other compile-time checks (which enables much of the Rails “magic”) can also lead to difficult-to-maintain code as codebases grow.</p><p>So while I love a lot of the design decisions and the general philosophy behind Rails, working on a growing Rails project can become frustrating quickly.</p><h3>Enter the Phoenix</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/728/1*W9maDRfdQbydm_aECrzAiQ.png" /></figure><p>What if there was a technology that took all of the good ideas from Ruby &amp; Rails but fixed all the bad stuff, like the bloat &amp; the performance, and put it on a more solid foundation? It turns out that’s essentially what you get with the <a href="https://www.phoenixframework.org/">Phoenix Framework</a> on <a href="https://elixir-lang.org/">Elixir</a>, the language built by José Valim, a long-time contributor of both Ruby and Rails.</p><p>I’ve had my eyes on Elixir for a couple of years and have used it in some side projects, but I had yet to fully immerse myself. Side projects and tutorials are great ways to get exposure to a new technology, but it’s not until you really dive into building a shipping product that you <em>really</em> get to know and understand it. Personally, I need to run into all those real world problems that are easy to overlook when taking a new framework for a casual spin: what’s the tooling like, what’s the ecosystem like, how the heck do I deploy this thing?</p><p>Using a new technology in a live production environment always reveals new challenges and opportunities to learn, and while I certainly won’t call myself an expert on Phoenix &amp; Elixir, building this product has given me more than enough experience to tackle some of those challenges. I’ve captured some of my thoughts and leanings here. This isn’t meant to be an exhaustive analysis of Elixir or Phoenix, but instead, some of the key observations I made in building out a new product.</p><h3>Pure Functional Programming — Mostly</h3><p>The first big win for Elixir is the focus on functional programming. I’m a big fan of functional programming in general: <strong>managing and reasoning about program state is often difficult and can be the source of insidious bugs</strong>. I’ve always appreciated that Ruby allows and often encourages developers to use a more functional programming style, though it does not force them to do so. At the micro level, using functions like <em>map </em>and<em> reduce </em>are certainly more idiomatic Ruby than writing <em>for</em>-loops, but at a more macro level, Ruby’s object-oriented nature tends to dominate, with state stored at the class and instance level.</p><p>The Elixir <em>language </em>is,<em> </em>at its core, entirely functional (though programs do maintain and manipulate state via processes in the Erlang <em>runtime</em> — more on that below). By removing state, code is simpler to reason about, debug and test, though it does occasionally require bending ones mind to solve a problem that may be more easily accomplished in a non-functional fashion.</p><p>So what about this state management via the Erlang runtime? The Erlang runtime allows for concurrent <em>processes</em> (which are not true OS processes and more analogous to <em>threads </em>in other languages), and these processes can<em>, </em>in effect<em>, </em>have their own <strong>fully isolated</strong> state. Applications can thus make use of state by sending messages to other processes. These messages are processed in the order in which they are received and may perform other computations than just changing state, such as data validation and other forms of state management.</p><p>Furthermore, these messages are typically not specifying state directly by saying “<em>hey process, set variable X</em>”. Though that can occur in some use cases, such as caching, the messages are more often higher-level application semantics like “<em>hey process, the user made this chess move, update the game state accordingly and send it back to me</em>”. This encourages data transformation and validation built-in to the state management. In a sense, manipulating state in Elixir can be thought of a little bit more like making an extremely lightweight API call than like setting a variable.</p><p>The reality is that sooner or later, most useful applications need <em>some </em>notion of state, it’s just a question of where and how languages expose this functionality. By avoiding state in the core language and by isolating and abstracting it into separate Erlang processes, Elixir manages to drastically reduce the use of state and mitigate many of the pitfalls that can come along with stateful solutions in other contexts: data inconsistencies, deadlocks, thread contention and race conditions.</p><h3>Metaprogramming &amp; “Magic”</h3><p>Metaprogramming in Ruby, and its application in Rails, is a contentious issue. The use of metaprogramming in Rails is often referred to, both complementary and disparagingly as “magic”. It is used to enable many of the benefits of the Rails framework; and is abused to create many of the downsides. Chief among those downsides are that code that is opaque and difficult to understand, as well as code exhibiting unintended consequences and side-effects.</p><p>Unfortunately, this is one area where in my opinion, Elixir carries at least some of the same baggage as Ruby. Though the use of metaprogramming is somewhat more restrained in Phoenix, Elixir actually enables far more metaprogramming functionality than Ruby via its powerful macro system. Elixir macros allow developers to effectively re-interpret the core syntax of the language and transform the meaning of expressions. It’s pretty much as scary as it sounds, though as the documentation warns:</p><blockquote>Elixir already provides mechanisms to write your everyday code in a simple and readable fashion by using its data structures and functions. Macros should only be used as a last resort. Remember that <strong>explicit is better than implicit</strong>. <strong>Clear code is better than concise code.</strong></blockquote><p>For an example of how macros are (ab)used, let’s take a look at Ecto, the Elixir analog to ActiveRecord. In ActiveRecord, I might write a query to fetch the names of users over a certain age like this.</p><blockquote>User.where(:name =&gt; query).select(:name)</blockquote><p>In Ecto, using the preferred query syntax is a DSL implemented via a macro:</p><blockquote>from u in User, where: u.name = ^query, select: u.name</blockquote><p>It looks reasonable, but <em>there are several features of this line of code that do things completely different from what they normally do in the Elixir language.</em></p><ul><li>“<em>x in y</em>” usually tells you if the element “x” is in the Enum “y”. But not here.</li><li>“^” is usually the “pin” operator used in a match clause, which is kind of <em>conceptually</em> how it’s being used here, though we’re not in a match clause, so it would not actually be valid (or expected!)</li><li>“<em>where: x, select: y</em>” would usually be creating a keyword list using the values for “<em>x</em>” and “<em>y</em>” — but that’s not happening here either (because the binding of “u” at that point is not what we would expect)</li></ul><p>Now having read the documentation for this particular, commonly used method, I get it and I understand how it works. And because under the hood here this method is essentially assembling a SQL fragment, <em>some</em> form of code gymnastics is going to be necessary. But in my opinion, these types of macros generally make code more difficult to read &amp; reason about.</p><p>I’ve found that this type of macro strategy is used in a surprising number of Elixir libraries. Any library which is integrated using the Elixir “<em>use</em>” keyword can inject unseen code into a module which may (or may not) make use of this kind of metaprogramming.</p><p>I understand and appreciate the need for this kind of functionality in the core language, but am sometimes taken aback by its applications, especially in a language which puts an emphasis on <em>explicit behaviors, </em>though as <a href="https://elixirforum.com/t/on-explicit-is-better-than-implicit/22076/5">detailed in this thread</a>, there are varying opinions on what <em>explicit</em> really means.</p><h3>Developer experience &amp; ecosystem support</h3><p>One of the biggest benefits of Rails in my opinion, is the rich ecosystem: it’s been around for long enough that somebody, somewhere has most likely already solved the problem you’re trying to solve — and there’s probably a gem or a blog post to help you solve it yourself.</p><p>I’ve been pleasantly surprised to find that Phoenix, while being relatively young, also has a healthy ecosystem and packages available for most of the integrations and other features I’ve needed. Sometimes, while Ruby might have 3 or 4 different gems to choose from (2 or 3 of which are likely outdated and unmaintained), Elixir might only have a single package available. But in my experience that package is more likely to be up to date and functional. It would be hard to deny that Rails holds an advantage here, given how long it’s been around, but in practice, it hasn’t been an issue for any of the problems I’ve come across.</p><p>In spite of being much younger, the general developer experience of Phoenix easily matches or surpasses that of Rails. Phoenix, like Rails, takes a mostly batteries-included approach, meaning that there’s a focus on developer productivity and having core functionality right out of the box. There are of course differences in exactly which batteries are included, so to speak, but generally speaking both frameworks deliver on this promise.</p><p>One feature of Phoenix worth calling out separately is one that I’m not using extensively right now is <strong>LiveView</strong>, which is a server-side rendering solution built into Phoenix out of the box. LiveView allows for real-time, server-rendered, single-page apps without writing a line of JavaScript. Building the full app in LiveView was a bridge too far for me (I went with React for the client), but there are a couple of specific features I’m working on that seem like ideal match for LiveView — situations where there’s an interactive component combined with a lots of back-and-forth between the server and the browser. I’ll be evaluating LiveView for these use cases as I build them out further.</p><h3>OTP &amp; the Erlang runtime</h3><p>The most fascinating aspect of Elixir is also the one where I’ve had the least experience: the Erlang runtime with Open Telecom Protocol (OTP). It’s probably more accurate to say this is the area where I have the least <em>explicit</em> experience — if you’re writing an app in Elixir or Phoenix, you’re implicitly experiencing the benefits of the OTP from the start.</p><p>The Erlang runtime is more complex than most language runtimes and is almost like a mini operating system for apps running on the Erlang VM. It’s designed for massive concurrency and fault tolerance and promotes a “let it crash” philosophy, in which individual processes are allowed to crash or fail without bringing down the entire application. Hierarchical <em>supervisor trees </em>are used to monitor processes and gracefully handle any crashes that occur.</p><p>What does this all mean in the context of Phoenix, for example? An “app” written with Phoenix is typically made up of dozens or hundreds of individual processes, most of which are not explicitly started by the developer. Each web request to the app is its own process, as are lots of other pieces of functionality behind the scenes: websockets, database connections, connection pools, loggers, and much much more. Even if you never explicitly create a process, your Phoenix app is taking advantage of the OTP for stability, scalability &amp; complete isolation of all the moving parts of your app. The OTP is a clear win for Phoenix over other frameworks like Rails.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PxRcfjmTby_hfEOJA2boHQ.png" /></figure><p>The recent release of the <a href="https://github.com/phoenixframework/phoenix_live_dashboard">Phoenix Live Dashboard</a> gives a small glimpse into the OTP and how it’s used in a Phoenix app. This drop-in lightweight dashboard shows process monitoring and metrics that demonstrate what the OTP does in every Phoenix app.</p><h3>3 Months Later</h3><p>After 3 months immersed in Elixir &amp; Phoenix, I’m very happy to have made the leap. As I mentioned at the start, my use case is mostly a vanilla web app that has relied on the support of excellent Phoenix framework, and hasn’t required many of the more exotic features of the OTP — so there are many topics I’ve yet to fully explore. I know there are a great deal of problems that I haven’t yet had the need to solve, and surely sooner or later I’ll come across one that will leave me banging my head on the keyboard — as will occur with any language or framework.</p><p>That said, I consider the choice of Elixir and Phoenix to be a great success. In fact, I’ve raved to anybody who has asked that Elixir is the “language of the future”, with only slight hyperbole — there are a lot of great new languages for application development these days and I haven’t done a deep dive with all of them of course. But after spending time working with the language and in particular the OTP, I do feel safe saying: there is something very <em>special </em>about Elixir<em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2810f653f887" width="1" height="1" alt=""><hr><p><a href="https://medium.com/swlh/3-months-with-elixir-phoenix-2810f653f887">3 Months with Elixir &amp; Phoenix</a> was originally published in <a href="https://medium.com/swlh">The Startup</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Boston Marathon non-race report: keeping focused in uncertain times]]></title>
            <link>https://verifiablee.medium.com/boston-marathon-non-race-report-keeping-focused-in-uncertain-times-ab19cbdbd732?source=rss-81810eb3b5a3------2</link>
            <guid isPermaLink="false">https://medium.com/p/ab19cbdbd732</guid>
            <category><![CDATA[race-report]]></category>
            <category><![CDATA[sports]]></category>
            <category><![CDATA[boston-marathon]]></category>
            <category><![CDATA[running]]></category>
            <dc:creator><![CDATA[Verifiablee]]></dc:creator>
            <pubDate>Mon, 20 Apr 2020 16:51:00 GMT</pubDate>
            <atom:updated>2020-04-20T16:51:00.904Z</atom:updated>
            <content:encoded><![CDATA[<p><em>This post written by Jon Klein, co-founder at Verifiablee.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/220/1*yDC8aqSTLIoJdrh2HoKMZQ.jpeg" /></figure><p>Today would have been the running on the <a href="http://baa.org/">2020 Boston Marathon</a>, and if everything had gone exceptionally well, I might be crossing the finish line right about… <em>now</em>. But of course, due to the ongoing pandemic that has changed all of our lives, there is no Boston Marathon today. If we’re fortunate, we’ll be running it in September, though of course, nobody really knows what the world is going to look like then either, in terms of sporting events and mass gatherings.</p><p>After a race, many runners write up detailed <em>race reports</em> describing the ups and downs of the training leading up to the race, and then all the details of the race itself. Though the Boston Marathon is not happening today, there are still a lot of stories to tell about the race, the training cycle, and everything else that has happened in the last couple of months. With that in mind, I’ve taken the opportunity to write up a <em>Boston Marathon Non-Race Report. </em>And like a lot of race reports, the story starts off with a previous race.</p><h3>What are you capable of?</h3><p>A couple of years ago, I had a conversation with a running buddy, where he asked: “if you quit your job and dedicated yourself exclusively to training, how fast do you think you could run a marathon”? We discussed things like training volumes, nutrition, rest, coaching, and both put forth a number. I came up with 2:50–though I’d run a dozen or so marathons and gone sub-3 a couple of times, improvements were getting more and more difficult and I saw diminishing returns on my training. I felt that at my age, and with the genetic hand I’d been dealt, 2:50 was my <strong>absolute theoretical limit</strong>.</p><p>In October 2019, at the age of 41, and after years of plateau, I ran a 2:46 at the Hartford Marathon. A breakthrough performance, I had beaten my previous personal record (PR) by over 10 minutes. Given my age and how long I’ve been running, this was unusual. And while not particularly fast in the grand scheme of things, it was a major accomplishment for me. Not only had I beaten my previous PR, I had done <em>better than I ever thought I was capable of</em>. And even more amazing, I was left with a feeling like I could do even better — I was hungry for more.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*KTfA0dkR4CuDVQe5LBk8Rg.jpeg" /><figcaption>Me, with a creeper mustache, winning my own personal Superbowl or something</figcaption></figure><h3>Training in early 2020</h3><p>After the race in Hartford, the next race on my calendar was Boston, in April 2020. Boston is a difficult race and though I’ve run it 6 times, I’ve never done particularly well —every single time I’ve always been foiled by the weather, injury, difficult winter training cycles or various combination of all those things. But after the Hartford race, I was determined — this year would be different. Even if I couldn’t beat my Hartford time, getting in the neighborhood of 2:50 at Boston would be an amazing achievement, and I knew now I was capable of it. So building off my fall fitness, I began an aggressive training cycle.</p><p>Things went okay at first, but as the days went on, the training cycle proved to be a slog. My household got hit with several illnesses (having a 1-year-old in daycare bring home colds did not help), and I found myself fighting a knee injury that, while not enough to keep me from running, was more than enough to make running difficult and not-at-all enjoyable. Time after time, I would be forced to take a couple of days off of running, work the training load back up, and only to be hit with another setback.</p><p>By the time the end of February rolled around, I was amazingly still at a level of fitness where I felt I could work to achieve a good performance in April, but all the setbacks were taking a toll. I was still dealing with the nagging knee issue, and the on-again off-again training left my body feeling worn down. Still, I kept my training moving forward with a focus on achieving a strong Boston performance.</p><p>But as I worked through a difficult training period, something more sinister was looming for all of us — the growing threat of a global pandemic. As the days wore on, it became more and more clear it was going to have a major impact on all of our lives. It gradually became obvious, even before anything was formally announced, that runners would not be lining up in Hopkinton April 20th. Still, lacking an official announcement, I continued the slog through my training schedule, doing the workouts, the long-runs, putting in the mileage. But it was tough — staying motivated in an already difficult training cycle, knowing deep down that it was all in vain.</p><p>“What am I even doing?”, I remember wondering during a particularly fatigued training run before the announcement was made</p><h3>The other racing shoe drops</h3><p>The official announcement was made on March 13th: the 124th running of the Boston Marathon would be postponed until September.</p><p>I didn’t run that day.</p><p>Or the next, or the one after that.</p><p>Was there any point in even training anymore? Not only was the Boston Marathon postponed, but there would be no races of any kind in the coming months — major marathons, neighborhood 5Ks, summer trail races, all cancelled.</p><p>I even had to ask myself a more existential (for a runner) question: was there any point in <em>even running</em> anymore? Fortunately, facing that question helped me to move on. <em>Of course </em>there’s a point to running — I ran for many years before I ever ran a race. Races are not the reason I run.</p><p>Three days after the announcement, I went out. But instead of running on the road and doing the hard workout that had been scheduled in my training plan, I went into the woods and ran gnarly, rocky, rooted trails. Instead of monitoring the pace on my GPS watch, I power-hiked up steep &amp; rocky inclines and flailed recklessly down the other side.</p><p>This set the tone for the next several weeks of running. I just ran wherever, whenever and however I felt on any given day. Sometimes I ran fast, sometimes I ran slow. I ran a lot of trails, and did a lot of bushwhacking through the woods where there were no trails at all. In one run, I clocked a 22:44 mile (bushwhacking through the woods up a mountain) and 5:45 mile (downhill on a mountain road) back-to-back.</p><p>Most importantly, the focus of running has been on what drew me to running in the first place. Even though running can be difficult and sometimes brings pain, it keeps me sane, happy and healthy.</p><h3>Life imitates running?</h3><p>Of course, what is happening in the world doesn’t only affect running. At the start of the year, I also took the leap to try to start a <a href="https://verifiablee.com/">new business focused on helping businesses build customer testimonial videos</a>. Suddenly, it was a very precarious time to be building a new product.</p><p>With lockdowns and stay-at-home orders in place, it became clear very quickly that this would change how every business operates. For many of the businesses we were talking to as potential customers, our product was suddenly the last thing on their minds.</p><p>Like the Boston Marathon announcement, the first days of lockdown brought lots of difficult changes, both at home and in the workplace, which had somehow suddenly become inseparably linked. With schools and workplaces closed, the house was now always full with kids, and a wife with her own busy work schedule — each with their own work and never-ending schedule of Zoom meetings. Even the 1 year old had a Zoom meeting.</p><p>At one point, as with running, I asked — “What am I even doing?”. And as with running, it took me a couple of days to figure it out. I accepted and tried to embrace the changes this time would bring as best I could. I started to adapt the product for some of the changes we saw coming (I wrote <a href="https://medium.com/@verifiablee/how-social-distancing-is-changing-our-product-development-a591f5a5169c">about those changes here</a>). And like running, I had to focus back on the reasons I was building something new in the first place.</p><h3>What Comes Next</h3><p>I think this is what we’re all wondering. The effects of the first wave of the pandemic have just passed their peak right now in many places throughout the United States, including in Boston, and the current wave appears to be subsiding. But the idea of going back to “normal” in the near future seems crazy. The idea of running the Boston Marathon in September sounds lovely, but I won’t be holding my breath until we see how the coming weeks &amp; months play out.</p><p>In spite of this, my training continues, and my work continues. I don’t know what my goal race is now, but I know there’s a goal. While I may not know <em>what </em>I’m training for, I certainly do know <em>why </em>I’m training.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ab19cbdbd732" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How Social Distancing is Changing our Product Development]]></title>
            <link>https://verifiablee.medium.com/how-social-distancing-is-changing-our-product-development-a591f5a5169c?source=rss-81810eb3b5a3------2</link>
            <guid isPermaLink="false">https://medium.com/p/a591f5a5169c</guid>
            <category><![CDATA[product-development]]></category>
            <category><![CDATA[quarantine]]></category>
            <category><![CDATA[coronavirus]]></category>
            <category><![CDATA[customer-testimonials]]></category>
            <dc:creator><![CDATA[Verifiablee]]></dc:creator>
            <pubDate>Thu, 09 Apr 2020 10:25:54 GMT</pubDate>
            <atom:updated>2020-04-09T18:35:12.713Z</atom:updated>
            <content:encoded><![CDATA[<p>Building a new product in early 2020 has turned out to be interesting timing, to say the least. When we started building <a href="https://verifiablee.com/">Verifiablee</a> in January, we had no idea how every aspect of our daily lives would change due to COVID-19. Like every business, we’ve had to make changes to how we work, though as a software startup with only a few collaborators, the day-to-day changes were modest. The bigger changes we’ve seen have come from the companies we’ve talked to in our customer development process, and how we think about our product.</p><p><a href="https://verifiablee.com/">Verifiablee</a> automates the recording and collection of customer video interviews and allows you to build them into high-quality testimonials, case-studies, sales videos and other video content. Early on, many of the companies we spoke to about the product loved the idea, but preferred to use their own video crews to shoot video with customers in-person rather than capturing video on their customers’ own devices. We understand this — for companies that have the budget and the time, a professional video production team can produce excellent results. So we shifted focus to smaller businesses that didn’t have the budget or the time to utilize full professional video production teams to capture videos of their customers.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*87go1_o9ixxezPZEiHrFvA.jpeg" /><figcaption>Customer testimonial video shoot, <strong><em>January 2020</em></strong></figcaption></figure><p>Of course, that was all <em>before</em> COVID-19 changed the working assumptions for just about every business. Some companies we were talking to, unfortunately, were no longer in a position to work on new marketing initiatives and instead were focused on their own survival. For others, with quarantines &amp; lockdowns becoming the norm, we’ve watched as these companies shifted to working from home and adapting all sorts of new tools to get work done. Around this time, we started hearing back from some of those companies that had been using their own video crews &amp; production teams. Using an on-site video crew was no longer possible — could we help automate the process of collecting video content from their customers? Could we use the customer’s own devices to record the footage?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-JnRDX5tI3z3D8u_0KqgsQ.jpeg" /><figcaption>Customer testimonial video shoot, <strong><em>April 2020</em></strong></figcaption></figure><p>At its core, this is what <a href="https://verifiablee.com/">Verifiablee</a> does — it lets companies capture customer testimonial footage on the customers’ own devices. But these companies require different workflows, so some of the product details are changing in response to these new use cases. For example, many of these companies need access to the raw video content, rather than a fully produced video, or they want to produce content by combining video footage in other ways than our product is currently designed. So changes in how businesses operate, driven by the Coronavirus &amp; social distancing, are flowing directly into our product development process.</p><p>There’s a lot of uncertainty in the world right now and all of us are feeling it in our own homes, our communities and in the workplace. In all of these settings we’ve been forced to improvise and discover new ways to solve problems, from getting basic necessities, to adapting to closed schools &amp; childcare, to getting everyday work done. In the case of <a href="https://verifiablee.com/">Verifiablee</a>, we’ve learned that there are new types of problems our product can solve that we hadn’t even considered when we started.</p><p><em>If these changes sound familiar to your business and you’d like to see more of what we’ve built, come try out </em><a href="https://verifiablee.com/"><em>Verifiablee</em></a><em> and make your own customer testimonial videos.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a591f5a5169c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Introducing Customer Testimonial Automation with Verifiablee]]></title>
            <link>https://verifiablee.medium.com/introducing-customer-testimonial-automation-with-verifiablee-ec1a59a9c7af?source=rss-81810eb3b5a3------2</link>
            <guid isPermaLink="false">https://medium.com/p/ec1a59a9c7af</guid>
            <category><![CDATA[automation]]></category>
            <category><![CDATA[marketing]]></category>
            <category><![CDATA[testimonials]]></category>
            <dc:creator><![CDATA[Verifiablee]]></dc:creator>
            <pubDate>Wed, 08 Apr 2020 21:42:42 GMT</pubDate>
            <atom:updated>2020-04-08T21:42:42.157Z</atom:updated>
            <content:encoded><![CDATA[<p>Nothing is a more powerful endorsement of your brand or product than the voice of a <em>real customer</em> sharing their experiences. While traditional promotional and demo videos are important, customer testimonials can provide a more authentic and personal connection to your leads. By some estimates, customer testimonials <a href="https://www.bigcommerce.com/blog/customer-testimonials/#social-media">can lead to a 62% increase in revenue per site visit.</a></p><p>As powerful of a tool as customer testimonials are, building the content can be a slow &amp; difficult process. Each step of the process — from collecting customer feedback, to building high quality content, to publishing &amp; promoting the content — comes with unique challenges. Video content in particular is an added challenge — dealing with video editing software or professional video producers adds a great deal of expense, both money &amp; time, to the project.</p><p>So we’ve set out to make the whole thing faster, easier and more affordable for small &amp; medium businesses — our goal is that in <strong>less than 5 minutes, you can start collecting powerful customer testimonials &amp; publish them to your website. </strong>And to achieve that goal, we’re excited to introduce <a href="https://verifiablee.com/">Verifiablee</a>, the fastest &amp; easiest way to build customer testimonial videos, quotes &amp; logo walls.</p><p>How does it work? It’s simple — Verifiablee automates the whole process of collecting customer feedback and producing video &amp; web content. You just design the customer interview and invite your customers to respond. When they do, Verifiablee builds out videos and web content that you can publish with a simple copy-and-paste.</p><p>And this is just the beginning. Verifiablee is building out better ways to share &amp; promote your customer testimonial content, more customization options, and much much more. Look for these features to roll out in the next couple of months.</p><p>In the meantime, you can get started building customer testimonial videos for free, so <a href="https://verifiablee.com/">come give it a try.</a> Or, if you have any questions, <a href="/service/mailto:support@verifiablee.com">send us an email </a>and let us know how we can help you with your customer testimonial content.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ec1a59a9c7af" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>