Hacker Newsnew | past | comments | ask | show | jobs | submit | POiNTx's commentslogin

I'm participating with my game in this Next Fest and I don't really think this is much of a problem. The amount of games presented doesn't seem significantly higher than last Next Fest. Games that are good get boosted after 2 days (first 2 days everyone gets featured randomly) so low quality AI slop won't get much of attention. And the way they check if a game is popular is wishlist count and player/install count as far as I understand. I don't think low quality slop will get much of boost, and if it does it probably is deserved unless the wishlist count/player count gets botted somehow, but I haven't really seen this happen but who knows. For most people I think it's best to wait until after the second day to see which demo's are worth checking out, there won't be much AI slop there.


As a Belgian living abroad I'm waiting for the day prepare/filet americain, proper mayonaise and "broodjes" are available world wide. If people knew about it, it would be as big as sushi!


Yeah, broodjes would be great. But I'd settle for even just decent bread lol.


I mean, a hoagie is a broodje, just the bread is not as good. The quality difference in mayonnaise outside of Belgium insane too.


I've been using nix before you could use AI to write ok code with it and it was a struggle knowing how to configure nix sometimes. Especially when dealing with less popular software which happens from time to time. Still stuck to it as I've felt that once it was working it was pretty amazing. But using Claude with nix is super cool. It's really good and I don't care much about the quality of my nix config at this point, it's just for me and I just want my computer to do what I want it to do and Claude can figure it out most of the time.


Heck i used Claude when it sucked just to ask it questions. It was wrong on 50% of the questions back then but it still was easier than randomly searching for the solutions. Claude helped unblock me when i got stuck on obtuse nix errors, foreign compilation issues, etc.

These days it's magical, but it was even a huge boon when it was barely functional. Nix just had a way of leaving me super confused and stranded.


I tried using various configurations tools and to this day, unless it’s needed for a project, my strategy is “don’t bother”. When I use a program for a while, I backup the config somewhere and perhaps write a few notes, but my daily setup vary enough and last enough that I wouldn’t replicate it.

My mac setup hasn’t been replaced since 2021 or something, and it was copied from my old mac. I have a dotfiles git repo, which I drag around and have multiple branches for my daily driver. For temp setup, I just copy files and edit.


most of us are not interested in doing extra unnecessary manual work to maintain these things or synchronize them across different computers or resurrect them after a certain amount of time not touching them

but you go with your time wasting self


I've been working on a puzzle game Quilt. Hope to get the demo out this coming week or next week.

https://store.steampowered.com/app/4760970/Quilt/


Can recommend Odin[0] if you want to play with Raylib. Great for prototyping, although I'm not sure if it will last further on in development. Still have to figure that one out.

[0] https://odin-lang.org/


What’s special about Odin when it comes to Raylib? (Genuinely curious)


Most of my code in the last year and a half has been Odin. My personal codebase moved from C11 to Odin. I would say that Odin is just more streamlined and easier for a beginner to learn with (which is who Raylib is aimed at.) Both syntax and semantics are simpler; so much so that the (relative to C) smaller ecosystem doesn't pose a problem to learners.

I like Odin because it values the low-friction of C, unlike just about every other "better C" I've tried. It adds friction where you're likely to cut yourself, and reduces friction where it matters; in places like:

- having semantic modules instead of textual inclusion

- having a nice build-system built in

- smart bounds-checking/integer-wrapping semantics (customizable, too!)

- predefined mathematical operators for things like vectors and matrices

- an actually useful core library


I think the magic is still mostly in raylib in that it's a well designed API with high composability. It feels like playing and building. Odin is special in its own right.

There's no particular feature of Odin that really stands out, but where Odin outclasses every language available is that every single feature has been very thoughtfully considered and designed to have the least amount of issues. Once you work with it for a few months, it becomes obvious very quickly its vision is remarkably consistent, leading to a smooth and outright delightful development experience.

I will caution, if you are the type of developer who likes to pull in lots of packages and dependencies to start a project, it's not for you. There's no package manager, and rightly so[1]. You'll have to build most high-level systems yourself. But when you realise that most frameworks and dependencies are trivial to implement by hand, this won't be a bother.

If you're the kind of developer who loves building systems and doing everything yourself, you'll feel right at home.

[1] https://www.gingerbill.org/article/2025/09/08/package-manage...


If you know C, not much because you steer away from the gotchas. If you don't, it's a good language, and with less surprising effects.


I think Raylib satisfies a similar CAPABILITIES-niche to Godot...

I am _not_ talking about ease of use or interface.

