weiwenhao

I'm currently using Nature to replace Tauri for developing desktop applications, which will allow me to conduct more thorough testing later. Since the linker succeeded in linking, it indicates that all symbols were successfully located. Both libruntime and libuv are highly complex code systems. The fact that the scheduler and coroutine system are already running successfully confirms that all core functions are functioning properly.

Nature's runtime architecture draws heavily from Go, with its GC similarly referencing Go's allocator and collector approaches. However, the use of mark-and-sweep GC inevitably leads to memory fragmentation issues. Virtual memory usage tends to advance progressively. In contrast, the span-based memory allocator avoids significant fragmentation problems during frequent memory releases and allocations.

---

I also believe predictable memory management is crucial. An arena-based supplementary memory allocator could be the next key feature.

I am a core developer of the nature programming language, welcome to talk to me!

For package management software that is rarely used, free is the biggest motivation.

Very nice, my nature-lang references the old ruby design, now maybe I can reference the new one.

I did something similar. Similar in every way. https://github.com/nature-lang/nature

A new programming language inspired by golang. I'm trying to share and promote it.

https://github.com/nature-lang/nature

So far it does, just inspired by golang, which doesn't support FFI and calling golang related code is not an easy task.

But the situation will improve soon, in order to make nature more useful, I've decided to translate nature into readable golang code and parse the golang code to utilize the golang code.

Your write-up is so detailed that I even feel like I could implement a complete golang scheduler myself

Does llm really understand the code at this stage?

I don't mean to promote it because the nature programming language version 0.5 is not ready yet, but the nature programming language https://github.com/nature-lang/nature basically meets your expectations, except for the use of var to declare variables, probably because I also really like simplicity.

Here's an example of how I use the nature and raylib bindings.

https://github.com/weiwenhao/tetris

tab completed is a nightmare when it comes to non-expected code.

zig ld should be the only cross-linker out there, and I'm considering migrating to zig, for zig ld's sake .

All programming languages that claim to be alternatives to C eventually become themselves, zig is good enough and different enough to not care about being an alternative to C!

The static compilation of musl libc is a huge help for alpine linux and many system programming languages. My programming language https://github.com/nature-lang/nature is also built on musl libc.

The primary channel for communication right now is https://github.com/nature-lang/nature , where you can engage and keep up-to-date through issues, discussions, and watching the repository.

Additionally, this is my first time hearing about the Mastodon platform, it looks really cool.

I'm not entirely sure if Hacker News scoring system includes a boost for comments, but it seems that controversy and criticism are not necessarily bad things. They may actually help keep the post on the front page for a longer period of time.

I apologize for not being clear in my previous statements. As of now, Nature does not even have a version that is community-ready. In my opinion, talking about various ideas and innovations is meaningless and deceptive if the programming language itself cannot be used by the community.

Additionally, my design philosophy is also included in the GitHub README.

This is the first-phase goal for the Nature programming language, as outlined in the first section of the README on https://github.com/nature-lang/nature. To summarize:

- Type system, null safety, generics, and union types

- An in-house compiler/assembler/linker that is not reliant on LLVM and supports compilation for amd64, riscv64, and wasm architectures

- Non-intrusive interaction with C for efficient and high-performance development

- Progressive Garbage Collection, supporting both automatic and manual GC

- Built-in vec, map, set, and tup data structures

- Package and module management

- Function tags, closures, error prompts, runtime stack traces, and coroutines

- Integrated SSA, linear scan register allocation, reflection, and an assembler & linker

We anticipate that these key features will be completed around version 0.7.0, at which point a community-ready version will be released. By "community-ready," we mean that there will be stable and backward-compatible syntactic API support.

https://nature-lang.org/docs/prologue/release-notes Record the core features that have not yet been completed in the version release notes.

After the MVP (Minimum Viable Product) version of Nature is released, I plan to use it for game engine and game development. But that's probably not the answer you were looking for.

I have experience with many programming languages like PHP, Python, Golang, JS, C, Scheme, etc. Each of these languages has its shortcomings that bother me. Taking C as an example, it lacks package management and doesn't support generics. In contrast, Nature is designed to improve upon C by featuring generics, package management, and null safety, among other things.

Moreover, what drives me is simply the joy of the process.

You were right

Thank you for the reminder. It appears I wasn't as prepared as I should have been. I will pay closer attention to details in the next version release.

Thank you for the heads-up! I'll be more careful with the details in the future. I am sorry about that, because all the current English documentation has been translated by GPT-4. It seems I wasn't fully prepared, but I'm still thrilled that someone shared the Nature project on Hacker News.

When I aim to create a piece of software, I not only want the users to be happy but also the people who build the software to find joy in the process. Using LLVM is a good choice, but creating your own compiler backend is definitely more interesting.

As mentioned in the design philosophy of the repository, the goals are to be intuitive, more convenient, and to have a lower learning curve, among other things. Programmers are always the first-class citizens.

I believe the pleasure you derive from a language largely depends on what you use it for. What a language can truly offer is increased convenience and efficiency.

Thank you for pointing out the bug in the website description; I have now updated it.