Forem: Brad

An Introduction to Targeting Web Assembly with Golang

Brad — Wed, 30 Dec 2020 19:24:00 +0000

Heads up! This post originally appeared on BradCypert.com but has been modified for your viewing pleasure on Dev.to!

In 2015, Google announced that the Dart VM would not be built into chrome. This was an impactful day for me because from Dart's inception, I had hope that we'd have a first class alternative to JavaScript for web clients.

Don't get me wrong, I have written a ton of JavaScript, but that doesn't mean I necessarily mean that I like the language. TypeScript, although not something a browser can simply execute as is, has done wonders for me but Im still left yearning for other alternatives to JavaScript.

Enter Web Assembly. When I had first heard of web assembly, my feelings weren't of excitement. I had written a tiny bit of assembly in college and the idea of shoving assembler instructions into chrome devtools sounded like a step backwards. Thankfully, Web Assembly is not simply shoving assembler instructions into chrome or firefox.

Web Assembly is a language that, similar to TypeScript compiling down to JavaScript, is targeted by another language as the build target. For this example, we'll use Golang and target Web Assembly as a platform and architecture, but there are other languages that can target web assembly, too (Rust, C, C++ to name a few).
Why use Web Assembly?

It's important to recognize that Web Assembly, just like JavaScript, is a tool to solve a problem. Web Assembly is fast/ Additionally, Web Assembly, when built correctly can actually produce an extremely small, pre-optimized binary.

Its important to note that Web Assembly requires manual memory management (but the language that you write your application in may help handle this).
Can I intermingle?

This is an extremely relevant question, in my opinion. Maybe you want to continue building user interfaces in React, but have interest in migrating any business logic into WebAssembly for a possible performance gain. Maybe you just want to reuse some code from your server that's written in Rust, Go, C or C++ (or any other language that can target web assembly). There are a lot of use cases where it makes sense to intermingle (use both) JavaScript and Web Assembly. Thankfully, they're made to be interoperable.

Our Simple Web Assembly Program

We're going to start by coding a very, very basic Go program that targets Web Assembly during the build process. Let's start out by printing "Hello World" to the console:

Create a new directory to house our project. I used `mkdir go-wasm`, but you can use whatever you'd like.

cd into your newly created directory and run `go mod init github.com/your-name-here/go-wasm`. Update your command to use your name or username and if you chose a different folder name then update that as well.

We'll create a new file named main.go and add the following to it:

package main
import (
    "fmt"
)
func main() {
    fmt.Println("Hello World!")
}

You'll notice that there's nothing special going on in this Go file. That's not always the case, but for this example we have some extremely normal-looking Go code. In fact, feel free to go run this and make sure it works.

We'll have to add a Web Assembly Support file to run our code. Thankfully, Golang ships with one. We can just run `cp "$(go env GOROOT)/misc/wasm/wasm_exec.js" .`

Next we'll need to setup an HTML file to be rendered to browser. Additionally, we'll include some JavaScript to load and execute our Web Assembly program.

<html>
  <head>
    <meta charset="utf-8" />
    <script src="wasm_exec.js"></script>
    <script>
      const go = new Go();
      WebAssembly.instantiateStreaming(
        fetch("main.wasm"),
        go.importObject
      ).then(result => {
        go.run(result.instance);
      });
    </script>
  </head>
  <body></body>
</html>

Our scripts are the most interesting part of this HTML file. Our first script loads the wasm_exec.js file from step 4, while our second script fetches and executes our web assembly instructions.

Our last step is to build out our `main.wasm` file. We can do that simply by setting a few flags before running our build command: `GOOS=js GOARCH=wasm go build -o main.wasm`. You'll also notice that we're specifying our output filename here, too!

With everything setup, you can serve this directory over an HTTP server however you see fit. If you need recommendations, You can use the goexec package to execute arbitrary go commands (like ListenAndServe). To install: go get -u github.com/shurcooL/goexec and to run a simple HTTP server: goexec 'http.ListenAndServe(:8080, http.FileServer(http.Dir(.)))'