For a long time Godot has not been ready for medium-large 3D releases, that is changing, but for the most part both it and Raylib are very reliable and will be perfectly good to release a 2D game with.

I'm not actually sure whether a 3D game with skinned meshes will ever be in-scope for Raylib. Wouldn't seem like it.


They didn't say anything about godot or 3d meshes.


“not sure if it will last further on development”

I interpret this to mean something like “as my game gets more involved” which is not unrelated to a venture into 3D. Why are you policing my comment which is trying to be helpful?


Your comment was so unrelated I thought you replied to the wrong comment.


In Elixir this would be written as:

  db.getUsers()
  |> getExpiredUsers(Date.now())
  |> generateExpiryEmails()
  |> email.bulkSend()
I think Elixir hits the nail on the head when it comes to finding the right balance between functional and imperative style code.


Not a single person in this thread commented on the use of Date.now() and similar - surely clock.now() - you never ever want to use global time in any code, how could you test it?

clock in this case is a thing that was supplied to the class or function. It could just be a function: () -> Instant.

(Setting a global mock clock is too evil, so don't suggest that!)


I was just referring to how pipes make these kinds of chained function calls more readable. But on your point, I think using Date.now() is perfectly ok.


> I think using Date.now() is perfectly ok.

This is why we have tests which we need to update every 3 months, because somebody said this. This is of course, after a ton of research went into finding out why the heck our tests broke suddenly.


I would call those badly-written tests. The current date/time exists outside the system and ought to be acceptable for mocks, and in python we have things like freezegun that make it easy to control without the usual pitfalls of mocks.


What are those mock pitfalls, which are avoided by freezegun which is a mock according even to them? IoC and Clocks solve the same problem. So what are the pitfalls of using those instead of this other mock?


Applying it to the wrong module, a very common mistake in python due to how imports work.


What happens during a daylight savings adjustment?


You use UTC which doesn't adjust daylight savings.


nit picking on the example code while missing the example the code was trying to demonstrate. I see why TAOCP used pseudocode


Agreed! But i didnt miss the example.... i also thought it was interesting that all the various examples of declarative or applicative did Date.now(), which i see as a big thing to avoid.


    bulk_send(
        generate_expiry_email(user) 
        for user in db.getUsers() 
        if is_expired(user, date.now())
    )
(...Just another flavour of syntax to look at)


The nice thing with the Elixir example is that you can easily `tap()` to inspect how the data looks at any point in the pipeline. You can also easily insert steps into the pipeline, or reuse pipeline steps. And due to the way modules are usually organized, it would more realistically read like this, if we were in a BulkEmails module:

  Users.all()
  |> Enum.filter(&Users.is_expired?(&1, Date.utc_today()))
  |> Enum.map(&generate_expiry_email/1)
  |> tap(&IO.inspect(label: "Expiry Email"))
  |> Enum.reject(&is_nil/1)
  |> bulk_send()
The nice thing here is that we can easily log to the console, and also filter out nil expiry emails. In production code, `generate_expiry_email/1` would likely return a Result (a tuple of `{:ok, email}` or `{:error, reason}`), so we could complicate this a bit further and collect the errors to send to a logger, or to update some flag in the db.

It just becomes so easy to incrementally add functionality here.

---

Quick syntax reference for anyone reading:

- Pipelines apply the previous result as the first argument of the next function

- The `/1` after a function name indicates the arity, since Elixir supports multiple dispatch

- `&fun/1` expands to `fn arg -> fun(arg) end`

- `&fun(&1, "something")` expands to `fn arg -> fun(arg, "something") end`


Not sure I like how the binding works for user in this example, but tbh, I don't really have any better idea.

Writing custom monad syntax is definitely quite a nice benefit of functional languages IMO.


That's a really cool concept, I'd love to see more art like this that uses modern technology. Do you have a demo available somewhere to see what the effect would look like? This is one of those things where you should just do it without asking for permission. The portals[0] art installation in some cities doesn't ask for consent either.

[0] https://www.portals.org/


Something like https://github.com/mrdotb/live_react might be what you're looking for.


https://backpex.live/ is a pretty good Phoenix Admin. Django's admin is still unmatched though.


Does this allow external programs/servers to interact with a workbook (xlsx file)? Or is this just to run more complex calculations inside cell(s)?

There's UNO and there's also openpyxl to interact with workbooks from Python, but both solutions were a bit slow when testing it.

There's a lot of value in having existing workbooks which a lot of businesses already use, and extending them so they can be interacted with or queried from a server. For example to allow further access from a webapp without allowing changes to the entire workbook or hiding the full dataset.


Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: