Øyvind Gerrard Skaar

Prototyping with NoCode and AI tools

2024-04-10T00:00:00Z

I'm currently trying out lots of different No-code and AI tools to create mobile and web apps. The goal is to be able to make prototypes and MVP's much faster and cheaper.

Startups and others who want to create something new are often faced with a dilemma: They would like to create an app of some sort to test their idea and to have something to show off.
But, unless you are a developer and designer, it can quickly cost a at least a few hundrede thousand dollars. And even if you can do it yourself, it takes a long time to create things "from scratch".

All these tools have disadvantages. But given that the advantages are so great, I think it can be a good solution for many.

Advantages: Create something quick and cheap. Do it yourself.

Cons: There's still a lot to learn. The result could be worse. Many different tools, with their own advantages and disadvantages.

As a developer, I enjoy programming. But I also like to make things, with or without coding.

So I'm testing many of these tools and platforms and will share my experiences here

Criteria

I look for tools that are useful for me and my clients. That is, they can help create apps of various kinds, for startups and the like.

More specialized tools are interesting if they help create things that entrepreneurs often want to create. E.g. with Sharetribe you can create a marketplaces, where some sell and others buy, and that is something many people want to do.

Several things disqualify many tools at straight away:

Price: Either too expensive for a typical startup project or high price per end user.
Designed for large companies and their needs. Often related to price, but also what these tools are good and bad at.
Specialized in the "wrong" niche. E.g. there are many tools for creating web forms and glorified spreadsheets (A la Airtable).
Too difficult to test out or to get started with.
Made for developers, for faster development, but requires programming.

While things that are a pluss, and the generalist tools should have:

Storage of data (some kind of database)
Logic required to create apps (If A then B..)
Many users: Support for creating a user, logging in etc (authentication)
Many users: Not everyone has access to the same things (authorization)
Support for creating apps for mobile (native iOS / Android, and/or progressive web apps)

Here is the list of the ones I will test. Did I forget any? Anyone have experience with one or more of these?

On the "to try out" list

Generalist, "all purpose" platforms

Adalo

Platform for creating web apps and mobile apps. I used Adalo about 4 years ago to make a prototype. Quite liked it.

Price: From 0$ to 200$ per month. The most relevant plan costs 30$ per month, lets you use your own domain etc.

Bravo Studio

From Figma design to a native mobile app.

Price: From 0$ per to 118$ per month. The 2 most relevant plans costs 21$ and 118$ per month. The expensive one is required to remove the Bravo logo/branding.

Bubble

One of the oldest and best-known platforms for creating web apps. I tried it out about 4 years ago, with somewhat mixed results.

Price: From 0$ to 399$ per month. The most relevant plan costs 32$ per month, lets you use your own domain etc..

Budibase

Price: 5$ per user per month?

Open source?

FlutterFlow

Price: 0 - 70$ per month.

Glide

Possibly a bit too "enterprisy" for my use.

Price: 2 price models: "For Makers" and "For companies". Maker is probably the most relevant and costs 60$ per month (?). Although it seems like it has fewer data sources than the "for companies" one.

Google Appsheet

Looks pretty versatile. Probably good integration with the rest of Google Workspace (Google Docs etc). Maybe a little limited?

Price: A bit unclear. 10$ per user per month? More if you want AI integration? Some of it included a Google Workspace subscription?

jetAdmin

Price: From 49$ per month, 349$ to use your own domain.

Plasmic

Open source. Mostly focused on design and visuals. Maybe a little too simple?

Price: From 0$ to 499$. The most relevant plan, to remove the Plasmic logo, costs $49 per month.

Open source, so you can use it for free, with all functionality etc?

toddle

Quite new. Norwegian? Danish?

Price: Actually looks quite cheap, but what does 20$ per user mean?

WeWeb

WeWeb is a "front end builder" that is used with another back-end solution of some kind. For me it would perhaps be appropriate to code a back-end myself. But there are also pure no-code back-end solutions such as Xano. Maybe Pocketbase could work as well.

Price: From 0$ to 179$ per month. 49$ per month to use your own domain. 179$ for more advanced functionality.

Plus the price of a back-end system.

Wized

Wized works together with Webflow to let you make more advanced websites and web apps than you can with Webflow alone. Looks good. Perhaps most relevant if you already know Webflow?

Price: From 0$ to 169$ per month. 12$ per month to use your own domain.

Plus you have to pay for Webflow in addition?

Xano

