Hacker Newsnew | past | comments | ask | show | jobs | submit | typical182's commentslogin

There’s some more context in a proposal from the folks behind this project to upstream the needed Go runtime hooks into Go proper.

From what I can tell, the core Go team seems generally favorable to it, so seems like a decent chance it will happen.

From:

#73608 proposal: all: add bare metal support

https://github.com/golang/go/issues/73608

> Go applications built with GOOS=none would run on bare metal, without any underlying OS. All required support is provided by the Go runtime and external driver packages, also written in Go.

And:

> These hooks act as a "Rosetta Stone" for integration of a freestanding Go runtime within an arbitrary environment, whether bare metal or OS supported.


This would also benefit the Embedded Go project, which uses similar modifications to the runtime.

https://embeddedgo.github.io/


Draft 1.26 release notes:

https://tip.golang.org/doc/go1.26


The arena experiment was essentially placed on indefinite hold:

> The proposal to add arenas to the standard library is on indefinite hold due to concerns about API pollution.

I think the parent comment was using arenas as an example that GOEXPERIMENTs don't always move forward (like arenas), or can change while still GOEXPERIMENTs in a way that would normally not be allowed due to backward compatibility (like synctest).

The arena GOEXPERIMENT has not yet been dropped as of Go 1.25, but as I understand it, the plan is to remove arenas from the runtime when 'regions' are introduced, which have similar performance benefits but a much lower API impact:

https://github.com/golang/go/discussions/70257

As discussed there, seeing how people actually used the arena GOEXPERIMENT influenced the 'regions' design.


> The biggest problem is any string you pass as an argument to the fmt functions is moved onto the heap

FWIW, that's not quite correct. For example, a string literal passed as a fmt argument won't be moved to the heap.

The upcoming Go 1.25 release has some related improvements that help strings in more cases. See for example https://go.dev/cl/649079.


Yeah I just saw in the bug they're finally making progress on fixing this, exciting! I edited in the link if you didn't see.


Bluesky and atproto seem to be built to be hackable.

Someone in the community recently built a searchable directory of Bluesky "Starter Packs" (which are a way for a user to publish a set of interesting people & feeds to follow, primarily to help newcomers bootstrap their experience):

https://blueskydirectory.com/starter-packs/all

Dan Abramov posted about it earlier today, saying he liked it and:

"the fact that it can be done in the ecosystem is awesome. let the ecosystem cook" [1]

And maybe more poignantly:

"seeing random projects pop up in the atproto ecosystem reminds me just how much public web common were stifled by social companies closing down their APIs. an entire landscape of tools given up on and abandoned" [2]

[1] https://bsky.app/profile/danabra.mov/post/3lar3sdna222d

[2] https://bsky.app/profile/danabra.mov/post/3lar3xpuu4c2d


I was contemplating coming over, but this comment is the most convincing to me.

I think one of the fatal flaws tech companies have been making is locking things in. But what made the computer so great, what made the smartphone so great, was to make them hackable. You build environments, you build ecosystems. Lockin only slows you down. I mean how long would it have taken for smartphones to have a flashlight if it weren’t for apps? A stopwatch? These were apps before they were built into the operating systems.


Had to make an account to just echo this sentiment. I recently joined bluesky and holy hotdog as a developer it feels good that you can actually build stuff, data wrangling or whatever you might feel inspired to do.


Wasn't this also sort of a feature with Twitter? iirc the retweet and other now popular features were originally hacked together by users


The word "tweet" itself came from a 3rd party developer:

> The Iconfactory was developing a Twitter application in 2006 called "Twitterrific" and developer Craig Hockenberry began a search for a shorter way to refer to "Post a Twitter Update."

https://en.wikipedia.org/wiki/Tweet_(social_media)#History


Retweet was original using the text "RT". Hashtags were also invented by Twitter users.


Wasn't the @ also invented by users? I remember it was fascinating to watch this network self organize and create conventions of its own, that are now used everywhere.


Also hashtags. Though I think some of this stuff came from other social networks.


Seems to me like Jarkko Oikarinen or one of his crew invented hashtags, no? Denoting the context of your communication with something like #warez or #hack significantly predates web2.0.


Rather I think Twitter-style hashtags take inspiration from IRC channels in the format of #topic

Because channel names are not hashtags. The syntax is purely because IRC is a text-based protocol, so you need a special way to distinguish channel names from regular text.


# also has the advantage of being on a key on a T9 keypad while using twitter over SMS was in style.


That use— to define IRC channels— seems distinctly different than Twitter hashtags to tag individual posts. I wouldn’t be surprised if hash tags started as a nod to that, perhaps even jokingly, but I don’t think you could consider them a descendent.


I think reblogs as a technical feature were added first in 2009 by Tumblr and slightly later adopted by Twitter - not that it matters in this context.


Hashtags were invented. It's a convention that happened to work well with Twitter's search engine.


Yep, we intentionally built it to be hackable! We believe that social media will improve when people are free to build on it, change it, fork it, and remix it. Bluesky and the atproto ecosystem can evolve as fast as users and developers want them to.


Starterpacks are great, what about seeing what is current top engaging accounts ? https://www.graphtracks.com


That's the best looking Bsky tool that I've seen so far. Nice!


Another argument is that it could lead to a bot problem 10x worse than twitters ever was.


The Twitter bot situation only seems to have got worse since they shut down free API access. LLM engagement farming bots everywhere in replies, hordes of scam bots replying if you use certain keywords, porn bots following and DMing everyone non-stop...

Evidently the people running the bots don't really care whether or not you give them an API to work with.



Presumably the bots weren't using the "proper" APIs even when they existed, so as to be less easily detectable.


I think that coincided with them removing phone number verification for accounts. Probably due to my browser looking unusual (content blocker, linux user-agent string, other addons) any time I set up a new account and used it for a few minutes a few years ago, it'd lock the account and redirect every logged in page to one demanding SMS verification to unlock the account.

I would usually get support to manually unlock it after a few days by emailing them and mentioning why I didn't want to give them a phone number. Now the process only involves solving captchas. (and maybe some hidden waiting)


Check out bluesky's "labeling services", I think it will be a very simple matter to crowdsource lists of obvious bots and prevent their having any reach. You can create bots that make as many posts as you want, but bots aren't entitled to being included in any feed. It comes down to the posts that the relay choose to aggregate, and what the appview chooses to display according to user preferences.


One of the nice things that make Bluesky different is that there isn't really a single central algorithm that everyone is forced to use. This combined with the many novel moderations tools like feeds and labellers mean it's pretty trivial to filter out entire categories of spam/botting.

As an example my feed is completely free of US politics, allowing me to curate an experience where I can go to enjoy myself instead of constantly being exposed to ragebait.


They have shareable block lists - like starter packs, but for blocking accounts. We'll see how that works out as the network grows.


I'm not sure you could be worse than Twitter right now on bots unless you are pursposely trying to be worse.


Computers that are operated by humans that are using APIs designed for computers is not a bug, but a feature.


Well yeah that's why you can expect it to increase 10x


> you can simply forbid pointers into the stack. This means that your GC doesn't need to be moving. I believe that's what Go does

I might have misunderstood your comment, but FWIW, Go does allow pointers into the stack from the stack.

When resizing/moving/copying a stack, the Go runtime does indeed find those pointers (via a stack map) and adjust them to point to the new stack locations. For example:

https://github.com/golang/go/blob/b25f5558c69140deb652337afa...

(The growable stacks I think replaced the segmented stacks circa Go 1.3 or so; I can't speak to whether they were contemplating growable stacks in the early days whilst considering whether to start their project with the Plan 9 toolchain, LLVM, or GCC, but to your broader point, they were likely considering multiple factors, including how quickly they could adapt the Plan 9 toolchain).


The “Personal” in PDS doesn’t mean it is only for self-hosting.

Bluesky has a main PDS instance at https://bsky.social that serves almost all of the Bluesky user base.

There is a good overview of the architecture here:

https://blueskyweb.xyz/blog/5-5-2023-federation-architecture

Here’s a snippet from the protocol roadmap they published 3-4 weeks ago [1]:

Multiple PDS instances

The Bluesky PDS (bsky.social) is currently a monolithic PostgreSQL database with over a million hosted repositories. We will be splitting accounts across multiple instances, using the protocol itself to help with scaling.

[1] https://atproto.com/blog/2023-protocol-roadmap


If I understand the question, I think that is rsc.io/unix/v6unix, which is at https://github.com/rsc/unix/tree/main/v6unix:

  "Research Unix Sixth Edition (v6) kernel written in Go and using rsc.io/unix/pdp11 to run user-mode code"
For example, you can see the process struct definition starting here:

https://github.com/rsc/unix/blob/main/v6unix/proc.go#L25-L67


I was trying to figure out whether I can run golang on that unix environment.


Effectively yes.

A fix for the loop variable closure problem is now in the official proposal process, which is how language changes happen in Go.

It’s a concrete proposal from the core Go team and seems to be on track for acceptance:

https://github.com/golang/go/issues/60078

An implementation is already available on tip and in the upcoming Go 1.21 release behind a GOEXPERIMENT flag.

The community reaction has been extremely positive. As one approximate measure, an earlier draft of the proposal had 671 upvotes and with 0 downvotes:

https://github.com/golang/go/discussions/56010


People should essentially never set GOROOT. It's mostly a holdover. For example, Ian Lance Taylor on the core Go team wrote [0] somewhat recently:

"It's a special purpose hook that is almost never needed".

[0] https://groups.google.com/g/golang-nuts/c/qDhJbkE1QeY/m/JoV2...


Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: