#pronelang — Public Fediverse posts

Update: I've fully figured out the repeatable pattern I want to use for object construction functions in #pronelang. Each object has at least the following four regular functions. Assume that the `...` are always the same consistent args which are sensible for type foo.

```
// Attempt to make a foo and return an error value (an enum where 0 = OK).
err_t mke_foo(foo_t *dest, ...);

// Run mke_foo, assert on the err_t, return the result.
foo_t mk_foo(...);

// Return a DV of a new foo, or an error atom on failure.
dv_t mkde_foo(...);

// Return a DV of a new foo. Asserts on error.
dv_t mkd_foo(...);

// Optional: compile-time construction logic.
#define MKD_FOO(...) /* impl */
#define MK_FOO(...) /* impl */
```

Unwrappy variants are given ergonomic priority since most callsites can be statically known (to human reviewers) to be infallible. I've implemented everything but the optional macros for atoms, and I'm using naive non-inline functions for now since I'm not in an optimization sprint.

Most of today needs to be downtime, but when I get back to work on #pronelang, for sure the very next thing I'm working on is moving all object construction to the `mk` module. It's already been a game changer just for the assign type. Huge quality of life improvement.

Most of today needs to be downtime, but when I get back to work on #pronelang, for sure the very next thing I'm working on is moving all object construction to the `mk` module. It's already been a game changer just for the assign type. Huge quality of life improvement.

Most of today needs to be downtime, but when I get back to work on #pronelang, for sure the very next thing I'm working on is moving all object construction to the `mk` module. It's already been a game changer just for the assign type. Huge quality of life improvement.

Most of today needs to be downtime, but when I get back to work on #pronelang, for sure the very next thing I'm working on is moving all object construction to the `mk` module. It's already been a game changer just for the assign type. Huge quality of life improvement.

PrismJS works alright on more conventional browsers, but it's still a slightly awkward fit. Doing syntax parsing and highlighting purely on the client side means fetching a fair amount of infrastructure to do so, which is disrespectful towards the bandwidth and CPU of the user, but also delays syntax highlighting when the JS isn't already in cache (and creates a pop of layout changes when we catch up).

The worst part is that I have to live with another project's constraints on language support - contributing upstream wouldn't be bad for getting x64 assembly highlighting, but a lot of what I use code blocks for is code in #pronelang, the language I'm prototyping, which is far from stable enough to contribute grammars upstream! That's been a thorn in my side the entire time.

Given that my site is built with a homemade SSG, there's no reason I *can't* precalc this and bake it into my page HTML. It's just going to be a difficulty cliff.

PrismJS works alright on more conventional browsers, but it's still a slightly awkward fit. Doing syntax parsing and highlighting purely on the client side means fetching a fair amount of infrastructure to do so, which is disrespectful towards the bandwidth and CPU of the user, but also delays syntax highlighting when the JS isn't already in cache (and creates a pop of layout changes when we catch up).

The worst part is that I have to live with another project's constraints on language support - contributing upstream wouldn't be bad for getting x64 assembly highlighting, but a lot of what I use code blocks for is code in #pronelang, the language I'm prototyping, which is far from stable enough to contribute grammars upstream! That's been a thorn in my side the entire time.

Given that my site is built with a homemade SSG, there's no reason I *can't* precalc this and bake it into my page HTML. It's just going to be a difficulty cliff.

PrismJS works alright on more conventional browsers, but it's still a slightly awkward fit. Doing syntax parsing and highlighting purely on the client side means fetching a fair amount of infrastructure to do so, which is disrespectful towards the bandwidth and CPU of the user, but also delays syntax highlighting when the JS isn't already in cache (and creates a pop of layout changes when we catch up).

The worst part is that I have to live with another project's constraints on language support - contributing upstream wouldn't be bad for getting x64 assembly highlighting, but a lot of what I use code blocks for is code in #pronelang, the language I'm prototyping, which is far from stable enough to contribute grammars upstream! That's been a thorn in my side the entire time.

Given that my site is built with a homemade SSG, there's no reason I *can't* precalc this and bake it into my page HTML. It's just going to be a difficulty cliff.

PrismJS works alright on more conventional browsers, but it's still a slightly awkward fit. Doing syntax parsing and highlighting purely on the client side means fetching a fair amount of infrastructure to do so, which is disrespectful towards the bandwidth and CPU of the user, but also delays syntax highlighting when the JS isn't already in cache (and creates a pop of layout changes when we catch up).

The worst part is that I have to live with another project's constraints on language support - contributing upstream wouldn't be bad for getting x64 assembly highlighting, but a lot of what I use code blocks for is code in #pronelang, the language I'm prototyping, which is far from stable enough to contribute grammars upstream! That's been a thorn in my side the entire time.

