DB engine appears to be sqlite. It's in the tags on the main page and there's a file full of sql to create what looks like a sample db in the data/ dir.
It seems more along the lines of a "headless CMS", which is basically just extensible CRUD often with API endpoints; compare it to Strapi. This one looks finished enough to play around with at least.
Choosing to name variables with a single character has nothing to do with syntax. At most it could be considered idiomatic, but there's no reason to slavishly follow every idiomatic choice, just as there isn't in natural language.
I appreciate your write-up, it was well done. How long did you spend on this? I'd be most interested to know how long, not counting writing the blog post.
I'm NOT trying to show that Go is faster than async/await or anything similar. I'm showing that nested async/await calls are incredibly expensive compared to regular nested function calls.
You need to add to go keyword to change a normal function to a goroutine.
If you would remove async/await and Task/Return from the C# code example, it would perform pretty much the same as Go.
If you want to show that async/await calls are expensive, than you should have shown two code samples of C#, one with async/await, and one without.
Or could have done the same for Go, show one example with goroutines, and one without.
But I think everyone already know that async/await and goroutines has it's costs.
The problem is more that you are comparing Go without goroutines (without it's allocation costs) to a C# example with a poor implementation of async/await.
This isn't true. I have use cases that don't require cancellations or timeout. The tasks I'm running don't involve the network, they either succeed or error after an expensive calculation.
This is an interesting post. My understanding: Most of the use case for async code is I/O bound operations. So you fire off a bunch of async I/O requests and wait to be notified. Logically, I/O requests normally need a timeout and/or cancel feature.
However, you raise a different point:
The tasks I'm running don't involve the network, they either succeed or error after an expensive calculation.
This sounds like CPU-bound, not I/O-bound. (Please correct me if I misunderstand.) Can you please confirm if you are using Go or a different language? If Go, I guess it still makes sense, as green threads are preferred over system threads. If not Go, I would be nice to hear more about your specific scenario. HN is a great place to learn about different use cases for a technology.
I think I just responded too hastily. I am working in Go. There is file IO going on in addition to the calculation (which because of a NAS or whatever could also be network IO). As a practical matter I had never felt the need to offer cancellation or timeout for these use cases, but I probably should, so mea culpa.
What's the point of multiplexing tasks on a particular core if the tasks don't do any I/O? It will be strictly faster to execute the tasks serially across as many cores as possible then.
To me this is proof that doing a good visualization is really an art. I saw this on hn for a couple hours, but really didn't think much of it. As soon as I clicked through the funny names, and "continents" brought a smile to my face.
I guess my little project is too small to make it, but now I too aspire to join the great nation of Golandia.
Looks like it worked on you then. Good writing evokes feelings in its readers but as you've discovered, not all feelings feel good. Bad or good though, feelings make things stick. As you worship whichever deity you relate to (even if that deity is technology), you'll remember that passage for far longer than if that substitution literary device hadn't been used.
If it shook you up so much that you had to stop reading then it was quite successful.
reply