Now that our server is up and running, go to localhost:8080 (or whatever your server address is) and you should see a blank white screen (we'll do more with that in a moment). For now, open your devtools and search for "Hello World" in the console output. If it's there, you've successfully set up and ran a Go program using Web Assembly as a build target.

Adding Elements with Golang/WASM

As far as demos go, this is one of the most underwhelming ones that I could offer. We're about to fix that (don't worry, its still nothing crazy). Our plan is to add a couple of elements to our webpage via Web Assembly and then set some properties on them as well. Let's start by modifying our Go code to look like this:

package main
import (
    "fmt"
    "syscall/js"
)
func main() {
    fmt.Println("Hello World!")
    document := js.Global().Get("document")
    p := document.Call("createElement", "p")
    p.Set("innerHTML", "Hello WASM from Go!")
    p.Set("className", "block")
    styles := document.Call("createElement", "style")
    styles.Set("innerHTML", `
        .block {
            border: 1px solid black; color: white; background: black;
        }
    `)
    document.Get("head").Call("appendChild", styles)
    document.Get("body").Call("appendChild", p)
}

Alright! Let's talk through our changes:

We've added a new import (syscall/js). This gives us access to functions that help us interface with JavaScript related tidbits, such as getting the browser document. In our main method, we do exactly that. We then leverage document.Call to create a new paragraph (p) element. Lastly, we set a few properties on our newly defined paragraph element.

We do the same thing shortly after but with a style Element. In this case, we want to set the innerHTML to apply a css class. Finally, we get the head and the body of the document and append the styles and paragraph elements respectively.

With our changes in place, we can rebuild our web assembly instructions via GOOS=js GOARCH=wasm go build -o main.wasm and relaunch our server via goexec 'http.ListenAndServe(:8080, http.FileServer(http.Dir(.)))' to see our changes. We should see "Hello WASM from Go" in a black box in the document. Tada 🎉!

Ready to learn something new? You can find more tutorials on BradCypert.com!!

Working with JSON in Dart

Brad — Sun, 27 Sep 2020 17:07:44 +0000

Heads up: This post originally appeared on BradCypert.com but has been reformatted on Dev.to for your viewing pleasure.

JSON is, as of 2020, the communication standard for most web applications (comon gRPC! You can do it!). Naturally, if you’re building a Dart application, you’ll likely want to work with JSON. Dart’s built-in dart:convert package is just the tool that you need!

Creating a Model

One of the first things that you’ll probably want to do is to create a model for your JSON data. In this example, we’ll use a simplified version of the Github API’s repository request. If you’d like to inspect the response that we’ll be parsing, here’s the URL : https://api.github.com/users/bradcypert/repos

We’ll start by creating a simple Dart class to model this response. I say “simple” because we’re not going to model all of the fields in that response — we don’t need all that data and it’d be a lot of code that might dilute the quality of this demonstration. We’ll also override the toString method for ease of printing our new model.

class Repository {
  final int id;
  final String name;
  final String description;
  final String url;

  Repository({this.id, this.name, this.description, this.url});

  String toString() {
    return '[${this.id}, ${this.name}, ${this.description}, ${this.url}]';
  }
}

That’ll work. We’ll just capture the id, name, description, and url for our repositories. Now that we have something to store our decoded JSON into, the next step is to actually decode the JSON. We’ll leverage a few Dart packages for these steps. Here’s the breakdown of what we’re going to do:

1. We need to make an HTTP request to the github repository list endpoint.
1. We need to decode the response body into a `dynamic` type for our JSON.
1. We need to use that `dynamic` JSON type to create instances of our Repository Model.

Let’s get to it!

import 'package:http/http.dart' as http;
import 'dart:convert'; // give us the global jsonDecode

class Repository {
  final int id;
  final String name;
  final String description;
  final String url;

