divan's blog

My experience with EdgeDB

Tue, 26 Jul 2022 18:11:29 +0300

Tomorrow is an announcement of EdgeDB 2.0, and I realized that I’ve never shared my experience with it, and it’s been more than a year since I switched every project I could to EdgeDB. So here is a short post on it.

What is EdgeDB?

It’s an open-source relational/graph database built on top of Postgres.

Unlike many other databases, it doesn’t reinvent the underlying engine and uses battle-tested Postgres. But it reinvents everything else for you as a database user. For me, the two most important innovations here are – query language and tooling.

War

Fri, 04 Mar 2022 03:39:32 +0200

It’s 3AM of 4th of March, 2022, but it’s just “the eighth day” for Ukrainians. We don’t know what day it is any more because every day lasts at least ten lives.

I was in Kyiv a day before the war started. On Wednesday, I flew to Estonia for a regular business trip. I had only a small backpack and planned to return in a few days.

I’m safe, but everything that makes me me – is not. My nation, country, culture, language, self-identity, people I love and the very right of existence are under brutal attack. Being in safety while millions of Ukrainians are sleeping in the bomb shelters or fleeing is killing me. Why did I choose precisely this day for flight?

I still ❤️ you, GOPATH

Mon, 30 Sep 2019 09:04:59 +0200

The newest release of Go – Go 1.13 – finally introduced full support for Go Modules – brilliant and long-awaited solution for built-in dependency versioning problem. Modules now enabled by default, and virtually make GOPATH obsolete.

Technically speaking, GOPATH is still supported, and Go 1.13 Release Notes uses term “GOPATH mode” (as being opposite to the “modules mode”), but still, to me this is a tectonic shift in the Go development ecosystem evolution. Now you or your static analysis tools no longer can assume that all code lives in one large directory.

Rethinking Visual Programming with Go

Sat, 01 Jun 2019 14:55:00 +0200

This is a blog version of the talk I gave at GopherCon Europe 2019 (Canary Islands Edition), where I shared my thoughts on why Visual Programming Languages have failed and revealed for the first time my experiment on visualizing Go code.

I could dive in straight into the project, but I do believe to truly appreciate it, I have to explain the thought line behind it first.

It starts with an almost existential frustration of working with code as a text.

Thought Experiment: Flutter in Go

Sat, 12 Jan 2019 14:55:00 +0200

I’ve recently discovered Flutter – a new Google’s framework for mobile development – for myself and even had an experience of teaching Flutter basics to the person who has never been doing programming at all. Flutter is written in Dart – programming language born in a Chrome browser and then escaped to the console land – and that made me think “hey, Flutter could have been easily implemented in Go as well”!

Creating WebGL apps with Go

Mon, 10 Dec 2018 00:00:00 +0000

TL;DR In this article I’ll share my experience building an interactive 3D WebGL-based application for peer-to-peer messaging protocol simulation without writing any single line in JS. You’ll learn how GopherJS and Vecty framework can dramatically lower the complexity of building WebGL-enabled web apps in Go.

It’s often said “A picture is worth a thousand words”, but in the era of high-DPI screens and big data, the new idiom is now truer – “3D interactive visualization is worth a thousand pictures”.

Fountain codes and animated QR

Sat, 01 Dec 2018 16:55:00 +0200

^{(source: Anders Sune Berg)}

In the previous article I’ve described a weekend project called txqr for unidirectional data transfer using animated sequence of QR codes. The straightforward approach was to repeat the encoded sequence over and over until the receiver gets complete data. This simple repetition code was good enough for starter and trivial to implement, but also introduced long delays in case the receiver missed at least one frame. And in practice, it often did, of course.

Animated QR data transfer with Gomobile and Gopherjs

Sun, 18 Nov 2018 11:55:00 +0100

TL;DR: a weekend project for transferring data via animated QR codes, written in Go and using fountain erasure codes. The Go code is reused for mobile apps using Gomobile, and in a web application for automating testing QR codes parameters, built with GopherJS and Vecty framework.

I’ll share my experience building it, some code and benchmark results of using animated QR as a data transfer method.

WakeMeUpInTheMiddleOfTheNight log level

Fri, 26 May 2017 12:55:00 +0100

On the last Golang Barcelona meetup we decided to try new format of conversation and after the talk started open discussion on logging, tracing and metrics. The idea was to encourage people to read a very nice blog post by Peter Bourgon on this subject - “Metrics, Tracing and Logging” and discuss it in a free format.

It went surprisingly well, and while most of the people were conscious about the topic, one thing seemed to be still confusing - what to log and when. I think we’re all more or less agree that we should log only when program requires human to take a look. It wasn’t a case, let’s say, 10 years ago - there were no ELK, solid solutions for metrics or tracing - we were using logs for everything, then were building “log analyzers” to deal with a vast amount of information. But now, when we have all these best practices, powerful time-series databases, visualization platforms, tracing tools - what should we print to the log?

Misusing error interface

Wed, 08 Mar 2017 12:07:40 +0100

I used to think that misunderstanding interfaces in Go can lead, at most, to not very readable code and worse maintainability. From my observations misusing interfaces becomes visible usually during refactorings, where you questioning what this type or abstraction actually represents. But, at least, the code tends to work and it’s not buggy.

