The thread about `volatile` is lost

[Curculigo]

I can't find it on the Discussions page even when searching in archived mode. The people who posted it have disappeared. It seems their account and all of its content have been deleted by GitHub, or perhaps was simply censored from public view.

I didn’t save the thread so I can’t remember the exact content. I only recall that you mentioned volatile in Adept is a hack and should be used with caution. I want to learn more about volatile, but no longer have the references.

[IsaacShelton]

Yeah his account must have been deleted or something. There used to be a guy around here who had his account deleted every few months but always came back with a new account, so was probably him.

It looks like you can see all of the old ones by not having any filters. https://github.com/AdeptLanguage/Adept/discussions?discussions_q=

I can't find the thread either, but you can see an example usage here: https://github.com/AdeptLanguage/Adept/blob/master/tests/e2e/src/volatile/main.adept

The way volatile works is that it's an attribute on a pointer, so *volatile int is the same *int, except that any reads/writes via the pointer are done as if the memory being pointed to is volatile (the compiler, optimizer, and cpu won't assume that the read/write is redundant). It's pretty niche and only really used when porting libraries from C or directly interacting with memory mapped IO. Sometimes it's also used for thread-related things on x86, but it's usually a bad idea to use it for threading.

Also yes as you mentioned, volatile should be used with caution and be avoided if possible (even outside of Adept). The only real situation it should be used in is when reading/writing memory mapped IO. Some people try to use it for threading, but it is architecture-specific and many people don't use it correctly and end up with data races.

func main {
    x int = 0
    x_pointer *volatile int = &x
    *x_pointer = 10 // This write is guaranteed to happen because we're using a volatile pointer.
                    // Otherwise, the compiler/optimizer/cpu is allowed to assume that this will never be seen and skip writing 10 to memory.
    *x_pointer = 20 // Same thing here technically too, since `x` is never read. But this write is also guaranteed to happen since we're using a volatile pointer.
}

[mjsshell]

Yeah his account must have been deleted or something. There used to be a guy around here who had his account deleted every few months but always came back with a new account, so was probably him.

It has always been me—just me and one or two others interested in this language. But the others couldn’t keep their interest for long. They all moved on to other languages, and so did I. By the way, most of the issues and discussions submitted to this repository and the AdeptImport repository are mine. There is a high chance that a thread submitted by “ghost” is actually mine.

In our last discussion, the account was not deleted by me. It was GitHub that flagged it and hid it from the public.

The reason is:

Hi. I'm @groggily. I'm not being banned by Github, nor I deleted my account.

I'm a Proton Mail user. Proton informed me about their @passinbox.com feature. I created an alias with @passinbox.com and replaced my Github account's email address with it. I don't know that Github silently censored me from the public after that.

Only me can see my contents.

BTW, I'm not junk-maker

Github doesn't like disposable email addresses. Try to add one into your account and it will be censored from the public immediately.

[mjsshell]

I learned C decades ago, but I still remember how to write C code. The syntax of C is simple and elegant—or maybe it’s just that I’ve grown older and can't learn new stuffs anymore. I first learned C in my youthful days. More recently, I learned the Adept language, and although I asked many silly questions, I became good enough at it to write wrappers for C libraries. Yet after only a year of not using it, I seem to have forgotten almost everything. Maybe the language itself is a big mess, or maybe it’s simply me getting old.

[mjsshell]

Currently, I’m learning JavaScript. It’s a bad language, but it still has fewer hiccups than Adept. I don’t know what Adept 3.x will look like, but perhaps it will be a trimmed-down clone of Rust (just like Adept 2.x is a weirded clone of Go). Given the roadmap, by the time Adept 3.x debuts, people will either be using Rust or will have already switched to the next shiny thing.

[IsaacShelton]

Yeah there are probably a lot of farmers who use burner emails.

I don't personally mind if people lose interest. Honestly I'm surprised a few people were and still are interested at all considering that this language is in maintenance mode and I've gone on to work on a successor that won't be ready for a few years.

Unfortunately I'm well aware that this language sucks, but people still use it for some reason. I think it's a little shallow to say "just a clone of Go", "just a clone of Rust" though. Borrowing (no pun intended) a feature or specific syntax doesn't instantly make a language a clone.

I'd rather go into hiding for a few years to create a good language than release one that's undercooked. We already have C, Go, Rust, etc. I don't want Go or Rust. The reason why I'm making Adept 3.x is because I want something that's better and that addresses the problems these languages don't have good answers for (such as async (okay well Go gets a pass on this one), C compatibility, arbitrary compile-time evaluation, macros / compile-time code generation with normal functions, etc.).

There will always be a shiny new thing. If a programming language doesn't do anything different, it will die quickly.

Language popularity is not something to worry about. Even if nobody uses Adept 3.x, I will be happy. As the language is designed for me (and I anticipate it will be good).