Xano is a little different because it is only a backend system. Most no-code tools have both a "front end" and a "back end" that work together. This means that Xano alone is not enough, and must be used together with e.g. WeWeb.

Personally, I would have tested Pocketbase at the same time as Xano, since it is open source and setting up a small server is something I'm comfortable with.

Price: From 0$ to 225$ per month. The most relevant plan costs $99, but I think you can go a long way with the free plan.

Plus the price of a front-end system.

Specialized

Sharetribe

A platform for creating marketplaces, that is, a place where someone sells something and someone buys. Such as Craigslist and Airbnb. But you can also sell for example something by the hour.

Price: From 29$ to 249$ per month.

Figma plugin for generating code

"Figma to Code" is a plugin for the design tool Figma. It is one of many such tools for creating code from designs in Figma. Supports html and css (with Tailwind), Flutter and SwiftUI.

Alone, this is not a "no-code" tool. But there are several AI tools that support creating designs in Figma for you (see below).

Price: Appears to be free to use and Open source

Generative AI

These are a little different. With the exception of Buzzy, they typically only create a design (UI) and perhaps code to implement the design (html and css).

You cannot create a full web app or mobile app in most of these tools.

But using generative AI can save us so much time that it's worth testing.

I'm guessing the UI's most of these create are pretty generic, and not as good as a good designer could have made. So they may not be good enough if your app is to stand out from the crowd with especially good design and UI.

Buzzy

Looks good, certainly one of the most promising on this list. When using chat (a text description), it creates a UI for you. After giving you a change to change the UI in Figma, Buzzy should in theory be able to create a working web or mobile app.

Buzzy is one of the few AI/AI tools that does more than create a design and/or html and css.

Price: Not entirely obvious, but it seems that you can now pay 50$ per month to generate UI (and code?). Whereas if you want them to "host" the web app (make it available to users) it costs $600 for a year.

No free trial.

See Special offers.

Galileo

When using chat (a text description), it creates a UI for you. The result is a design in Figma. Unsure if it can also create code to implement the design. If not, you can probably use the Figma plugin mentioned above.

Price: 19$ per month, but everyone can see what you create. 39$ for "private mode".

Rendition

Rendition is actually two different things:

Rendition Create: Create a design based on chat and either export it to Figma or create code to implement it (html and css with Tailwind).
Rendition from Figma: Take a design in Figma and create code to implement it (html and css with Tailwind). (Could not get this work last time I tried).

You can test it for free.

Price:

Renedition Create: Not sure, 10$ per month?
Rendition form Figma: Free to use a bit, then 10$ per month for more use.

Uizard

Generate design and UI with chat or from a screenshot or wireframe.

Can also create some code (html, css and React code).

Seems to have a lot of functionality for creating and editing UIs. So it's also a simpler alternative to Figma.

Price: From 0$ to 49$ per month.

Vercel v0

Vercel v0 is similar to Galileo. When using chat (a text description), it creates a UI for you. v0 creates code to implement the design (html, css with Tailwind and React).

v0 cannot export to Figma and is perhaps more "tied" to React than the other similar tools?

Price: From 0$ per month, but everyone can see what you create. For $20 per month you get to enjoy what it makes and also "High Quality", whatever that means.

Discared

Appfarm
Very curious about Appfarm and want to check it out.

But in general it is probably too expensive for my use, typically 1000-2000$ per month, if I understood it correctly.

Genus
Too "enterprisy". Norwegian, large customers, have been doing this for a while.

Hadron
Design. Creates html and css for you?

Interplay
Design heavy: React components and design tokens.

Kombai
Design for React, html and css. Requires coding?

Motor Admin.com
Similar to Airtable (spreadsheet style)

nocodb{.com}
Similar to Airtable (spreadsheet style)

OutSystems
Too expensive, starting at $1,513 (USD) per month.

Looks good, logic, mobile apps etc

Play
Looks good, but only for ios apps

Retool
For "business applications", pay per customer

RNBW
Design. Creates html and css for you?

Stacker
For "business applications"

Teable
Similar to Airtable (spreadsheet style). Open source.

Utopia
For React, requires coding?

Vizro
"Python enabled data visualization"

Webstudio
Similar to Webflow, i.e. lacks "app" functionality. Open Source.

How to use Google Cloud Storage with Golang

2016-10-26T00:00:00Z

I recently had the "pleasure" of getting started with Google Cloud Storage using Go. It was a hassle, but all's well that ends well.

Google Cloud Storage, Storage or GCS for short, is a S3 like service from Google. It lets you store files and other "blob" data cheaply and easily. These files can be private or something you share with the world. With public files, Google will cache them automatically to make fetching them faster around the world. See the official Storage page for a longer salespitch.

Storage is a part of the overall Google Cloud Platform that also includes things like Compute Engine and App Engine (comes in two flavours: Standard and Flexible). See the Google Cloud Platform homepage for more.

Go (or golang if you want) is an open source programming language started by some guys at Google and now used by many people for many different things. It's seen most success within newer, devops like, serverside tools such as Docker, Kubernetes and Consul. This is not the only usecase though, as it's a general purpose language with many strong points. I currently use it to build back-end systems that talk http, http/2 and websockets with mobile app's, JS frontends, special hardware etc.

Digression: A short Google Cloud Platform rant

Before we get to the point, I have to rant a little about the Google Cloud Platform (GCP). In many ways I'm a fan. It seems like they understand "no ops" better than almost anybody, and in my opinion App Engine could be the only real PaaS out there. Their pricing model is very nice, with a linear increase in costs as the traffic increases (quite unlike Heroku). With Compute Engine, their EC2-like IaaS, you get automatic discounts when running a server for more than 25% of a month (quite unlike Amazon's reserved instances). This means there's no need to "reserve instances" up front. Just run a normal instance for enough time and get automatic discounts. Great!

So, there are many things to like about GCP, but obviously things are not perfect. While the platform itself seems well-engineered, the developer experience can be horrible at times. The learning curve is a roller coaster, usually for stupid reasons.

If you're in a hurry and you don't have anyone with GCP experience I would probably recommend something else. That being said, developing on GCP is fast and easy when you know how to do it. If you can avoid the quirks and gotcha's, the platform itself in incredibly powerful.

There's three main problems I've seen so far:

The documentation falls into three categories: Correct, Outdated and Just Plain Wrong. It sometimes feels like they are distributed evenly, and therefore only correct 33% of the time, but that's probably just me being negative.

Related, there's usually 3 or 4 libraries to do something:
- 1-2 legacy libraries that you are discouraged to use
- 1 new, but still in beta and missing some feature, library,
- 1 lib that's auto generated and probably works most of the time kind of.
- (The documentation, of course, refers to one or all of these seemingly at random).

Quirks and gotchas in the different products. These are actually, for the most part, documented and well known. They can still bite you though if you're not careful.

We'll see all these 3 in action here.

Cloud Storage with Go

I did not start completely from scratch. I already knew Storage pretty well having done something similar with Storage, App Engine Standard and Python.

The question therefore, when starting out, where something like:

When developing on App Engine Standard (AE) you usually run it on your own machine first. The AE tooling helps to simulate some of the AE and Google Cloud Platform services locally. Can these tools simulate Storage locally? This would be useful when writing and testing new code.

Which of the many libraries should I use? Do I need more than one?

I'm working with private (not public) files. How is authentication handled?

These questions answered, in order:

Can you simulate Storage locally?

The short answer: No you can not. Use one or more buckets just for testing.

What most people end up doing is to have 1 or more Storage buckets just for development. This actually works pretty well when you get authentication working (quite easy, more on that later). You have to pay for the traffic you upload and download when testing, but the price is so low that it's just a rounding error for most usecases. Of course, if your files are very large uploading them could take some time. On the other hand, you probably have to upload them sooner or later anyway. And having them in the real Storage makes them accessible to the rest of the Google Cloud Platform, most of which integrates nicely with Storage.

The App Engine Standard tooling includes support for something called "Blobstore" which is the AE specific predecessor to Storage. It has some limited interoperability with Storage: You can tell it to actually store the files in Storage instead of in the old blobstore. I haven't tried this as I can't really see any of my projects staying with just the Blobstore for very long. Storage integrates with the rest of the Google Cloud, has many extra features and keeps evolving.

Which Go library should you use with Storage?

The short answer: Use the new gcloud Go libs: Main page / Storage client docs

This is the newest library and even though it's marked with "beta" it seems stable enough that people use it in production.

Here are the different libraries I've found so far:

See what I meant in my rant? I probably even forgot a couple..

How do you authenticate to the "real" Storage when running locally?

The short answer: Use the gcloud lib mentioned above. Install the gcloud client program if you haven't already (not related to the gcloud lib, confusing eh? =)

Run:

gcloud beta auth application-default login

on the command line and log in with your Google account.

After reading and googling this stuff for a while I was under the impression that this was more complicated. The above methods uses the developers Google account to authenticate with Storage. This is useful when running locally, but is a bad fit in some situations. You may want the program or machine to authenticate instead of the developer, for example when running automated tests. Therefore there are other ways of authenticating, mainly using Key files and something called Service Account's.

I haven't tried this in Go, but the process seems to be:

Generate and download a key from the Cloud Console. You can use an existing Service Account or create a new one. You find this under IAM & Admin ⇒ Service Accounts.

Pass this keyfile to the gcloud library like this:
```
client, err := storage.NewClient(ctx, option.WithServiceAccountFile("path/to/keyfile.json"))
```
All that is not necessary to just run code locally against the real Storage. Contrary to the common wisdom (at the time of writing), the helper gcloud command above (gcloud beta auth application-default login) actually works. This makes using the gcloud library a breeze, just do:
```
client, err := storage.NewClient(ctx).
```
When running on the Google Cloud Platform the same code just works and you should not have to think too much about authentication and authorization in common scenarios.

One last tip: I could not get auto-detecting of the bucketname, as seen in the docs, to work. This confused me for a long time since it doesn't throw an error, it just returns an invalid bucketname.

Hopefully this is useful for someone. It took me hours to figure out, but it's pretty simple and straight-forward when you know how to do it =).

Learn from my Go mistakes, Part 1: Closing over loop variables

2016-05-11T00:00:00Z

This post is about a mistake that's common and easy to make in Golang. I show a few examples, explain why it happens and how you can avoid it. This is explained in many places already (see links at the end). My goal is to be more thorough than the others.

There might be many of these blogposts. There's at least one more topic I want to write about. We'll see.

Closing over a loop variable

This mistake is very easy to make in some situations. If you please, take a look at the code below and try to figure out why Example B fails.

(Most code snipet has a link in the header to the Go Playground where you can run and play with the code. All links open in this window).

Print out the numbers from 0 to 2:

(On the playgroud)

package main

import (
    "fmt"
    "time"
)

func main() {

    // A
    fmt.Println("Example A - Count to 2, This works :) ")
    for a := 0; a < 3; a++ {
        fmt.Println("a is:", a)
    }

    // B
    fmt.Println("\n\nExample B - Count to 2, concurrently.")
    fmt.Println("This does not work :( ")
    for b := 0; b < 3; b++ {
        // Run fmt.Println(..) in the background
        go func() {
            fmt.Println("b is:", b)
        }()
    }

    // we sleep to let the go functions finish before the program quits
    time.Sleep(2 * time.Second) 
}

Running the above code prints:

Example A - Count to 2, This works :) 
a is: 0
a is: 1
a is: 2


Example B - Count to 2, concurrently.
This does not work :( 
b is: 3
b is: 3
b is: 3

Huh? 3, 3, 3? Where's zero and one? And wasn't it suppose to stop at two? Bah! We can't even count to 2, what's going on? Two things:

Closures

Firstly, when we print variable 'b' in Example B what are we even referring to? It's inside of a function, and there's no variable 'b' inside this function body. If you did this in a normal function you would get a nice little error from the compiler complaining that there's no 'b'.

This does not happen here. The function we have in Example B, 'func(){..}', is not a normal function: it's in the middle of another one and it lacks a name. These types of functions are often call function literals or anonymous functions. I like "anonymous functions". An anonymous function can "see" variables from the function it's inside (enclosed in). That means that in our example it can access variable 'b'.

This is not a bug in Go, by the way. It's intended behavior that can be used to do some pretty advanced stuff. See the "function closures" links at the end.

Variable reuse

Our anonymous function can access variable 'b'. But it's the same variable 'b', accessed 3 time in the loop. It's declared once before the loop starts to run. It then changes value from 0 to 1, then to 2 and finally to 3. Then the loop stops since 3 is not less than 3.

Goroutines runs out of order

With our 'go func()..' statement we start a new goroutine. They run concurrently, which they do not run one after the other in an orderly fashion. They could in theory run one after the other, or they could all run at the same time (in parallel). Or maybe the "last one" runs first and then the "first one" and the "second one" runs last, or maybe.. think you get the point; it's unpredictable. Well this is kind of the point of using Goroutines in the first place. We want to be able to run many things at once. In this example it does not make a lot of sense, but imagine, if you will, that the printing took 10 seconds. Or we did something else that took 10 seconds. In that case Example A would take 30 seconds to complete and Example B would only take 10 seconds. Great!

We can think of the go statement as "run this code in the background at some point". It could run right away, or it could run later. Thinking like this it becomes more clear why Example B fails. It's possible, likely even, that the loop finishes before the first 'fmt.Println("b is:", b)' ever runs. So the loops runs, increasing 'b' to 3 and then stopping. Then the goroutines run and print variable b. They all look at the same variable b, the one declared at the start of the loop. They never got their own copy. At this point 'b' is 3, so they all print 3.

Fixing it

There are several ways to change our code and fix this bug. I've listed the 3 I could come up with at this time, with the last one possibly being the most "idiomatic" go.

Each of these examples should print something like this if you run them. Note that the numbers can be out of order, since the goroutines can run in any possible order, or all at once.

Fix 2 for Example B
dd is: 1
dd is: 0
dd is: 2

Alternative 1

One easy way of fixing this is to change the anonymous function to a normal function call. Normal functions can not refer to variables "outside" itself. This forces us to pass the variable we want to use as an argument to the function (print() in our example). When you call a normal function the arguments are copied, every time you call it. That is, the value of 'c' (0, 1 or 2) is copied and given to the invoked function. Therefore this works as you would expect:

(On the playgroud)

package main

import (
    "fmt"
    "time"
)

func main() {

    // Fix 1
    fmt.Println("\n\nFix 1 for Example B")
    for c := 0; c < 3; c++ {
        // same code as earlier,
        // but no longer in an anonymous function:
        go print(c)

        // The value of c is copied when we call print()
        //   so it's no longer reffering to the same variable.

        // This copying happens before the code
        //   in print() actually runs
    }

    time.Sleep(2 * time.Second)
}

func print(c int) {
    // The value of c was copied.
    // So 'c' here is not the same as 'c' in the for loop above.
    // It's a "coincidence" that they are both named c
    // (it's irrelevant).
    fmt.Println("c is:", c)
}

Alternative 2

But let's say you wanted to keep the anonymous function? They can certainly be useful, creating a named function that is only used in one place is kind of ugly. This code fixes this by explicitly copying the variable before using it in the anonymous function. This works because each run (iteration) through the loop now gets its own variable, with its own value. So it does not matter when the goroutine actually runs. It will refer to its own variable 'dd' that never changes.

(On the playgroud)

package main

import (
    "fmt"
    "time"
)

func main() {

    // Fix 2
    fmt.Println("Fix 2 for Example B")
    for d := 0; d < 3; d++ {
        // The value of d is copied into its own variable. 
        // This happens for every iteration in the loop.
        dd := d
        go func() {
            fmt.Println("dd is:", dd)
        }()
    }

    time.Sleep(2 * time.Second)

}

Alternative 3

Finally this fix is similar to the first one (well, actually they're all pretty similar). Here we also copy the variable for every iteration of the for loop. Our anonymous function still sees the variable 'e' but ignores it. Instead we send in the variable we want to access when we call the anonymous function.

Having both 'e' and 'ee' inside the function body can be a little confusing. We could for example use variable 'e' by mistake and the compiler would not complain. Therefore some people prefer to name the second variable the same as the first one ('e' instead of 'ee' in our example). This has the effect of hiding (shadowing) the first one and thus making it inaccessible.

(On the playgroud)


package main

import (
    "fmt"
    "time"
)

func main() {

    // Fix 3
    fmt.Println("Fix 3 for Example B")
    for e := 0; e < 3; e++ {
        go func(ee int) {
            // The value of e is copied into its own variable ee
            // (We could also call this new variable e)
            fmt.Println("ee is:", ee)
        }(e) // e becomes ee inside the function
    }

    time.Sleep(2 * time.Second)

}

That's it

Ok, that's it =) Hit me up on twitter (@oyvindsk) if you have any questions or corrections. All honest feedback is welcome. You can also enter your email underneath to get future articles.

A few places you can find Golang remote jobs

2016-04-15T00:00:00Z

Go is an open source programming language that makes it easy to build simple, reliable, and efficient software

--- golang.org

Go (or golang) is a simple, general purpose programming language that excels at writing things like backend services. It's the language used to make Docker, among many other things.

I'm currently using Golang almost exclusively and I'm looking for remote freelance jobs. I've therefor compiled this list for my own sake, but I guess it can be useful to others as well.

Websites specifically for Golang

We Love Golang

http://www.welovegolang.com/jobs/search?q=remote

This is probably the site with the most Go specific listings. Many jobs in Europe and the US. It seems like searching for "remote" is not entirely reliable, so double check the results before getting too excited about a job :). This site also has developer profiles, and you can get listed just by tweeting them.

Golangprojects.com

http://www.golangprojects.com/golang-remote-jobs.html

Also a good place to find Go-specific job listings. This site also have developer profiles, but registering here is more work since they require more information. Seems like most of the jobs are full time at the moment. Remote jobs can sometimes be US-specific.

Websites specifically for remote jobs

RemoteOK

https://remoteok.io/remote-golang-jobs

Great site with reposts jobs from other places. You can often click the "Apply for job" to get to the website with the original listing.

Remotely Awesome Jobs

https://www.remotelyawesomejobs.com/tags/golang?q=

Similar to the above, but fewer listings.

FlexJobs.com

https://www.flexjobs.com/search?search=golang&location=

Remote / telecommute jobs site.

Jobspresso

https://jobspresso.co/browsejobs/#s=1

There's a couple of listings here, try searching for "golang" or maybe "go".

Golang Forums etc

Gophers Slack channel

https://gophers.slack.com/messages/golang-jobs/

The Gophers Slack is quite active and has a separate "Jobs" channel.

The Golang forum

https://forum.golangbridge.org/c/jobs

The Golang-Jobs Google+ Community

https://plus.google.com/communities/116819843904802051830

Not super active, 2 postings in the four first months of 2016.

Hacker News Monthly Postings

http://hnhiring.me/

Hacker News has monthly "Ask HN: Who is hiring?" posts. This is an easy interface view and search this posts, you can filter on words etc. More geeky than most job listing sites =)