Given that my site is built with a homemade SSG, there's no reason I *can't* precalc this and bake it into my page HTML. It's just going to be a difficulty cliff.

Commits that make spawn the voice of Jesse Pinkman in my head, screaming "Yeah that's what you get! Bitch!" #pronelang

Commits that make spawn the voice of Jesse Pinkman in my head, screaming "Yeah that's what you get! Bitch!" #pronelang

Commits that make spawn the voice of Jesse Pinkman in my head, screaming "Yeah that's what you get! Bitch!" #pronelang

Commits that make spawn the voice of Jesse Pinkman in my head, screaming "Yeah that's what you get! Bitch!" #pronelang

Commits that make spawn the voice of Jesse Pinkman in my head, screaming "Yeah that's what you get! Bitch!" #pronelang

Upgraded one of my threads to a blog post with proper formatting!

https://maddiem4.cc/blog/fuller-stack/002e-the-slow-road

#prone #pronelang

Upgraded one of my threads to a blog post with proper formatting!

https://maddiem4.cc/blog/fuller-stack/002e-the-slow-road

#prone #pronelang

Upgraded one of my threads to a blog post with proper formatting!

https://maddiem4.cc/blog/fuller-stack/002e-the-slow-road

#prone #pronelang

Upgraded one of my threads to a blog post with proper formatting!

https://maddiem4.cc/blog/fuller-stack/002e-the-slow-road

#prone #pronelang

This thread might take awhile. I'm full in medical struggle. But I'm pretty proud of the work on #pronelang that I managed to squeeze in between the disruptions and chaos in my day, and I want to talk about it.

It doesn't look like a ton of progress. It's just one item on my TODO.md, really half of one (I did the other half yesterday). But it required a lot of side quests that will have long-term value beyond just unlocking the "eval" ability on `prn_assign_t` objects.

This thread might take awhile. I'm full in medical struggle. But I'm pretty proud of the work on #pronelang that I managed to squeeze in between the disruptions and chaos in my day, and I want to talk about it.

It doesn't look like a ton of progress. It's just one item on my TODO.md, really half of one (I did the other half yesterday). But it required a lot of side quests that will have long-term value beyond just unlocking the "eval" ability on `prn_assign_t` objects.

This thread might take awhile. I'm full in medical struggle. But I'm pretty proud of the work on #pronelang that I managed to squeeze in between the disruptions and chaos in my day, and I want to talk about it.

It doesn't look like a ton of progress. It's just one item on my TODO.md, really half of one (I did the other half yesterday). But it required a lot of side quests that will have long-term value beyond just unlocking the "eval" ability on `prn_assign_t` objects.

This thread might take awhile. I'm full in medical struggle. But I'm pretty proud of the work on #pronelang that I managed to squeeze in between the disruptions and chaos in my day, and I want to talk about it.

It doesn't look like a ton of progress. It's just one item on my TODO.md, really half of one (I did the other half yesterday). But it required a lot of side quests that will have long-term value beyond just unlocking the "eval" ability on `prn_assign_t` objects.

The #pronelang codebase is a pretty bad mess lately. Lots of inconsistent patterns where multiple approaches were tried. It's just that phase of the divergence/convergence cycle, and at this moment in particular, I'm forging out a lot of new patterns that can't be cheated off existing code in the repo, having to really think about architecture decisions.

An LLM wouldn't be slowly plodding along like I am, figuring out the right way to do things, because it would just pick something based on the wisdom of crowds. Notably, not second-guessing that wisdom based on project-specific aspirations, or the heterodox value judgments I've come to on software quality after 15 years observing and pondering what makes for good code.

It doesn't have to be now, but via a collective subconscious I mostly disagree with. It has to be mine, and my definition of right.

The #pronelang codebase is a pretty bad mess lately. Lots of inconsistent patterns where multiple approaches were tried. It's just that phase of the divergence/convergence cycle, and at this moment in particular, I'm forging out a lot of new patterns that can't be cheated off existing code in the repo, having to really think about architecture decisions.

An LLM wouldn't be slowly plodding along like I am, figuring out the right way to do things, because it would just pick something based on the wisdom of crowds. Notably, not second-guessing that wisdom based on project-specific aspirations, or the heterodox value judgments I've come to on software quality after 15 years observing and pondering what makes for good code.

It doesn't have to be now, but via a collective subconscious I mostly disagree with. It has to be mine, and my definition of right.

The #pronelang codebase is a pretty bad mess lately. Lots of inconsistent patterns where multiple approaches were tried. It's just that phase of the divergence/convergence cycle, and at this moment in particular, I'm forging out a lot of new patterns that can't be cheated off existing code in the repo, having to really think about architecture decisions.

An LLM wouldn't be slowly plodding along like I am, figuring out the right way to do things, because it would just pick something based on the wisdom of crowds. Notably, not second-guessing that wisdom based on project-specific aspirations, or the heterodox value judgments I've come to on software quality after 15 years observing and pondering what makes for good code.

It doesn't have to be now, but via a collective subconscious I mostly disagree with. It has to be mine, and my definition of right.

The #pronelang codebase is a pretty bad mess lately. Lots of inconsistent patterns where multiple approaches were tried. It's just that phase of the divergence/convergence cycle, and at this moment in particular, I'm forging out a lot of new patterns that can't be cheated off existing code in the repo, having to really think about architecture decisions.

An LLM wouldn't be slowly plodding along like I am, figuring out the right way to do things, because it would just pick something based on the wisdom of crowds. Notably, not second-guessing that wisdom based on project-specific aspirations, or the heterodox value judgments I've come to on software quality after 15 years observing and pondering what makes for good code.

It doesn't have to be now, but via a collective subconscious I mostly disagree with. It has to be mine, and my definition of right.

The #pronelang codebase is a pretty bad mess lately. Lots of inconsistent patterns where multiple approaches were tried. It's just that phase of the divergence/convergence cycle, and at this moment in particular, I'm forging out a lot of new patterns that can't be cheated off existing code in the repo, having to really think about architecture decisions.

An LLM wouldn't be slowly plodding along like I am, figuring out the right way to do things, because it would just pick something based on the wisdom of crowds. Notably, not second-guessing that wisdom based on project-specific aspirations, or the heterodox value judgments I've come to on software quality after 15 years observing and pondering what makes for good code.

It doesn't have to be now, but via a collective subconscious I mostly disagree with. It has to be mine, and my definition of right.

Working on adding a dedicated C type for assignments (`x = y`) in #pronelang has been an opportunity to pilot out the new `mk`/`mkd` tools, and even `alloc_t_assign`, and I gotta say, the new world is feeling great. Until about now, I was feeling a little uneasy about whether the verb-based modules were actually going to pay off, especially since I was paying some up-front R&D costs figuring out how stuff should work. But I'm now at the point where development is conspicuously fast and fluid, with no `assign.{c,h}` in sight.

I think it's gonna feel really good refactoring existing types to work the same way.

Working on adding a dedicated C type for assignments (`x = y`) in #pronelang has been an opportunity to pilot out the new `mk`/`mkd` tools, and even `alloc_t_assign`, and I gotta say, the new world is feeling great. Until about now, I was feeling a little uneasy about whether the verb-based modules were actually going to pay off, especially since I was paying some up-front R&D costs figuring out how stuff should work. But I'm now at the point where development is conspicuously fast and fluid, with no `assign.{c,h}` in sight.

I think it's gonna feel really good refactoring existing types to work the same way.

Working on adding a dedicated C type for assignments (`x = y`) in #pronelang has been an opportunity to pilot out the new `mk`/`mkd` tools, and even `alloc_t_assign`, and I gotta say, the new world is feeling great. Until about now, I was feeling a little uneasy about whether the verb-based modules were actually going to pay off, especially since I was paying some up-front R&D costs figuring out how stuff should work. But I'm now at the point where development is conspicuously fast and fluid, with no `assign.{c,h}` in sight.

I think it's gonna feel really good refactoring existing types to work the same way.

Working on adding a dedicated C type for assignments (`x = y`) in #pronelang has been an opportunity to pilot out the new `mk`/`mkd` tools, and even `alloc_t_assign`, and I gotta say, the new world is feeling great. Until about now, I was feeling a little uneasy about whether the verb-based modules were actually going to pay off, especially since I was paying some up-front R&D costs figuring out how stuff should work. But I'm now at the point where development is conspicuously fast and fluid, with no `assign.{c,h}` in sight.

I think it's gonna feel really good refactoring existing types to work the same way.

Gonna create the `prn_assign_t` type today at some point, but not right yet. #pronelang can wait. I have a Twilight Zone episode to watch with my beloved.

Gonna create the `prn_assign_t` type today at some point, but not right yet. #pronelang can wait. I have a Twilight Zone episode to watch with my beloved.

Gonna create the `prn_assign_t` type today at some point, but not right yet. #pronelang can wait. I have a Twilight Zone episode to watch with my beloved.

Gonna create the `prn_assign_t` type today at some point, but not right yet. #pronelang can wait. I have a Twilight Zone episode to watch with my beloved.

Then perish.

#pronelang

Then perish.

#pronelang

Then perish.

#pronelang

Then perish.

#pronelang

So, I'm pretty disabled right now, but the experimental plan to keep me from losing my mind is Work Wednesdays. I can probably handle consuming a decent dose of caffeine if I'm not doing it daily, and that way I'm not stalling out on projects that matter to me. I'm willing to be bedridden every Thursday if I can make some progress killing off legacy constructs in #pronelang .

So, I'm pretty disabled right now, but the experimental plan to keep me from losing my mind is Work Wednesdays. I can probably handle consuming a decent dose of caffeine if I'm not doing it daily, and that way I'm not stalling out on projects that matter to me. I'm willing to be bedridden every Thursday if I can make some progress killing off legacy constructs in #pronelang .

So, I'm pretty disabled right now, but the experimental plan to keep me from losing my mind is Work Wednesdays. I can probably handle consuming a decent dose of caffeine if I'm not doing it daily, and that way I'm not stalling out on projects that matter to me. I'm willing to be bedridden every Thursday if I can make some progress killing off legacy constructs in #pronelang .

So, I'm pretty disabled right now, but the experimental plan to keep me from losing my mind is Work Wednesdays. I can probably handle consuming a decent dose of caffeine if I'm not doing it daily, and that way I'm not stalling out on projects that matter to me. I'm willing to be bedridden every Thursday if I can make some progress killing off legacy constructs in #pronelang .

Partner's got the flu or something. I woke up from a migraine and still kinda feel like shit. And yet, I have a craving to work on #pronelang. Is that a bad idea? Almost certainly. But I'm a specific kind of bored, goshdangit.

Partner's got the flu or something. I woke up from a migraine and still kinda feel like shit. And yet, I have a craving to work on #pronelang. Is that a bad idea? Almost certainly. But I'm a specific kind of bored, goshdangit.

Partner's got the flu or something. I woke up from a migraine and still kinda feel like shit. And yet, I have a craving to work on #pronelang. Is that a bad idea? Almost certainly. But I'm a specific kind of bored, goshdangit.

Partner's got the flu or something. I woke up from a migraine and still kinda feel like shit. And yet, I have a craving to work on #pronelang. Is that a bad idea? Almost certainly. But I'm a specific kind of bored, goshdangit.

As a kind of a side note, while working on #pronelang, I realized that I really want certain language-significant atom names to be shorter in order to take advantage of 7-character-or-less optimizations. And those should probably match up with the visible, documented types of the language constructs.

So there's a couple kinds of value chaining the language is intended to support, really two. Immutable chaining, and mutable chaining. The thunk representation of an immutable chain is marked as `#CHAIN_IMM`. And I guess, if I'd got a bit further on features before my current refactoring, mutable chains would have been marked with `#CHAIN_MUT`. It's not the worst, but, egh.

What I eventually realized is that they don't both have to be called "chain." Mutable chaining uses the -> operator, and that kinda looks like a whip! So the immutable `:` ones can be chains, and the mutable ones, whips.

As a kind of a side note, while working on #pronelang, I realized that I really want certain language-significant atom names to be shorter in order to take advantage of 7-character-or-less optimizations. And those should probably match up with the visible, documented types of the language constructs.

So there's a couple kinds of value chaining the language is intended to support, really two. Immutable chaining, and mutable chaining. The thunk representation of an immutable chain is marked as `#CHAIN_IMM`. And I guess, if I'd got a bit further on features before my current refactoring, mutable chains would have been marked with `#CHAIN_MUT`. It's not the worst, but, egh.

What I eventually realized is that they don't both have to be called "chain." Mutable chaining uses the -> operator, and that kinda looks like a whip! So the immutable `:` ones can be chains, and the mutable ones, whips.

As a kind of a side note, while working on #pronelang, I realized that I really want certain language-significant atom names to be shorter in order to take advantage of 7-character-or-less optimizations. And those should probably match up with the visible, documented types of the language constructs.

So there's a couple kinds of value chaining the language is intended to support, really two. Immutable chaining, and mutable chaining. The thunk representation of an immutable chain is marked as `#CHAIN_IMM`. And I guess, if I'd got a bit further on features before my current refactoring, mutable chains would have been marked with `#CHAIN_MUT`. It's not the worst, but, egh.

What I eventually realized is that they don't both have to be called "chain." Mutable chaining uses the -> operator, and that kinda looks like a whip! So the immutable `:` ones can be chains, and the mutable ones, whips.