This is my first post to this Rust community and I am happy to introduce myself and discuss what I love about this language, but first a little about myself.

I'm Alice, Fluffy to most, and she/her are my pronouns. I'm from the UK. I got a little boy who love like crazy. I'm Autistic, suffer from cPTSD and I also 🩷 Rust!!

Rust I feel appeals to Autistic people because of it's focus on accuracy and correctness. It's a common feeling people have about the language. But as the type of person I am I love it.

I began learning it in 2023, before this I was using C++. Rust showed me the importance of error's as values and helped improve the quality of my code.

Currently I'm writing a game-engine as a hobby. The game-engine is a work in progress (WIP) and I have only just begun it's development. Since the game-engine will natively support various platforms. To ensure consistency I'm writing all the platform specific code manually and building my own custom standard library for my engine, loosely based on the actual Rust standard library.

Right now I have the code in place to create/remove directories and to create, delete, write, read and set file pointer location. Convert UTF8 to UTF16 and output to the console in Unicode (Windows C API uses UTF16) and heap functions to get the process heap and create and delete memory dynamically.

Next will be the 'config.json' for which Serde will be used. Then the logger, and so on.

So it is a WIP but it's fun and given my conditions allows me to do what I love, writing Rust code.

Thanks for reading!!

Alice 🏳️‍⚧️

you are viewing a single comment's thread
view the rest of the comments

[–] taladar@sh.itjust.works 16 points 4 months ago (3 children)

Next will be the ‘config.json’ for which Serde will be used.

Have you considered TOML instead? For files that need to be edited and read by humans it tends to be better than JSON due to the easier ability to split it over lines and add comments in between.

[–] ex_06@slrpnk.net 3 points 4 months ago (1 children)

I’ll never understand how the rust community loves TOML (like me) but also loves Rust syntax (totally not like me)

I feel like they are opposite: rust syntax is full of symbols, toml is super minimal and square parentheses are just less “noisy” than curly ones…

[–] robinm@fosstodon.org 0 points 4 months ago (1 children)

@ex_06 @taladar Personnally it's not that I like the syntax, it's that I love the semantic.

[–] ex_06@slrpnk.net 1 points 4 months ago (1 children)

Are you talking about rust or toml? Because if rust, just out of curiosity, would you still like it with keywords instead of symbols?

[–] sugar_in_your_tea@sh.itjust.works 2 points 4 months ago (1 children)

Rust has very few symbols, especially compared to pre-1.0 when they had ~ (box?) and @ (GC?).

Symbols in modern Rust are pretty reasonable IMO, but maybe that's just stockholm syndrome.

[–] robinm@fosstodon.org 0 points 4 months ago (1 children)

@sugar_in_your_tea @ex_06

- && and || instead of and and or
- :: instead of the simpler .

Just those two changes would help significatly reduce the awkwarness. Even turbofish would be slightly less noizy.

[–] sugar_in_your_tea@sh.itjust.works 1 points 4 months ago* (last edited 4 months ago)

Idk, && and || are pretty universally common, so I highly doubt they trip anyone up.

:: is a little odd, but at least it's limited to imports. Having it be . makes it a little ambiguous when you see x.y as to whether x is a module or an instance. But it's absolutely fine in other languages, so that's not a hill I'm willing to die on.

The turbofish is disgusting though. I prefer D's template syntax: Type!A or Type!(A, B), though this conflicts with macros. If we have macros all use the same symbol (e.g. println#(...) instead of println!(...)), then we could use the ! instead of the turbofish. But that ship has sailed and it's not clear if my bike shed is a better color.

[–] fluffy_hub@programming.dev 1 points 3 months ago

I have considered it in the past but JSON feels like the standard. But TOML could be an option. I might try to see which I like better

[–] FizzyOrange@programming.dev -4 points 4 months ago (3 children)

TOML is a terrible format. It is anything but obvious, especially when you have more than one level of nesting.

It is pretty annoying that there isn't an obvious format that Serde supports to use though:

YAML is an awful format (worse than TOML in many ways). serde-yaml is abandoned anyway.
serde_json is great but dtonlay refuses to support comments/trailing commas
serde_json5 is an option but JSON5 doesn't have good IDE support.

I would probably go with either RON or one of the forks of serde_json that adds support for comments. I think there's serde_jsonc and serde_jsonc2 maybe.

[–] Flipper@feddit.org 5 points 4 months ago (1 children)

JSON doesn't have comments according to the spec. So he is right. Same with trailing commas.

[–] FizzyOrange@programming.dev 3 points 4 months ago

Right but JSONC does support them. We just want support for JSONC as well as JSON.