General job listing sites

Angel List

Startup jobs in the US and a few other places around the world. (No search function?)

Remote Jobs at Angel List: https://angel.co/job-collections/remote

Golang jobs at Angel List. Varies how much these emphasize Go. https://angel.co/golang/jobs

Stack Overflow Jobs

Remote jobs tagged with golang: http://stackoverflow.com/jobs?searchTerm=[golang]&allowsremote=true

Remote jobs containing the word "golang": https://stackoverflow.com/jobs?searchTerm=golang&allowsremote=true

Monster.com

I was supriesd to find a few hits for "golang" and "remote" on Monster.com: http://jobs.monster.com/search/?q=golang&where=remote

Others checked

Remotecoder

No Go jobs when I checked.

WeWorkRemotely

No Go jobs when I checked.

Working Nomads

No Go jobs when I checked.

Whf

Hard to know for sure, but I could not find any Go jobs when I checked.

Job listings at Artic Startup

Startups in the nordics. No Go jobs when I checked.

Toptal

"Exclusive" site for freelancers. Don't know if there's demand for Go programmers here, they don't list their openings. Last I checked (in 2014?) the onboarding process was very automated and not that great. You could not do it in Go, but maybe that has changed.

More remote jobs links at tryremote.com

A collection of the best resources for remote workers.

(Original gopher graphics by Renee French, modifications by unknown.)

How-to build Docker from source

2015-07-23T00:00:00Z

"Docker is an open-source project that automates the deployment of applications inside software containers".

Lately the Docker project has grown to include many different projects, but the core is still the docker server and client. The client and server is contained in the same binary and written in Go (golang). This is the binary we'll compile from source.

Docker is pretty easy to install from binaries. They release pre-compiled binaries, an install script and many linux distros have packages ready to install. So why would you want to build it from source? Well, I personally have two reasons: 1) I'm currently tinkering with Docker Plugins, a feature under development, and even the experimental build is lagging behind the latest developments. 2) Being able to modify the source and run the result can be very helpful when trying to understand how Docker works.

How

It turns out there are basically two ways of building docker from source: The hard way and the easy way. The hard way is to install all the dependencies and build everything from scratch. Although this is not that hard, docker has more dependencies than expected. The easy way is to use their build scripts to automate everything. This saves you all the trouble of finding and installing the right dependencies. The scripts builds and runs a docker image to compile the binary. So you need to have docker installed already to build docker in this way, which is the drawback.

Being lazy, I'm going to go with the easy way, but if you want to this the hard way (without using docker) this Dockerfile is a good starting point. From that you can extract all the dependencies and steps necessary.

The easy way is roughly:

Install docker
Get the docker source
Run the included scripts to create the docker image and compile everything
Test the binaries
Copy the binaries to wherever you want to have them.

Installing Docker

If you don't have docker already, install it. You can find instructions on docs.docker com

For ubuntu this is basically:

# as root (or prepend with sudo)
apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 
sh -c "echo deb https://get.docker.com/ubuntu docker main > /etc/apt/sources.list.d/docker.list"
apt-get update
apt-get install lxc-docker