  Repository({this.id, this.name, this.description, this.url});

  String toString() {
    return '[${this.id}, ${this.name}, ${this.description}, ${this.url}]';
  }
}

void main() {
  http.get("https://api.github.com/users/bradcypert/repos")
    .then((response) => jsonDecode(response.body)).then((jsonBody) {
      var repos = jsonBody.map((repo) => 
        Repository(
          id: repo['id'],
          name: repo['name'],
          description: repo['description'],
          url: repo['url']
        )
      );
      repos.forEach((repo) => print(repo.toString() + "\n"));
    });
}

jsonDecode is doing all of the heavy lifting in regards to the parsing. We request the data from github, parse it, and then used the parsed JSON to create our model. Finally, for the sake of proving it works, we print our model to the console. Truncated for brevity, you should see something like this in your console:

[199228305, async-http, A channel-based HTTP client built around Golang's net/http package., https://api.github.com/repos/bradcypert/async-http]

[290240968, bradcypert.com, WordPress theme for BradCypert.com, https://api.github.com/repos/bradcypert/bradcypert.com]

[44900977, clojchimp, A small MailChimp client written in Clojure, https://api.github.com/repos/bradcypert/clojchimp]
...

First, pat yourself on the back. You’re parsing JSON with Dart. Second, don’t you think we could make this a little cleaner? Me too. Let’s create a new constructor for our Model.

Refactoring our Model

We’re going to add redirecting constructor to our model here. This allows us to maintain our primary constructor, but specify a new constructor specifically for dealing with dynamic json types of data.

class Repository {
  final int id;
  final String name;
  final String description;
  final String url;

  Repository({this.id, this.name, this.description, this.url});

  Repository.fromJSON(dynamic json) {
    this(
      id: repo['id'],
      name: repo['name'],
      description: repo['description'],
      url: repo['url']
    )
  }

  String toString() {
    return '[${this.id}, ${this.name}, ${this.description}, ${this.url}]';
  }
}

Now, with our new redirecting constructor, we can simplify our main method as well!

import 'package:http/http.dart' as http;
import 'dart:convert'; // give us the global jsonDecode

class Repository {
  final int id;
  final String name;
  final String description;
  final String url;

  Repository({this.id, this.name, this.description, this.url});

  Repository.fromJSON(dynamic json) : this(
    id: json['id'],
    name: json['name'],
    description: json['description'],
    url: json['url']
  );


  String toString() {
    return '[${this.id}, ${this.name}, ${this.description}, ${this.url}]';
  }
}

void main() {
  http.get("https://api.github.com/users/bradcypert/repos")
    .then((response) => jsonDecode(response.body)).then((jsonBody) {
      var repos = jsonBody.map((jsonRepo) => 
        Repository.fromJSON(jsonRepo)
      );
      repos.forEach((repo) => print(repo.toString() + "\n"));
    });
}

How about that? Same output, but cleaner. Note: I know that you can simplify this even further by removing the .map call and just creating the Repository in the forEach instead. Most real world applications don’t just print to the console each of the items they have, and I find that proper use of .map tends to lead towards cleaner code. For demo purposes, you can simplify it, but follow I suggest following the patterns with .map in your own application!

Generating JSON from Models

Now that we know how to decode JSON and generate class instances from that JSON, it’s time that we flip-the-script and do the opposite. We’ll take our Repository class and modify it so that it can generate a Map that we can parse via jsonEncode. So, our steps for this change are as follows:

Add a new method to our model called .toJson
Write the code to return a map containing key-value pairs to represent our model’s data.
Call jsonEncode passing in our Repository instance (toJson method is called be jsonEncode under the hood).

class Repository {
  final int id;
  final String name;
  final String description;
  final String url;

  Repository({this.id, this.name, this.description, this.url});

  Repository.fromJSON(dynamic json) : this(
    id: json['id'],
    name: json['name'],
    description: json['description'],
    url: json['url']
  );


  Map<String, dynamic> toJson() => {
    'id': this.id,
    'name': this.name,
    'description': this.description,
    'url': this.url
  };

  String toString() {
    return '[${this.id}, ${this.name}, ${this.description}, ${this.url}]';
  }
}

So now that we’ve added our toJson method, we can call jsonEncode on a repository object like so:

import 'package:http/http.dart' as http;
import 'dart:convert'; // give us the global jsonDecode

class Repository {
  final int id;
  final String name;
  final String description;
  final String url;

  Repository({this.id, this.name, this.description, this.url});

  Repository.fromJSON(dynamic json) : this(
    id: json['id'],
    name: json['name'],
    description: json['description'],
    url: json['url']
  );


  Map<String, dynamic> toJson() => {
    'id': this.id,
    'name': this.name,
    'description': this.description,
    'url': this.url
  };

  String toString() {
    return '[${this.id}, ${this.name}, ${this.description}, ${this.url}]';
  }
}

void main() {
  // create a new Repository instance in our application
  Repository repo = Repository(id: 0, name: "test repo", description: "No thanks.", url: "github.com/nextawesomeproject");

  // print the repo as is (calling toString under the hood)
  print(repo);
  // print the repo as valid JSON
  print(jsonEncode(repo));
}

And that’ll do it! You’re now encoding and decoding JSON in Dart! Best of luck!

PS: You can TOTALLY make this a tiny bit simpler (or maybe a lot simpler when working with big data structures) by using reflection. Dart’s runtime reflection package (called Mirrors) is actually pretty rad, however it can not be used with Flutter (due to it breaking Flutter’s tree-shaking mechanisms). If you’re using Dart with something other than Flutter ~~please let me know what you’re working on~~ see the reflection package here.

Autosaving with React Hooks

Brad — Sat, 21 Dec 2019 19:12:25 +0000

This post is originally from bradcypert.com, but has been reformatted for your viewing pleasure on Dev.to!

React hooks have really changed the game for me when it comes to building react components. However, I've found that writing autosaving functionality is a little less obvious via hooks. Thankfully, it is still possible (and arguably a lot cleaner) when using hooks.

We can accomplish autosaving functionality through use of useEffect. You'll also need a way to post the data to your server. In my case, I'm using Apollo's useMutation hook as well. This allows me to post a graphql mutation from a hook-like interface.

The `useEffect` hook

The useEffect hook effectively replaces componentDidMount, componentWillUpdate, and componentWillUnmount. Here's how I remember the API for useEffect:

useEffect(() => {
  doWhateverIsHereOnMountandUpdate();

  return () => {
    doWhateverIsHereOnWillUnmount();
  }
}, [skipUntilThisStateOrPropHaschanged])

It's worth mentioning that the skipUntilThisStateOrPropHasChanged is optional, and leaving it out will cause it to process the hook on every render.

Implementing Autosave

Now that we understand our hook, the autosave functionality becomes fairly trivial. We'll use a couple of state hooks as well to help us manage the text that a user types in as well as the last value we saved (we can skip network requests if they're the same).

const [lastText, setLastText] = React.useState('');
const [text, setText] = React.useState('');

You'll see how we use lastText in our useEffect hook below, but for now, you just need to know that text represents the state of what the user has typed in. If you'd like more information on how this works, React's documentation for Controlled Components is a great place to start.

Now, we need a function to trigger to persist our data to the server. In my case, I'll use an Apollo mutation since the server API processes graphql.

const [updateContent] = useMutation(UPDATE_CHAPTER_CONTENT.MUTATION);

Finally, we can write our useEffect hook:

const AUTOSAVE_INTERVAL = 3000;
React.useEffect(() => {
    const timer = setTimeout(() => {
      if (lastText != text) {
        updateContent({ variables: { content: text, id: chapterId } });
        setLastText(text);
      }
    }, AUTOSAVE_INTERVAL);
    return () => clearTimeout(timer);
  }, [text]);

We're doing a couple of neat things here. First, we're setting up our useEffect hook. It creates a timer via setTimeout, and when that hook unmounts, it removes that timer. That's the "meat-and-potatoes" behind it. You'll notice that our setTimeout function checks to see if the text has changed before posting our data, and then sets the last text if it has changed.

We're also only triggering this useEffect when text has changed (as indicated by [text] as the second parameter. We probably could clean this up a bit by removing the if in the timeout function body, and updating the useEffect dependency array to be [text != lastText].

And that should do it! Hopefully, this helps if you're trying to build autosave functionality into React project.

If you'd like to learn more about React, you can find my other post on Facebook's awesome framework here.

Developer Burnout: 9 Tips to Help

Brad — Mon, 25 Nov 2019 16:31:17 +0000

Burnout happens — especially developer burnout. It’s unfortunate, but a fact of life. However, it seems to happen to developers (and maybe Doctors, but you’re not my target audience) far more often than other professions. It may manifest in the emotion of dread, knowing you have to go in to work tomorrow. Or it may manifest in sadness, just thinking about staring at code. Or it may possibly manifest as anger, thinking about the project that won’t seem to work.

Just a heads up, this post originally aired on BradCypert.com but has been formatted for your reading pleasure on Dev.to

Unfortunately, we’ve found that ping-pong tables and dart boards aren’t the cure for developer burnout. Instead, we’ve seen that being given ownership and shown appreciation for your work helps far more than the silicon valley staples of free food or entertainment. Plus, it also helps to have a team that you care about and that also cares about you. It’s all about being engaged in the day-to-day.

Unfortunately, burn-out is something that can be difficult for you, the developer, to prevent. It’s something best prevented by your employer, by ensuring that you can stay engaged and can focus on the work you’re interested in.

Whatever you experience in regards to burnout, you can fight it. I’ve successfully fought burnout in the past but have also failed to fight it — to the point where I just left my job.

Unfortunately, the consequences of burn out can be far more dangerous than just leaving your job. I’ve seen many people post about burnout and their “next play” being in a completely different field. There have also been recent discussions around a connection between burnout and suicide rates. However, with the proper help you can fight burnout and get back to doing what you love.

Here’s nine (hopefully helpful) tips I have to help fight burnout (without leaving your job).

1. Accept that you are burnt out.

When you’re thinking about work, coding, or a project and have no positive emotions about it — you’re likely burnt out. If you’re reading this post, it’s pretty likely that you’re burnt out or are on the cusp of becoming burnt out. And that’s okay! But if that is the case, you need to accept that you may be burnt out.

If you don’t accept that you’re experiencing burn out, you’re likely to only further your level of burn out. In the case of uncertainty, I would suggest treating yourself as if you are burnt out. There’s no harm in any of these tips if you’re not burnt out, and some can be rather enjoyable regardless of whether you are or aren’t burnt out.
A person wearing red shoes in a hammock.

2. Take a break or a vacation.

Take a vacation and just get away from work. Don’t bring your laptop and don’t check your email while you’re away. Instead of checking Slack, consider cutting yourself some slack and just “go offline” for a bit.

Studies are currently quite mixed about this, but from personal experience I can vouch for it. Taking a regular vacation is a great way to help prevent burn out and help fight it if you’re already experiencing burnout.

However, to be successful, you can’t just go somewhere else. You need to take an effort to leave work behind you, and just enjoy something else entirely. For me, this is easiest when exploring a new city. It’s very easy for me to get caught up experiencing new sights and new things while exploring a new city. This helps set my focus on “the moment” and less on work or projects.

That being said, you don't have to go anywhere to enjoy a vacation from work. Some of my most favorite vacations have been stay-cations, where I stay at home and do something local to where I live.

3. Read a book.

Perhaps a vacation sounds intimidating or the logistics behind taking a trip is overwhelming — consider staying in and reading instead. I recently fell back into regular reading and it has been a fantastic way to relax, reduce stress, and just enjoy something created by someone else.

If you’re determined to keep up on soft skills or business news, you can keep up with the latest Business book or whatever Seth Godin has put out lately. However, If you find that to be intimidating but are still interested in reading something, I strongly recommend finding a nice piece of fiction written by a great world builder like Robert Jordan or Anne McCaffrey.

4. Visit with friends or family.

When was the last time you did this? I mean really did this. Not just a lunch date with a friend, or picking up your stuff from you parents place. When was the last time you actually sat down with some friends or family, not rushed for time, and just talked about your life?

A study in 2007 shows that having close friends and spending time with them has a direct effect on happiness. So reach out a friend and invite them out for a drink or to participate in a movie marathon. Maybe go for a hike or a walk!

Of course, the option of making new friends exists too. This idea works great, as often times, you can do this while doing #5 or #6 (we’ll get to those in a second). A great plan of attack to meet new people and work on something new or explore a new hobby is attending a Meetup.

While Meetup.com seems to have a ton of tech related Meetups, you can also find Meetups for other things. I’m in a local hiking group and a local kayaking group, for example.

5. Start something new.

Some companies offer perks like 20% time to work on something that you think is valuable to work on. It’s a great opportunity to mix up the mundane and work with new people or a new language or technology. Starting a side project can be a great way to focus and channel your energy, even if it’s not development related. Fun fact: This blog started as a burn-out side project.

But even if your company doesn’t offer these perks, that doesn’t mean you cant pursue a new project. Although everyone has different obligations in life, most people can make the time to work on something interesting — something they care about. If you spend an hour on Netflix each night after putting the kids to sleep, consider spending thirty minutes on Netflix and thirty minutes working on that book you’ve always wanted to write. In a week, you’ll have contributed three and half hours towards writing a book!

If you’re burnt out on “that terrible Java project” but still want to code on something, try exploring alternatives. If you don’t want to touch code at all consider starting a blog or try your hand at designing something. Maybe take the time to work on a home improvement project. Find something that will either challenge you or offer you a meaningful sense of fulfillment when completed and tackle it!

6. Explore a hobby.

Explore a hobby – especially if this is a hobby that you’re naturally skilled at. This is great because if you’re skilled at it, you’re likely to succeed in your practicing of the hobby and it likely won’t be as mentally exhausting as development.

Ultimately the goal is to help establish an identity for yourself outside of being a developer. What does that mean? A lot of us dedicate a slice of our lives to our career. We may work twelve hour days, or be expected to promptly respond to emails 24/7, or maybe are always on-call. This leads us to always be work-focused.

And if it’s not work, maybe it’s something else that’s development related. Maintaining an open source project, working on a side project, or even trying to learn a new technology. It feels so easy to get caught up in the endless cycle of development, that, even if you’re not “working”, you’re still focusing on work or development.

Hobbies help give us something else that makes us who we are. I’m not just Brad, the Software Architect — I’m Brad, a hiker and photographer that does software for a living. An interesting side effect from having hobbies is that you have more people to socialize with, and you don’t bore the socks off of people by talking about programming when they just don’t understand it.

7. Go outside.

Not only are some of the most enjoyable activities outdoors, but studies have shown that sunlight helps the body produce serotonin, and serotonin helps promote positive moods and a clearer mind. Additionally, exercise has been shown to promote happiness. With these things in mind, I can’t stress enough how important outdoor activities are. When the weather is warm, I try to take a walk at work each day. Small, but helpful.

However, I wasn’t always a fan of being outdoors (that sounds weird, but its true). It wasn’t until about two years ago — when I met my dog, Luna — that I found myself making time to go outdoors. In a weird way, the responsibility of need to take her for walks helped force me to spend more time outside, and when we go out on those walks, I enjoy them a lot, now.

I’m not saying you have to go adopt a dog, but do try to find a way to motivate yourself to spend time outside. The sunlight and fresh air does really help.

8. Seek professional help.

If you’re struggling with burn out, professional help may be the best option. There is no issue with requesting psychological or psychiatric help if there doesn’t seem to be a way to help your burnout. A lot of times, simply talking with a therapist or even a career counselor can help.

Fortunately, science is further investigating burnout, so there’s hopes for new breakthroughs in treating burnout. Unfortunately, for now, most of the evidence seems inconclusive in studies, but I’ve seen art therapy mentioned a lot with anecdotal successes.

Regardless, there are people and processes in place to help cope with (or fight) developer burnout. Finding the right one for you may take some time, or effort, but it’s definitely worth it.

Also, a lot of companies have started to offer mental health days and other psych-related forms of compensation.

9. Stop exhibiting behavior that leads to burnout.

This one may seem obvious, but I want to mention it as its the most important. If you are burnt out, then you have to identify what is burning you out and stop doing it.

Maybe you’re working twelve hour days. If so — Stop. Talk to your manager about it and inform them of your concerns regarding a work life balance. If they want to keep you around, they will help you find that balance.

Maybe you’re working on a project that you just can’t stand to work on. Maybe it’s dreadfully boring or you’re struggling and just cant seem to figure it out. Either find help or find a different project to work on. Sometimes you do have to push through and see unenjoyable work to completion, but if that’s all you’re doing — consider doing something else.

If your burnout stems from your team, talk to them about it. Don’t point fingers or try to pass blame, but instead explain to them how you’re feeling and what you feel might help you feel better. If nothing comes out of that, talk with your manager and consider trying to switch team.

If your burnout comes from the thought of writing code, try to find something else to do for a while. While working as a Software Developer for CARFAX, I had a few months where I helped design internal tools. This was such a pleasant reprieve from writing code and really helped me stay motivated. Plus, it let me explore a new interest.

How do you cope with burnout? Feel free to share your successes or concerns below. We’re all in this together.

Interview with Indie Game Dev Barry Rowe of Roaring Cat Games

Brad — Sun, 24 Nov 2019 15:54:51 +0000

I've got the podcast itch, and I just can't seem to scratch it. Believe me, I tried. I even recorded my 2nd episode of Design Doc just yesterday and have already published it out for your listening pleasure! I thought that would help, but I'm so ready to record episode three now!

In this episode, I talk with Barry Rowe of Roaring Cat Games, an Indie GameDev shop in Louisville, Kentucky. We talk about the tools he leverages while developing games, how his day job (of Android Developer) carries over to working on Games, and tips for aspiring game developers.

.ltag__user__id__278821 .follow-action-button { background-color: #5013c2 !important; color: #ffffff !important; border-color: #5013c2 !important; }

Barry RoweFollow

If you're interested in listening in (and I hope you are!) you can find the episode here on Anchor.fm or anywhere that podcasts can be heard.

Think I've missed an important question in this episode? You can leverage the anchor.fm link above to record your own questions and send them in to be asked on the podcast (your voice and all)!

Announcing the Design Doc Podcast

Brad — Tue, 12 Nov 2019 22:28:10 +0000

Hey there! I'm a bit ashamed to say that my first Dev.to post is self-promotion, but this is the first big thing that felt worth sharing! I just launched a Podcast! It's called Design Doc, and the goal is to help more junior developers gain knowledge around project development, tools, and technologies.

The vision involves showing how experienced developers do their work, often in their spare time. This highlights the idea that, when trying to ship something, it's often okay to skimp on the nine-to-five requirements like tests, CI/CD, etc.

My first interview is with a long-time friend and engineer at LinkedIn. We talk about one of his personal projects and how he's built it. We cover the tech side as well as the project side so developers can get some insights into building their own product.

I'd really appreciate it if you'd check out the first episode and let me know your thoughts :)

https://anchor.fm/design-doc