[–] RustySharp@programming.dev 3 points 4 months ago

JSON5 is seriously what I feel JSON should've been. Comments, trailing commas, hex numbers, etc.

[–] sugar_in_your_tea@sh.itjust.works 2 points 4 months ago (1 children)

TOML... nesting

If you're doing a lot of nesting in your config, you should rethink your config. Config should be pretty flat.

If you're putting data in TOML, you're doing it wrong. If your config needs to include data, IMO it should just reference the data in a separate file that uses a proper data format (e.g. JSON).

TOML rocks precisely because it nudges you into making simpler configs. Nesting is inherently hard to read (see endless debates over indentation standards), and TOML sidesteps the whole problem elegantly, forcing you to think about whether you actually need it. In most cases you don't, and when you do, it's possible and not unreasonable.

[–] FizzyOrange@programming.dev 4 points 4 months ago (1 children)

Config should be pretty flat.

Why? I don't see any reason for that.

TOML rocks precisely because it nudges you into making simpler configs.

This is just "you're holding it wrong".

In most cases you don’t, and when you do, it’s possible and not unreasonable.

Really. Here's the first Gitlab CI example I could find:

lintDebug:
  interruptible: true
  stage: build
  script:
    - ./gradlew -Pci --console=plain :app:lintDebug -PbuildDir=lint
  artifacts:
    paths:
      - app/lint/reports/lint-results-debug.html
    expose_as: "lint-report"
    when: always

Let's see the TOML:

[lintDebug]
interruptible = true
stage = "build"
script = [
  "./gradlew -Pci --console=plain :app:lintDebug -PbuildDir=lint"
]

  [lintDebug.artifacts]
  paths = [ "app/lint/reports/lint-results-debug.html" ]
  expose_as = "lint-report"
  when = "always"

Gross. The tool I used to convert even added extra indentation because otherwise it is unclear.

IMO JSON5 is the best:

{
  lintDebug: {
    interruptible: true,
    stage: 'build',
    script: [
      './gradlew -Pci --console=plain :app:lintDebug -PbuildDir=lint',
    ],
    artifacts: {
      paths: [
        'app/lint/reports/lint-results-debug.html',
      ],
      expose_as: 'lint-report',
      when: 'always',
    },
  },
}

This is much clearer than TOML and less ambiguous than YAML. It could do without the outer {}, but overall it's still better.

[–] sugar_in_your_tea@sh.itjust.works 2 points 4 months ago* (last edited 4 months ago)

Gross

The only gross thing I see is your indentation. I find the TOML to be more readable honestly.

In a config format, you want to group top level fields together, and it enforces that. Your example could be like this instead:

lintDebug:
  stage: build
  script:
    - ./gradlew -Pci --console=plain :app:lintDebug -PbuildDir=lint
  artifacts:
    paths:
      - app/lint/reports/lint-results-debug.html
    expose_as: "lint-report"
    when: always
  interruptible: true

It's easy to tack stuff on like that, and it's also easy to miss when quickly scanning, especially if you're using 2-space indenting.

The TOML would be the same in either case, because it forces related fields to be grouped separately from child groups.

The main thing I don't like about TOML is yellow table groups:

[[thing]] 

[[thing]]

I rarely see it in the wild though.

IMO JSON5 is the best:

It's trying to do two things at once, and ends up doing neither very well. The extra curly braces are there because it's trying to be a data format, and it's bad as a data format because it's not universal. We've standardized on JSON as a community for data, and that's unlikely to change, so we shouldn't try to "fix" it just for configs. IMO, either use JSON or a config-specific format.

I agree that YAML is plain awful. It shouldn't exist.

XML is awful for anything outside of markup, and even then I think we can do better. I'm partial to Lua tables:

    {x=10, y=45, "one", "two", "three"}

A typical HTML drop down menu {pulled from MDN):

<select name="pets" id="pet-select">
  <option value="">--Please choose an option--</option>
  <option value="hamster">Hamster</option>
  <option value="parrot">Parrot</option>
</select>

Could be like this in a Lua table:

{
  node="select", 
  name="pets", 
  id="pet-select", 
  {value="", "--Please choose an option--"}, 
  {value="hamster", "Hamster"}, 
  {value="parrot", "Pattot"}, 
}

Or maybe something a little different with the node type outside:

select{
  name="pets", 
  id="pet-select", 
  option{value="", "--Please choose an option--"}, 
  option{value="hamster", "Hamster"}, 
  option{value="parrot", "Parrot"}, 
}

I think QT Quick uses something like that, but it's been years since I played with it.