nvlled

Why should it be the router? A saner option is to let the parent component coordinate the data fetches for the child components. What you are suggesting is way out of the normal responsibility of a router.

"Who sold you on that lie? Hardware is anything but complex. Literally guys without any kind of degree could do it, just buy a breadboard and some arduino-pi or whatnot."

That's you, that's what you sound like.

Playing with this outlandish thought further, the idea that earth is an enclosure for research or preservation explains why the solar system is configured the way it is and why tiny adjustments could render it an inhabitable wasteland.

As time goes on, the glass walls tend to age and occasionally the "cracks" allows external lifeforms (aliens) to slip past the protection layer, much like how insects or parasites would occasionally slip past any opening.

With this in mind, there would be two types of aliens/visitors to our enclosure: (1) lifeforms that are similar to humans in terms of size and biological complexity but more technologically advanced and (2) our protectors who are incomprehensibly larger and more complex than any life on earth. This isn't as outlandish as it seems to be considering there are stars that are million times larger than our own sun.

This sheer difference in scale might as well make the protectors exist in a different dimension. This explains why people would say that aliens were here all this time, but from another dimension. Technically they are here, but more accurately to say the protectors surround us.

Occasionally protectors would step in to prevent mankind from destroying their own enclosure, much like a terrarium owner would reach into the enclosure to remove unwanted organisms. Frequent unidentified sightings on nuclear sites is the protectors' way of peeking and reaching a "hand".

It remains to be seen if humanity would one day evolve to outgrow the enclosure.

A semi-serious tinfoiled answer:

Humans are a protected species, carefully raised and nurtured by higher organisms that are hundred thousand times larger than us (in terms of space and time). The earth and solar system is just a vivarium of galactic scale. Several "glass wall" mechanisms were placed to ensure we are separated from the rest of the universe, like the oort cloud.

Somewhere out there in the universe are humans living freely outside the glass wall.

I just found out that ovh has their own ".ovh" TLD, that sounds pretty legit.

> The unintuitive part is that this works in the first place and doesn't throw an error

What the hell? So you do agree that it's unintuitive but the supporting points you keep giving are completely, utterly tangential. That's what I have been saying all this time, that it's unintuitive, what you are even disagreeing with me for? The analogy?

I repeat this once again, I made the analogy to simplify and make it clear because some responses seems to miss it. I've already addressed your points, but you keep giving back the same supposed rebuttal, different words but same meaning. Nothing about what you say invalidates the analogy.

> But if you know about this unintuitive feature and are relying on it instead of accessing the fields by their fully qualified names, then you should already have a gnawing feeling that asks you "what happens when there are conflicts?" (and the answer is - it does the intuitive thing)

If you are deeply aware of the quirks, intuition no longer applies. You rely on intuition when you are in an unfamiliar situation. So again, nothing what you said just now supports any of your argument, whatever it is.

> There are no "latter operations or (re)definitions" here.

Yes, in the literal narrow sense, there is no such thing in the submitted article (if it isn't already clear, I'm referring to my own example). That's why it's an analogy. I don't know the precise term that go uses for this, closest is probably "shadowing", but again it doesn't matter, it is besides the point. The point is that the exhibited behaviour is unintuitive, in contrast to what the others are saying.

> it completely replaces the intuitive thing that's happening with an unintuitive thing that isn't happening

What is the intuitive thing are you referring to here? If it's my example, then you are in total agreement with me, but you seem to think otherwise. If you are referring to the linked article, then you are just merely invoking tautology, to disagree with me. It's intuitive because you said so, therefore my analogy is invalid. Did I get that right?

I'm making an analogy using simple assignments to show more clearly that it's actually counter-intuitive, I'm not claiming what you seem to be refuting, which at best seems to be beside the point.

I die inside whenever I see something like this. Not even a word that this is a reference to the "Operating System in 1,000 Lines" which someone else linked in this thread. The worst part is that OP probably learned nothing about operating systems from this project.

I'm confused at the responses saying this intuitive. It's like saying:

  var x string
  x = "abc.com"
  x = "xyz.com"
  fmt.Println(x)

will print abc.com and that's totally expected.

The normal intuition would be that the latter operations or (re)definitions override the preceding ones.

> To be more precise, we should stop trying to solve the syntactic problem

Fixing the problem purely from a syntactic perspective avoids any unexpected semantic changes that could lead to irreconcilable disagreements, as clearly demonstrated by the infamous try proposal. Very simple syntactical changes that maps clearly to the original error handling has the advantage of being trivial to implement while also avoids having the developers needing to learn something new.

Maybe, it's using lowpoly models though which are relatively easier to create or outsource. This game is more on simulations and procedural generation, so I think game code is the likely the bottleneck.

I agree that the game is amazing from a technical point of view, but look at the reviews and the pace of development. The updates are sparse and slow, and if there's an update, it's barely an improvement. This is one the of disadvantages of creating a game engine from scratch: more time is spent on the engine than the game itself, which may or may not be bad depending on which perspective you look at it from.

