<?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[Yakka - Medium]]></title>
        <description><![CDATA[Yakka is a digital product design and development agency. Whether it’s the web, Flutter, native mobile apps or a back-end project, we’re the ones to get it done for you. - Medium]]></description>
        <link>https://medium.com/yakka?source=rss----215e779f0be5---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Yakka - Medium</title>
            <link>https://medium.com/yakka?source=rss----215e779f0be5---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 02:28:51 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/yakka" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Dart is ready for FaaS with Cloud Run]]></title>
            <link>https://medium.com/yakka/dart-is-ready-for-faas-with-cloud-run-fb069abb3176?source=rss----215e779f0be5---4</link>
            <guid isPermaLink="false">https://medium.com/p/fb069abb3176</guid>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[serverless]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[dart]]></category>
            <category><![CDATA[google-cloud-run]]></category>
            <dc:creator><![CDATA[Luke Pighetti]]></dc:creator>
            <pubDate>Fri, 30 Aug 2019 18:43:06 GMT</pubDate>
            <atom:updated>2019-08-30T18:43:05.924Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*U6ptmNn-J-iymrNrDbVR6Q.png" /></figure><p><em>TLDR? Dart + Aqueduct (JIT) + Cloud Run = 220ms cold starts, 90ms hot starts. </em><a href="https://github.com/lukepighetti/aqueduct_cloud_run"><em>Example repo</em></a><em>.</em></p><p>I’m a huge fan of functions-as-a-service. I’ve been using Google Cloud Functions under TypeScript for quite some time, and its totally reasonable pay-as-you-go pricing structure with no servers to worry about is incredible. My only beef is that my cold starts can be real bad… like 10–20 seconds bad, and even with few dependencies. If only we could get faster cold starts… 😏</p><p>Since I use Dart quite regularly for building Flutter apps, I had the pleasure of playing around with some server-side frameworks a few months ago to handle both sides of development with one language. My favorite was easily Aqueduct with it’s excellent tooling, Postgres ORM, and support (thanks Joe!). I came to rely on Aqueduct for any Dart server.</p><p>Recently, Dart team added full AOT support for server-side which means the future holds 8mb Alpine containers with fast startup times. Unfortunately Aqueduct doesn’t currently support AOT because it makes use of `dart:mirrors`, but this is <a href="https://github.com/stablekernel/aqueduct/issues/669#issuecomment-495653758">currently being worked on</a> by the timely and extremely supportive Joe Conway. (Thanks again, Joe!)</p><p>Additionally, Google recently announced Cloud Run… a kind of amalgamation of a container host and Cloud Functions. You setup a Docker container that listens for HTTP requests, and it instantiates it in response to requests. My understanding is that Cloud Run will handle 80 concurrent requests per instance, while Cloud Functions will only handle 1 concurrent requests per instance. That means 99% less cold starts, in theory.</p><p>So the planets have aligned… Dart supports AOT. Aqueduct is an excellent server-side framework. Google announced Docker based Cloud Run as a FaaS service. I can’t think of any other buzzwords, so lets see how <em>blazing fast</em> this setup can be.</p><p>This isn’t a tutorial as much as it’s a short blog, but we’ll go ahead and post up some notes and a repo to refer to.</p><pre>$ pub global activate aqueduct</pre><pre>$ aqueduct create cloud_run_app</pre><pre>$ cd cloud_run_app<br></pre><pre>[rename bin/main.dart to bin/server.dart]</pre><pre>[add environment variable support]</pre><pre>[add Dockerfile]<br></pre><pre>$ gcloud auth login</pre><pre>$ gcloud config set project myproject-8d802</pre><pre>$ gcloud config set run/region us-central1</pre><pre>$ gcloud builds submit --tag gcr.io/myproject-8d802/helloworld</pre><pre>$ gcloud beta run deploy --image gcr.io/myproject-8d802/helloworld --platform managed</pre><p><a href="https://github.com/lukepighetti/aqueduct_cloud_run">lukepighetti/aqueduct_cloud_run</a></p><p>The whole thing is pretty straight forward. Setup a Google Cloud project, get the GCP tooling, add your Dockerfile, submit it for a Cloud Build, deploy it to Cloud Run, and smash it with request from Postman to see the results. That’s it!</p><p>One critical takeaway is to use <strong>google/dart</strong> Dockerfile instead of the popular <strong>google/dart-runtime </strong>because it is more svelte and doesn’t launch Observatory, which added an additional 11 seconds to cold starts.</p><p>So how does it perform? Honestly? Extremely well. 220ms cold starts and 90ms hot starts. Real-world responses.</p><p>Now, granted, this project is basically hello world, so add in some real work and the response time will get worse. And those are real-world responses from Bangor, ME on a normal cable internet connection hitting <strong>us-central1</strong>. I don’t want to start a firestorm, but we compared this to a Golang deployment and saw comparable numbers….</p><p>So, here’s my takeaway. <strong>Dart + Aqueduct + Cloud Run is a toolkit that makes me willing &amp; excited to use Dart for my FaaS projects.</strong> Adding AOT support for Aqueduct should improve those start times even more.</p><p>Will I end up using it in production? Hard to say, but I’m always happy to have another tool on my belt.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fb069abb3176" width="1" height="1" alt=""><hr><p><a href="https://medium.com/yakka/dart-is-ready-for-faas-with-cloud-run-fb069abb3176">Dart is ready for FaaS with Cloud Run</a> was originally published in <a href="https://medium.com/yakka">Yakka</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Better Go error handling with xerrors]]></title>
            <link>https://medium.com/yakka/better-go-error-handling-with-xerrors-1987650e0c79?source=rss----215e779f0be5---4</link>
            <guid isPermaLink="false">https://medium.com/p/1987650e0c79</guid>
            <category><![CDATA[golang]]></category>
            <category><![CDATA[error-handling]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Luke Freeman]]></dc:creator>
            <pubDate>Wed, 08 May 2019 20:09:43 GMT</pubDate>
            <atom:updated>2019-05-08T20:09:43.137Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2xByKrmzyIcFiLkqBGDxOA.png" /></figure><h3>Better Go error handling</h3><h4>A peek at the xerrors package for Go</h4><p>When it comes to errors in Go, you can fall into one of a few camps:</p><ol><li>you hate writing constant if/else blocks</li><li>you think writing if/else blocks makes things clearer</li><li>you don’t care because you’re too busy writing code</li></ol><p>I fall somewhere between #2 and #3 which is why I was surprised that I was (seemingly) super excited when I saw the <a href="https://godoc.org/golang.org/x/xerrors">xerrors</a> package. For those who haven’t heard, the xerrors package is slated for inclusion as part of the Go standard library in Go 1.13.</p><p>There is plenty to unpack, so I figured it could be good to give a bit of an overview. Hopefully once we’ve gone through a few scenarios it’ll all be clear.</p><h3>Simple error handling</h3><p>We’re going to work through a simple code example that just compares a trivial error with a predefined error (in reality, it’d be a set of errors) so that we can deal with specific error scenarios.</p><pre>var ReallyBadError = errors.New(&quot;this is a really bad error&quot;)</pre><pre>func someErrorHappens() error {<br>    return xerrors.Errorf(<br>        &quot;uh oh! something terrible happened: %w&quot;, ReallyBadError<br>    )<br>}</pre><p>In this scenario, we have a function that would hypothetically perform some action and then return specific errors based some kind of control flow. For example: Look up a user and return a UserNotFoundError.</p><p>In this code you’ll see a call to xerrors.Errorf. This call lets us add some context into our simple error message and then <em>wraps</em> the original error into the one we’re going to return. That’s what the %w flag is doing there.</p><p>Just to quickly explain that:</p><blockquote>If the last argument is an error and the format string ends with “: %w”, the returned error implements Wrapper with an Unwrap method returning it.</blockquote><p>This is particularly helpful for simple error handling and avoids having to manually store the chained error yourself. However, it is a “little bit of magic” so use wisely.</p><p>Now that that is all done, we can check the error conditions.</p><pre>err := someErrorHappens()<br>if xerrors.Is(err, ReallyBadError) {<br>    // deal with the really bad error<br>}</pre><p>xerrors will automatically unwrap the error in this case and we can check the error chain to confirm that it is the specific error type we’re looking for. Pretty cool.</p><h3>More complex error handling</h3><p>Simple error checking is often enough, but, let’s move on to a more complex scenario. If you’re working with an API, there may be times when you want to return a code, a message or some other data. That’s pretty hard to do with just a plain old error. Often I see / hear about people parsing the error string or doing sub-string matching. That makes everyone a sad panda.</p><p>There is a better way!</p><p>Let jump into an example:</p><pre>type ComplexError struct {<br>    Message string<br>    Code    int<br>    frame   xerrors.Frame<br>}</pre><p>This is our struct where we’re going to store an application specific Code and a helpful Message describing the situation. It could, of course, contain other things.</p><p>Next, we want to integrate this struct into our code but we want to do it in a way that is consistent with the standard error mechanisms in Go. This way, our code is easily tested and compatible with pretty much every other package.</p><p>It’s a pretty easy few steps to do that.</p><pre>func (ce ComplexError) FormatError(p xerrors.Printer) error {<br>    p.Printf(&quot;%d %s&quot;, ce.Code, ce.Message)<br>    ce.frame.Format(p)<br>    return nil<br>}</pre><pre>func (ce ComplexError) Format(f fmt.State, c rune) {<br>    xerrors.FormatError(ce, f, c)<br>}</pre><pre>func (ce ComplexError) Error() string {<br>    return fmt.Sprint(ce)<br>}</pre><p>The first function, FormatError, is part of the Formatter interface of the xerrors package. This allows us to define how the error will be represented when we print it to the console or otherwise want to retrieve the simple / default value. The other functions implement Go’s standard error and formatting interfaces.</p><p>Here is the detailed breakdown of what is going on:</p><ul><li>p.Printf will print a simple message to the Printer object. This will be what you see when you Println or use %s/%v in a formatted print statement.</li><li>The ce.frame.Format(p) statement prints the associated error frame. the Format function will automatically consider whether you’re asking to print “the details” or not (i.e.: %+v vs %v). If you don’t want the details, it won’t print the frame information.</li><li>The Format and Error functions provide backwards compatibility. In the case of Format, we’re just passing it all back into the xerrors mechanism.</li></ul><p>The long story short here is that all of this is to tell Go how we want our custom error to be represented.</p><p>In our basic example, we will implement a quick function that just returns our ComplexError struct.</p><pre>func someComplexErrorHappens() error {<br>    complexErr := ComplexError{<br>        Code:    1234,<br>        Message: &quot;there was way too much tuna&quot;,<br>        frame:   xerrors.Caller(1),  // skip the first frame<br>    }<br>    return xerrors.Errorf(<br>        &quot;uh oh! something terribly complex happened: %w&quot;, complexErr<br>    )<br>}</pre><p>Our function still returns an error and not our custom struct and that’s a good thing because we can keep all of functions consistent (not a bunch of different structs everywhere). It also means that our code is compliant with all the rest of the code / libraries we’re going to be using.</p><p>OK, we know this is all good, but how do we get at the error and the code? Glad you asked.</p><pre>cerr := someComplexErrorHappens()<br>var originalErr ComplexError<br>if xerrors.As(cerr, &amp;originalErr) {<br>    // deal with the complex error<br>    // we can now directly interrogate originalErr.Code<br>    // and originalErr.Message!<br>}</pre><p>We can use the xerrors.As function to cast our error value to our custom struct. From there, we can interrogate the values directly. Pretty neat.</p><p>You could also store a raw error inside the struct if you’re wrapping an error from another library. This way you can continue the error chain.</p><p>Well .. that was actually a lot more content than what I originally though it would take. Hopefully I’ve helped a little! This is all coming in Go 1.13 (at least that’s the plan) but you’ll still need to use the xerrors package if you’re targeting Go versions that are lower. I think once you’ve tried it out you’ll switch!</p><p><strong><em>About Yakka<br></em></strong><a href="https://theyakka.com/"><em>Yakka</em></a><em> is a digital product design and development agency. Whether it’s the web, Flutter, native mobile apps or a back-end project, we’re the ones who’ll get it done for you.</em></p><p><em>Reach out today!</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1987650e0c79" width="1" height="1" alt=""><hr><p><a href="https://medium.com/yakka/better-go-error-handling-with-xerrors-1987650e0c79">Better Go error handling with xerrors</a> was originally published in <a href="https://medium.com/yakka">Yakka</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A quick Android app wrapper]]></title>
            <link>https://medium.com/yakka/a-quick-android-app-wrapper-41b5fd5a94dd?source=rss----215e779f0be5---4</link>
            <guid isPermaLink="false">https://medium.com/p/41b5fd5a94dd</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[mobile-app-development]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[android]]></category>
            <category><![CDATA[samsung]]></category>
            <dc:creator><![CDATA[Luke Freeman]]></dc:creator>
            <pubDate>Thu, 07 Mar 2019 20:29:00 GMT</pubDate>
            <atom:updated>2019-03-07T20:29:00.694Z</atom:updated>
            <content:encoded><![CDATA[<h4>or: How I made Google Assistant work with the Bixby Button</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*J_-M-p-lmxKO_QXapqGBbA.png" /></figure><p>Honestly, I’m not fully sure why you would want to do it but I guess it has it’s uses because here I am writing this. Anyhow, if you need to write an Android application who’s sole use is to launch another application, here is how you can go about it:</p><ol><li>Create a project in Android Studio and use the <strong>Empty Activity</strong> template to add an activity. Make sure this activity is the <strong>launcher activity</strong>.</li><li>In your AndroidManifest.xml file, find your &lt;activity ../&gt; definition and add the following <strong>theme</strong> attribute: android:theme=&quot;@android:style/Theme.NoDisplay&quot;. This will prevent the Activity from popping into view when the application starts.</li><li>Lastly, add some code into your onCreate function to start the other app and then just quit. To launch Google Assistant you can use (in Kotlin):</li></ol><pre>startActivity(Intent(Intent.<em>ACTION_VOICE_COMMAND</em>).setFlags(Intent.<em>FLAG_ACTIVITY_NEW_TASK </em>or <em>FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS</em>))<br>System.exit(0)</pre><p>And that’s it.</p><p>If you’re using Nova you can hide the app so you don’t have to look at it.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=41b5fd5a94dd" width="1" height="1" alt=""><hr><p><a href="https://medium.com/yakka/a-quick-android-app-wrapper-41b5fd5a94dd">A quick Android app wrapper</a> was originally published in <a href="https://medium.com/yakka">Yakka</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Cloud Functions in Go]]></title>
            <link>https://medium.com/yakka/cloud-functions-in-go-94c1014a6fe4?source=rss----215e779f0be5---4</link>
            <guid isPermaLink="false">https://medium.com/p/94c1014a6fe4</guid>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[go]]></category>
            <category><![CDATA[google-cloud-functions]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Luke Freeman]]></dc:creator>
            <pubDate>Fri, 18 Jan 2019 00:57:35 GMT</pubDate>
            <atom:updated>2019-01-18T01:49:53.730Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nKZfNn-0iNZpxjn1RInXuQ.png" /></figure><p>It’s happened! Go is now an officially supported language for Google Cloud Functions (check <a href="https://cloud.google.com/blog/products/application-development/cloud-functions-go-1-11-is-now-a-supported-language">the blog</a>). Goodbye node.js… for me at least.</p><p>Let’s take it for a quick spin with a quick function that uses some shared code to output some JSON.</p><p>All of the code for this project at <a href="https://github.com/theyakka/go-func-example">https://github.com/theyakka/go-func-example</a>.</p><h3>The Code</h3><p>Let’s create the directory structure first. We will need two folders: one for our <strong>common</strong> code and one for our <strong>functions</strong> code. The overall structure will look like this:</p><pre>+ myfunctions<br>  - common<br>  - functions</pre><p>To allow our functions to see / use the common code, we’re going to create a local module using the module functionality added in go 1.11. So, under <strong>both</strong> the common and the functions folders, let’s first create a couple ofgo.mod files.</p><p>For simplicity, we’re going to use the module name mysite.com/myfunctions as the base identifier for all of our code. Therefore, the contents of the common/go.mod file should be module mysite.com/myfunctions/common and that’s it.</p><p>The functions go.mod is a little more complicated. Here is what it looks like:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/30bad13776ead1cce4b5b974daf1312f/href">https://medium.com/media/30bad13776ead1cce4b5b974daf1312f/href</a></iframe><p>Quick breakdown of what is going on here. Using the version number v0.0.0 tells Go that we’re going to be working outside of a VCS system so it shouldn’t try to hit mysite.com/myfunctions/common to check for the latest version and download it. However, we still need to tell Go where to find it, so that’s what we achieve with the replace line. The replace tells Go that it should go to the common folder for the common code. A bit verbose, but it works.</p><p>Next, lets set up our first function entry point. Under the functions folder, create a file called message_func.go. Now we need to add a function handler. Let’s call ours OuputMessage:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2a901a7ee24b27e7ae9b8f37ea7f9fde/href">https://medium.com/media/2a901a7ee24b27e7ae9b8f37ea7f9fde/href</a></iframe><p>Now, just for the sake of an example of accessing some common code from our function, let’s add a helper struct that we can pass a message to and it generates &amp; writes a JSON response to our ResponseWriter.</p><p>Create a file called json_message_writer.go in a folder called writers under the common module. Now, let’s add some quick and dirty code to produce and write the JSON. The file should look like:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/dfd72c434593153c73b18bf78dd1ae97/href">https://medium.com/media/dfd72c434593153c73b18bf78dd1ae97/href</a></iframe><p>All that we’re doing here is simply taking a string value that is passed into the JSONMessageWriter at creation time, wrapping it in a simple response structure and encoding the map to a JSON string. Pretty simple.</p><p>So, now we can update our original function to use the message writer.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/2ae8c1a17a4af7fe75621d161b31d5a9/href">https://medium.com/media/2ae8c1a17a4af7fe75621d161b31d5a9/href</a></iframe><p>To make it a bit more dynamic, we’re pulling the message we’re going to display from the a query string value (called message) and passing that along to our JSONMessageWriter. If there is an error, we’re returning a 500 status code and printing the error to the console/log and writing it as plain text to the ResponseWriter. We would obviously want to make that JSON also but, for now, we’re not going to deal with that.</p><p>And that should do it for the code for the moment. Let’s give it a quick test and then move onto deployment.</p><h3>Testing Locally</h3><p>To test our function locally we can use a test (which we should be writing anyway). Let’s set up a quick test to test that the function executes correctly (returns a status code 200) and matches the JSON generated by the JSONMessageWriter:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/060f394931751dbe26f72a9bc102a555/href">https://medium.com/media/060f394931751dbe26f72a9bc102a555/href</a></iframe><p>Run the test from your chosen IDE or using the command line (inside the functions directory):</p><pre>go test -run TestOutputMessage</pre><p>You should see a PASS like:</p><pre>PASS<br>ok   mysite.com/myfunctions 0.003s</pre><p>This means we’re now good to move onto deployment!</p><h3>Deployment</h3><p>I’m not going to go over all of the instructions on setting up the gcloud command line tool, linking your project, authorizing, etc. It’s well documented <a href="https://cloud.google.com/functions/docs/quickstart">here</a>. So, I’m going to assume you made a coffee (or opened a cold beer) and ran through those steps already.</p><p>Before you jump in too quickly trying to deploy your function, we need to do one quick thing. We need to tell the gcloud tool to ignore our go.mod and go.sum files as we’re going to use the module vendoring function to connect our modules.</p><p>To do this we first create a file called .gcloudignore under the functions directory with the following contents:</p><pre>go.mod<br>go.sum</pre><p>That’s it. It’ll now ignore those files when it tries to deploy our app. Ok, as I mentioned just a moment ago, we also need to vendor our app. To do that, we run:</p><pre>go mod vendor</pre><p>This will pull in our common module into our functions module (under a new vendor directory). Go will look in the vendor directory by default when trying to resolve imports, so we should be all good.</p><p>We can now deploy our function!</p><p>Run:</p><pre>gcloud functions deploy OutputMessage --runtime go111 --trigger-http</pre><p>This command deploys our OutputMessage function to the current project as a HTTP function and tells it we want to use the Go 1.11 runtime. It should take 10 — 60seconds for it to deploy (especially if it’s the first time), but after that you will see a bunch of information about the deployment in your console. One of the values printed out will be httpsTrigger. This will be the URL of your new cloud function. Let’s hit that URL.</p><p>Open a browser window/tab and enter the httpsTrigger URL with the query string ?message=Hello World appended to the end of your URL. You should see the following JSON output:</p><pre>{<br>    &quot;data&quot;: {<br>        &quot;message&quot;: &quot;Hello world&quot;<br>    }<br>}</pre><p>If all has gone well you’re now up and running on Google Cloud Functions with Go 1.11!</p><p>If you have any issues, try retracing your steps and check out the docs as it’s likely you have missed a configuration step somewhere.</p><p>Good luck and have fun writing Functions!</p><p>As a quick reminder, all of the code can be found at <a href="https://github.com/theyakka/go-func-example">https://github.com/theyakka/go-func-example</a>.</p><p><strong><em>About Yakka<br></em></strong><a href="https://theyakka.com/"><em>Yakka</em></a><em> is a digital product design and development agency. Whether it’s the web, Flutter, native mobile apps or a back-end project, we’re the ones to get it done for you.</em></p><p><em>Reach out today!</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=94c1014a6fe4" width="1" height="1" alt=""><hr><p><a href="https://medium.com/yakka/cloud-functions-in-go-94c1014a6fe4">Cloud Functions in Go</a> was originally published in <a href="https://medium.com/yakka">Yakka</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Flutter doesn’t need Kotlin (or anything else)]]></title>
            <link>https://medium.com/yakka/flutter-doesnt-need-kotlin-or-anything-else-5773965d5905?source=rss----215e779f0be5---4</link>
            <guid isPermaLink="false">https://medium.com/p/5773965d5905</guid>
            <category><![CDATA[dart]]></category>
            <category><![CDATA[flutter]]></category>
            <category><![CDATA[mobile]]></category>
            <category><![CDATA[swift]]></category>
            <category><![CDATA[kotlin]]></category>
            <dc:creator><![CDATA[Luke Freeman]]></dc:creator>
            <pubDate>Sun, 08 Apr 2018 23:26:48 GMT</pubDate>
            <atom:updated>2018-02-26T23:52:41.328Z</atom:updated>
            <content:encoded><![CDATA[<p>It’s not an exaggeration to say that I was super impressed by Flutter the first time I picked it up. Hot Reload, the declarative UI syntax, near (if not actual) native performance and easy access to the underlying OS. Cross-platform is a no-brainer in a mobile development world but I’ve never found a solution that executed it “right”. Flutter felt closer than anything else but one thing didn’t sit right.</p><p><strong>Dart</strong>. Why Dart!? I thought.</p><p>I know this is the common thought process for a lot of people who are coming into Flutter fresh so I figured I’d take a crack at describing my general experience.</p><p>I’d had a couple of minor past experiences with Dart, mostly in an attempt to escape Javascript at any cost, but overall it hadn’t made any lasting effect either positively or negatively on me. Now that I was in a situation where I had to use it the thought that “we have Kotlin and Swift and … why Dart!?” kept coming up. Surely one of those other languages would have been way better? There is a talent pool already, why not leverage that? Stuff like that.</p><p>As I wrote more and more Flutter it was alongside more Kotlin (mostly) and I kept saying to myself “See? Look at this cool Kotlin thing it’s missing” and getting into a general huff about it. But as I started writing more Dart code, something changed. I started to really appreciate it.</p><p>I started to appreciate the simplicity of its asynchronous features, how complete the standard libraries are and features like method cascades that make your code nice to read. I still want(ed) things like Data Classes, Extensions and various language features I’d come to really love, but things started to seem not so bad. Dart 2 development was coming along and feature I know I’d suggested (along with others) were coming to fruition and things started seeming even brighter. “This Dart stuff is pretty neat” I started thinking.</p><p>To get a better feel for Dart I decided to try out AngularDart so that I’m not just using Dart in the context of Flutter. Flutter is / can be pretty specific, so the theory here was that may I just have some minor beefs with Flutter and not Dart itself.</p><p>The two realizations I made from this experiment is that: #1 — I freaking <em>really </em>like AngularDart, and #2 — It wasn’t Flutter, but getting more exposure to a language in a variety of situations is <strong>super </strong>important. Dart has a super rich ecosystem to tap into for a variety of situations and it’s worth digging deep. Either way, the end-result was that I felt pretty happy.</p><p>Can I say conclusively that its better than Kotlin or Swift? Absolutely not, nor is it worse. Ultimately Dart doesn’t have to be better either.</p><p>After all my experiences within the Dart / Flutter ecosystem the obvious parallel to draw here is a direct comparison to Ruby on Rails. Was Ruby the best, most well known language ever? No. Did people complain at the time and say they should have been using some other more popular language at the time? Yes. Did it achieve a tremendous amount and was it a better product because of Ruby? Absolutely.</p><p>The crux of it is that Dart is to Flutter what Ruby is to Rails. Neither would be possible without their respective language choices. If you want to read more on the actual technical reasons then you should check out the following article.</p><p><a href="https://hackernoon.com/why-flutter-uses-dart-dd635a054ebf">Why Flutter Uses Dart | HackerNoon</a></p><p>So, when you pick up Flutter, just remember that you’re working toward an end goal and you’re not just the victim of arbitrary decisions. Decisions weren’t made because someone preferred one thing over another. Enjoy building!</p><p>P.S. The Flutter and Dart teams are also incredibly responsive and they love constructive feedback so I recommend reaching out.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5773965d5905" width="1" height="1" alt=""><hr><p><a href="https://medium.com/yakka/flutter-doesnt-need-kotlin-or-anything-else-5773965d5905">Flutter doesn’t need Kotlin (or anything else)</a> was originally published in <a href="https://medium.com/yakka">Yakka</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>