Well, this works as long as you're using a separate goroutine and the Go runtime creates more than one thread, right? My claim is that a Go runtime that only creates one thread (which is effectively what Joy is) will not work the way you expect in this case.
Or, more specifically, that if you have N goroutines that consist of infinite loops of pure computation (or really, anything that doesn't involve receiving from a channel), and at least one other goroutine that's receiving from a channel, your runtime needs to generate at least N+1 OS threads or your last goroutine will never get scheduled.
https://github.com/golang/go/issues/11462 seems to be saying the same thing (by setting GOMAXPROCS to 1).
In Show HN: Joy – a Go to JavaScript compilergolang
go
Go2014–2026
golang / go
go
The Go programming language
1,181Distinct people
1,944Mentions
14Explicit recommenders
139.9KGitHub stars
What to know before exploring
What it is
The Go programming language
GitHub
Where it is used
No documented product use was verified in the last source check.
What people are saying
> To convert the Stream.Reader to an std.Io.Reader, we need to call its interface() method. To get a std.io.Writer from an Stream.Writer, we need the address of its &interface…
j1elo used a recommendation phrase. 14 indexed comments match. This is a phrase match, not a verdict.
No classified warning is attached to this page. Read the discussions before treating silence as approval.
Also in these discussions
- golang/proposal · linked in 12 of the same discussions
- rust-lang/rust · linked in 8 of the same discussions
- nodejs/node · linked in 5 of the same discussions
Mentioned in the same Hacker News threads. That is not proof they are substitutes.
This week on Hacker News
Nov 8–Nov 15 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/15/2026, 11:34:28 AM UTC.
No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.
Mentions over time
HN mentions by year1,944 dated mentions
Observed mentions: 2014-12-08 08:41:45 UTC to 2026-10-22 10:17:39 UTC.
* An incomplete calendar period is marked with an outlined bar. Its count is not directly comparable with a full period.
Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.
View mention counts and date ranges
| Period | Start (UTC) | End (exclusive, UTC) | Mentions | Submissions | Comments |
|---|---|---|---|---|---|
| 2014 | 2014-01-01 00:00:00 UTC | 2015-01-01 00:00:00 UTC | 16 | 1 | 15 |
| 2015 | 2015-01-01 00:00:00 UTC | 2016-01-01 00:00:00 UTC | 80 | 17 | 63 |
| 2016 | 2016-01-01 00:00:00 UTC | 2017-01-01 00:00:00 UTC | 135 | 18 | 117 |
| 2017 | 2017-01-01 00:00:00 UTC | 2018-01-01 00:00:00 UTC | 164 | 20 | 144 |
| 2018 | 2018-01-01 00:00:00 UTC | 2019-01-01 00:00:00 UTC | 174 | 26 | 148 |
| 2019 | 2019-01-01 00:00:00 UTC | 2020-01-01 00:00:00 UTC | 196 | 30 | 166 |
| 2020 | 2020-01-01 00:00:00 UTC | 2021-01-01 00:00:00 UTC | 159 | 21 | 138 |
| 2021 | 2021-01-01 00:00:00 UTC | 2022-01-01 00:00:00 UTC | 184 | 34 | 150 |
| 2022 | 2022-01-01 00:00:00 UTC | 2023-01-01 00:00:00 UTC | 220 | 45 | 175 |
| 2023 | 2023-01-01 00:00:00 UTC | 2024-01-01 00:00:00 UTC | 221 | 27 | 194 |
| 2024 | 2024-01-01 00:00:00 UTC | 2025-01-01 00:00:00 UTC | 163 | 13 | 150 |
| 2025 | 2025-01-01 00:00:00 UTC | 2026-01-01 00:00:00 UTC | 167 | 24 | 143 |
| 2026 (partial) | 2026-01-01 00:00:00 UTC | 2027-01-01 00:00:00 UTC | 65 | 15 | 50 |
From the project README
An excerpt from the repository, fetched Nov 12, 2026.
Read the project’s introduction
The Go Programming Language
Go is an open source programming language that makes it easy to build simple,
reliable, and efficient software.
Gopher image by Renee French, licensed under Creative Commons 4.0 Attribution license.
Our canonical Git repository is located at https://go.googlesource.com/go.
There is a mirror of the repository at https://github.com/golang/go.
Unless otherwise noted, the Go source files are distributed under the
BSD-style license found in the LICENSE file.
Download and Install
Binary Distributions
Official binary distributions are available at https://go.dev/dl/.
After downloading a binary release, visit https://go.dev/doc/install
for installation instructions.
Install From Source
If a binary distribution is not available for your combination of
operating system and architecture, visit
https://go.dev/doc/install/source
for source installation instructions.
Contributing
Go is the work of thousands of contributors. We appreciate your help!
To contribute, please read the contribution guidelines at https://go.dev/doc/contribute.
Note that the Go project uses the issue tracker for bug reports and
proposals only. See https://go.dev/wiki/Questions for a list of
places to ask questions about the Go language.
Read the full README on GitHubWhat Hacker News says
164 sourcesAdding generics is being considered and might be happening.
In the meantime you could write an Experience report[0]?
[0]https://github.com/golang/go/wiki/ExperienceReports
In Go 1.10 Beta 1 is releasedLooks like it was because an internal structure in the runtime had a fixed size, but that has changed: https://stackoverflow.com/questions/40943065/golang-why-runt...
https://github.com/golang/go/commit/ee55000f6c45d2f5c38d9167...
https://github.com/golang/go/issues/15131
In Go 1.10 Beta 1 is releasedI don't agree, but if you think so, you can try making go2 better via https://github.com/golang/go/wiki/ExperienceReports
In Error handling in UpspinIn a memory constrained environment, we recently noticed the throughput/latency tradeoff being made by the GC, but having to say that this behavior was not obvious in the first place and we had to dive into the source code to understand things better (which is a good benefit of go being open source, as already stated in the article).
The bottom line is that the scavenger will allow the OS to claim free memory only at least 5 minutes after it was GC'ed. For us the solution was to "force" releasing the free memory to the OS [1], and even since then things have been much smoother in the context of our particular app.
On this topic, there's an open issue [2] to look at making the scavenger more prompt and aggressive.
[1] https://medium.com/samsara-engineering/running-go-on-low-mem...
[2] https://github.com/golang/go/issues/16930
In Why I love GoError handling is what happen after you discover there was an error.
In Go, "checking" for errors may be skipped (and people make mistake, even True Programmers), in which case they are handled just as if they were ignored.
Even if the error can be ignored for fmt.Println, it is not clear from the example whether it was even taken into account or not. The following could be required:
_ := fmt.Println("hello world")
That means that the function call can return an error, and thus you have to use the return value, but the programmer decided to ignore it. Contrast it with:
fmt.Println("hello world")
Did the programmer know there was possibly an error? What happens if there is an error (not specifically for this example, but in general), and you don't check for it? then it is ignored.
In another language, the same line could be the s
Read the rest
ource of an error; but only error handling depends on the programmer, not error checking. Moreover, the default handling strategy is to abort execution. Actually ignoring errors requires more work.
And errcheck is apparently no silver bullet: https://github.com/golang/go/issues/20148
I too wish there was more standard containers available in Go's standard library. However, I don't think there will be a collections package unless and until generics make it into the language. That said, there are some pretty good libraries out there:
- https://github.com/timtadh/data-structures ## I wrote this one.
- https://github.com/Workiva/go-datastructures ## this one is also popular.
- https://github.com/golang/go/wiki/Projects#data-structures ## big list here.
In Why I love GoSo there is android-go[0], which is a Goland thing; and Go Mobile[1], which is a Golang thing; and now there is also the other Android Go[2], which has nothing to do with the Go programming language.
Right?
[0]: https://github.com/xlab/android-go
[1]: https://github.com/golang/go/wiki/Mobile
[2]: https://www.android.com/versions/oreo-8-0/go-edition/
In Android 8.1 OreoDon't forget about this one, similar but affects BSD and still open:
https://github.com/golang/go/issues/15658
In Debugging an evil Go runtime bugThe investigation in the linked Go issue [1] is also impressive.
[1] https://github.com/golang/go/issues/20427
In Debugging an evil Go runtime bugYeah, it mostly happens when you have a server which runs an abnormally large task or payload, causes the heap to grow, and does it in a way that Go can't release the memory back to the OS due to heap fragmentation.
I haven't looked at this for a while but I believe it's still an issue.
https://github.com/cockroachdb/cockroach/issues/2007
https://github.com/golang/go/issues/18896
https://github.com/golang/go/issues/14045
In Erlang Garbage CollectorExponentiation incorrect in Go
2 points · Open discussionIn net/http, if a handler panics you don't want it to bring down your entire application. For more info, see https://golang.org/pkg/net/http/#Handler
The encoding/json package is interesting because it uses both panic() and recover() internally in a way more reminiscent to how exceptions are used in other languages (that is, for control flow).
For example, https://github.com/golang/go/blob/2596a0c075aeddec571cd658f7... panics, and https://github.com/golang/go/blob/2596a0c075aeddec571cd658f7... recovers it.
Both uses are quite uncommon, though.
In Understanding Go panic outputCan you give an example of this? Most of the compilers I've seen have excellent code bases, with good separation between the different components, probably because compilers are so well-studied. It can be surprising what the most productive part of the compiler is to optimize. Often the lexer is heavily optimized due to its outsized impact on performance, but even then, the code looks idiomatic to me.
- Scanner.Scan() https://github.com/golang/go/blob/master/src/go/scanner/scan...
- scan() https://github.com/Microsoft/TypeScript/blob/master/src/comp...
- Lexer::LexTokenInternal() https://github.com/llvm-mirror/clang/blob/master/lib/Lex/Lex...
All three examples are heavily optimized and hand-written but they’re still clear and easy to follow.
In Ask HN: Which TypeScript codebase should I study to get better?Showing the 15 most recent of 164 sources. Enable JavaScript to search and browse every indexed mention.