The bug

But here is the interesting piece of code that actually was buggy:

err := SomeFunc()
if _, ok := err.(MyError); !ok {
    log.Println(err)
}

Quite idiomatic, right? Error type naming is good, following recommended way to name error types and variables. We use here normal type assertion, “extracting” underlying static type from an interface. If an error doesn’t have this type inside, we should log it.

How to avoid Go gotchas

Fri, 04 Nov 2016 13:25:35 +0100

TL;DR by learning internals

a gotcha is a valid construct in a system, program or programming language that works as documented but is counter-intuitive and almost invites mistakes because it is both easy to invoke and unexpected or unreasonable in its outcome (source: wikipedia)

Go programming language has some gotchas and there is a number of good articles explaining them. I find those articles very important, especially for the newcomers in Go, as I see people run into those gotchas every now and then.

My GopherCon experience

Wed, 03 Aug 2016 19:28:46 +0200

A couple of weeks ago I gave a talk at the largest Go conference, GopherCon, in Denver. It was the first time I attended GopherCon at all, and the first time ever I spoke in English in front of 1400+ people, and it was an absolutely incredible experience. Here is my story.

My journey to GopherCon started on a cold winter day in the apartments in the center of Odessa, Ukraine, where I was living at that time. I was one of the organizers of the first Go meetup in Lviv (Ukraine) and have prepared one general talk about Go. We targeted mainly newcomers, so I wanted to make another talk that would share my passion and admiration of some of the coolest aspects of Go - concurrency.

go get for private repos in docker

Wed, 01 Jun 2016 19:28:46 +0200

As Go community slowly moving towards established and well understood patterns and practices of dependency management, there are still some confusing moments. One of them is automating repeatable build process using containers along with using dependencies in private repositories.

Private repositories on Github are often is a source of confusion when using go get, but it has easy workaround by adding two lines to your .gitconfig:

[url "[email protected]:"]
	insteadOf = https://github.com/

or as a oneliner:

LeftPad and Go: can tooling help?

Thu, 31 Mar 2016 04:30:29 +0300

You’ve probably heard that story about NPM community and LeftPad package, that broke thousands JavaScript projects worldwide. There was a nice follow-up article titled “Have We Forget How To Program” and one guy even created left-pad.io - Left-Pad As A Service web service. People got a lot of fun discussing this story.

I personally find this story amazing, because there is no single point of failure, but rather a set of things and coincidences resulted in a disaster. Every person I spoke about left-pad story sees it through it’s own lens of concern. Some blame JS-community, some talks about how important vendoring is nowadays and others stands for absolutist views of the DRY principle.

Visualizing Concurrency in Go

Sun, 24 Jan 2016 18:31:12 -0300

If you prefer video over blog posts, here is my talk on this at GopherCon 2016: https://www.youtube.com/watch?v=KyuFeiG3Y60

One of the strongest sides of Go programming language is a built-in concurrency based on Tony Hoare’s CSP paper. Go is designed with concurrency in mind and allows us to build complex concurrent pipelines. But have you ever wondered - how various concurrency patterns look like?

Of course, you have. We’re all thinking mostly by visualization in one form or another. If I ask you something involving “numbers from 1 to 100” you will have your own image of the series in your head, even without realizing it. For example, I imagine it as a line going from me with numbers from 1 to 20, then it turns 90 degrees to the right and continues to the 1000+. I recall from very young period of my life that in our kindergarten there were numbers in a cloakroom, written along the wall, and number 20 was exactly at the corner. You probably have your own image of numbers. Another common example is the visual representation of the full year with four seasons - some people see it as a box, other - as a circle.

How to complain about Go

Mon, 14 Dec 2015 08:36:54 -0300

Over the years of existence of Go programming language, the articles with its critique was always popular, bringing a lot of discussion from both sides. Recently, Maksim Kochkin even created GitHub repo with curated list of articles complaining about golang’s imperfection.

So, is it true that ranting about Go flaws is a trend nowadays? With carefully gathered links in the repository above, we can check this! :) Unfortunately, there are only 17 articles in the list, which is a bit disappointing because it’s not enough for fine statistical analysis, but we can use this anyway.

Integration testing in Go using Docker

Mon, 07 Dec 2015 08:36:54 -0700

Note: this post was originally written for the Go Advent 2015 series, but I discovered that a post with almost exactly the same subject (and even similar code!) already planned :) That’s amazing.

Golang is often used for writing microservices and various backends. Often these type of software do some computation, read/write data on external storage and expose it’s API via http handlers. All this functionality is remarkably easy to implement in Go and, especially if you’re creating 12factor-compatible app, Go is your friend here.

Explaining Go error handling

Mon, 02 Nov 2015 08:36:54 -0700

I recently translated great article — Errors are values by Rob Pike — and we discussed it in our podcast Golangshow (in russian). One thing I was surprised about is that even experienced Go developers sometimes do not understand the core idea of that article.

Looking back, I remember my first impressions when I read it for the first time. It was similar to “It looks like Pike just adds some complexity to what could’ve been solved gracefully with exceptions”. I have never been fond of exceptions, but that’s the first thought I remember. The example in the article was clearly asking for comparison with exceptions’ way to deal with errors and it didn’t look like a winner here.