Grim fandango too

I've seen code like that in production, it's not as strange as you think (pretty common in reactjs codebase). After a while, you just get used to it and read past the weird syntax. It's not really that different from a switch-case or if-else block:

  function member(item, x) {
    return   /* if   */ is_null(x)
           ? /* then */ null
           : /* elif */ item === head(x)
           ? /* then */ x
           : /* else */ member(item, tail(x));
  }

That's the point of comments right? Comments are not supposed to be stand alone, they exist to provide additional information that the code cannot express fully, but no more than necessary that it becomes a noise. It's all about balance.

> If you need the code to understand the comment, the comment is a failure.

Nope, not all comments are for the public API. Some are very context-specific and can only be understood in that context. Fully providing all the excessive details in the comments that it becomes context-independent is pointless and time-wasting.

> I'm not unfairly clipping context away from it

Yes you are, you didn't attach the surrounding code where this comment was found. That comment would make a lot of more sense even just with the function name.

Thanks, ghostty looked really off in KDE by default.

Not disagreeing with your overall point, but JS can also do it more succintly:

  [1,2,3,4].reduce((a,b) => Math.max(a,b),100)
  // or
  Math.max(...[1,2,3,4])

I'm currently trying to create a lua-to-js transpiler using treesitter. Not sure how hard this is, but I suppose it's just a matter of traversing trees. I might need to use this transpiler later on my static site generator using a lua DSL.

I'm also planning on making changes to improve my text reader. The purpose of the project is to help me alleviate my discomfort when reading long blocks of text over an extended period of time.

This goes beyond media entertainment. All of our senses are being exploited and overstimulated for commercial gains. Food, perfumes, music, furniture. People crave for saltiest or sweetest food. They fill their noses with strong artificial fragrances, their heads with loud, distracting, catchy music, all the while butt-slouched on the comfiest couches or beds. If this continues on, there will be a point where humanity will be so desensitized and can no longer feel anything natural with their own senses.

Yeah, even disabling a bunch of things and pausing the scene tree, Godot still uses 5% of my CPU (i3-6100T):

  func _ready() -> void:
    set_physics_process(false)
    PhysicsServer2D.set_active(false)
    PhysicsServer3D.set_active(false)
    Engine.max_fps = 1
    RenderingServer.render_loop_enabled = false
    get_tree().paused = true

I wonder what's using that CPU?

You can enable low-processor mode to reduce CPU & GPU usage. See related FAQ https://docs.godotengine.org/en/stable/about/faq.html#is-it-...

Lucky you, godot does have those features, although a bit limited to an extent.

For native file dialogs, see the methods file_dialog* in https://docs.godotengine.org/en/stable/classes/class_display...

Not quite sure what you meant by drag & drop, but godot has API for getting the files dropped onto the window: https://docs.godotengine.org/en/stable/classes/class_window....

Finally, you can create (or customize?) native menus: https://docs.godotengine.org/en/stable/classes/class_nativem...

Also, slightly unrelated, I have WIP useless desktop widget created with godot https://github.com/nvlled/fps-desktop that shoots a gun on mouseclick. Tested only on linux.

https://github.com/256lights/zb/blob/102795d6cb383a919dd378d...

TIL I can also use semicolons on lua tables, not just commas:

  return derivation {
    name = "hello.txt";
    ["in"] = path "hello.txt";
    builder = "/bin/sh";
    system = "x86_64-linux";
    args = {"-c", "while read line; do echo \"$line\"; done < $in > $out"};
  }

I like using lua as a DSL, now I like it even more! I've using lua as a html templating language that looks like this:

  DIV {
   id="id";
   class="class;
   H1 "heading";
   P [[
    Lorem ipsum dolor sit amet, consectetur adipiscing elit, 
    sed do eiusmod tempor ]] / EM incididunt / [[ ut labore et 
    dolore magna aliqua.
   ]];
   PRE ^ CODE [[ this is <code> tag inside <pre> ]];
  }

https://nvlled.github.io/catchsup

This is a habit-building app that I've been personally using for months now. Although it's still buggy and slow as heck (prototyped with electronjs), it has been very helpful and effective for me so far. Aside from slowly reading and finishing a book[1], I alternate in doing these on my free time:

  - learn zig (currently with ziglings)
  - learn 3D gamedev with godot 
  - learn blender
  - read Crafting Interpreters
  - read Computer Graphics from Scratch
  - meditate consistently every early evening

Although the pacing is gradual and slower compared to traditional means, it's more relaxed and it doesn't intrude in my daily main activities. I also learn better due to natural spacing effect, which also gives me time to reflect on what I did.

Currently thinking of rewriting it in the future, especially the scheduler, but it's good enough for now, I'm instead searching for a remote work to support development.

[1] Philosophy of science: a very short introduction