# Get some dependencies
apt-get install make git

Aside: On Digital Ocean? Create some swap space

I've had some issues with compiling docker on the smallest Digital Ocean plan. I think it's because it runs out of ram and does not have any swap space to fall back to. You can fix this, I think, by creating and enabling some swap space:

# as root (or prepend with sudo)
dd if=/dev/zero of=/swapfile bs=1M count=1000
chmod 600 /swapfile 
mkswap /swapfile 
swapon /swapfile 
swapon -s

# Test that it worked:
free -h

Read more in this Digital Ocean tutorial and this AskUbuntu question. (If you're not using Digital Ocean but would like to be, you should use my affiliate link. Perks for you, perks for me :)

Get the docker source

This should be as easy as fetching the code from Github. Install git if you don't have it already and run:

git clone https://github.com/docker/docker.git
cd docker

Compile docker in a docker container

The Dockerfile and supporting scripts make it pretty easy to compile a new docker from source, they do all the heavy lifting for you. This works by first building a new docker image from the Dockerfile, running this image and compiling a new docker binary. Since it's building a new docker image, the docker server (docker -d) must be running. Hence the need for installing docker first. This docker image then has all the dependencies necessary to build docker from source. The docker binary is build inside this container and copied out afterwards. Ideally the included Makefile and scrips do all of this for us, and produce a binary ready to use:

# as root (or prepend with sudo)
make build 
# this takes a while and prints the output from "Docker build ." 
# It ends with: "Successfully built ..".

# as root (or prepend with sudo)
make binary

# This runs the image we created with "make build". 
# Ends with "Created binary: bundles/1.8.0-dev/binary/docker-1.8.0-dev",
# where "1.8.0-dev" is the version I'm building, 
# the next unreleased version at the time of writing.

Test the new binary

Stop the old docker daemon

Stop the docker daemon so w can run our new one. On Ubuntu / debian this is:

service docker stop

On other systems it might be.. something else. You can try killall docker or pkill docker

Start a daemon using our new binary

# in the docker/ directory where we ran make build and make binary
./bundles/1.8.0-dev/binary/docker -d  # the version, "1.8.0-dev", will vary according to the version your building

Run the old binary as a client and connect to our new daemon

With the docker server (docker -d) still running, open a new console / terminal and run: docker version. This will use the original docker as a client and it should be able to contact our new docker binary. You should see the difference in server version and client version, like so:

docker version

Client version: 1.6.0
Client API version: 1.18
Go version (client): go1.4.2
Git commit (client): 4749651
OS/Arch (client): linux/amd64
Server version: 1.8.0-dev
Server API version: 1.20
Go version (server): go1.4.2
Git commit (server): c2346f6
OS/Arch (server): linux/amd64

As you can see "Client version" and "Server version" are different. This is expected since the server is the new binary we just started as a daemon (./bundles...docker -d). The client, however, is the docker installed on the system. Run which docker to see where this binary is located.

Run the new binary as a client and connect to our new daemon

You can test the new binary as a client as well:

# in the docker/ directory where we ran make build and make binary
./bundles/1.8.0-dev/binary/docker version

Client:
 Version:      1.8.0-dev
 API version:  1.20
 Go version:   go1.4.2
 Git commit:   c2346f6
 Built:        Thu Jul 23 15:03:21 UTC 2015
 OS/Arch:      linux/amd64

Server:
 Version:      1.8.0-dev
 API version:  1.20
 Go version:   go1.4.2
 Git commit:   c2346f6
 Built:        Thu Jul 23 15:03:21 UTC 2015
 OS/Arch:      linux/amd64

As you can see the Client and Server version is now the same. Both the server and client is running the same binary file; the one we just built. Also, it looks like the output of docker version changed between version 1.6 and 1.8.

Last test: Run a docker container

A basic test that everything works is to run the official hello-world image using our new binary. Make sure the server is still running and run:

./bundles/1.8.0-dev/binary/docker run -t -i --rm hello-world

Installing our new binary system-wide

As far as I know, installing the new binary is as simple as copying it into place, overwriting the old one. (I'm sure there's cases where this is not enough, or could break things, so, you know.. )


# Where is our old binary?
which docker

# Mine is in /usr/bin/docker, so let's move it
# as root (or prepend with sudo)
mv /usr/bin/docker /usr/bin/docker-old 

# and copy our new binary in
cp ./bundles/1.8.0-dev/binary/docker /usr/bin/

# run the server with "docker -d" or :
service docker start

Questions? Comments? Found something wrong or confusing? Hit me up on twitter or hello @ this domain

A few (more than one and less than ten) reasons Redis is awesome!

2014-12-09T00:00:00Z

Redis describes itself as an:

"Open source, BSD licensed, advanced key-value cache and store. It is often referred to as a data structure server since keys can contain strings, hashes, lists, sets, sorted sets, bitmaps and hyperloglogs"

--- redis.io

This is not a Redis tutorial, just a rant. If you want to learn more, here's a few links:

The little Redis Book: A great free ebook. Somewhat outdated (ca 2012), but a good start:
- PDF
- Read online
Redis: Swiss army knife: Slides (2012)
Official documentation: redis.io/documentation

Small

When you download the latest version from the website, the sourcecode, tests, helper scripts etc. is 6.3 MB. The source itself is ~ 2 MB. The server binary is ~ 4 MB.

Simple

Compiling is as simple as one make. It takes less than a minute on my laptop, and I have never seen it fail (although I'm sure it can happen).

After compiling you get a bunch of redis-* files in your src/ folder. Run ./src/redis-server and it starts! Done!

There's a lot of config options to set, but adjust when needed, no need to worry about that when trying it out.

Versatile

Redis is often associated with caching, but that's just one of its many, many uses. People sometimes call it a "swiss army knife", and that's not a bad analogy. As a low-level tool, it's best seen as a one little program you can use to build a lot of cool stuff upon.

Even the basic datatypes become super useful when you have programs in written in different languages that want to work on the same data. Redis has clients for most languages and platforms. (seriously). And being fast, Redis actually fills the role of data migrator and interpreter nicely.

Redis supports different data types, each with a slew of uses:

Strings (basic key-value)
Hashes
Sets
Sorted Sets
Lists (Stacks, Queues)
Publish / Subscribe (Message queue)

See Redis commands for the full, scary list of commands, grouped by data type.

I'm way too lazy to try to summarize the different usecases, play around with them and you'll probably get some ideas. Or try google.

There's also this: Redis data types and abstractions (long but useful).

Fast

A single-server, single-process Redis server does approximately 50 000 - 100 000 operations a second. This means that you can do 50 Redis operations per page load, and still have 1000 concurrent users. Obviously this is not Facebook or Google scale, but it's more than enough for many, probably most, usecases. Scaling beyond this can be a little tricky, but there's examples of people making it work.

Useful

Each of the data types supported by Redis has its usecases. Combine this with the cross-platform nature and ease of use, and you get something really useful.

Redis Is The Most Important Tool In My Toolbelt (2012)

Honest

There's refreshingly little marketing-bs in the documentation and community. The documentation lists time complexity, in Big-O notation, for each command. And, AFAIK, nobody pretends Redis is going to replace everything else and make RDBMS's obsolete.

Øyvind Gerrard Skaar

Prototyping with NoCode and AI tools

Criteria

On the "to try out" list

Generalist, "all purpose" platforms

Specialized

Generative AI

Discared

How to use Google Cloud Storage with Golang

Digression: A short Google Cloud Platform rant

Cloud Storage with Go

Can you simulate Storage locally?

Which Go library should you use with Storage?

How do you authenticate to the "real" Storage when running locally?

Learn from my Go mistakes, Part 1: Closing over loop variables

Closing over a loop variable

Closures

Variable reuse

Goroutines runs out of order

Fixing it

Alternative 1

Alternative 2

Alternative 3

That's it

Links

Closures in Go

Other

A few places you can find Golang remote jobs

Websites specifically for Golang

We Love Golang

Golangprojects.com

Websites specifically for remote jobs

RemoteOK

Remotely Awesome Jobs

FlexJobs.com

Jobspresso

Golang Forums etc

Gophers Slack channel

The Golang forum

The Golang-Jobs Google+ Community

Hacker News Monthly Postings

General job listing sites

Angel List

Stack Overflow Jobs

Monster.com

Others checked

How-to build Docker from source

How

Installing Docker

Aside: On Digital Ocean? Create some swap space

Get the docker source

Compile docker in a docker container

Test the new binary

Stop the old docker daemon

Start a daemon using our new binary

Run the old binary as a client and connect to our new daemon

Run the new binary as a client and connect to our new daemon

Last test: Run a docker container

Installing our new binary system-wide

A few (more than one and less than ten) reasons Redis is awesome!

Small

Simple

Versatile

Fast

Useful

Honest