frou_dh

In 3D games, something that's key for roads to look/feel realistic is to have small amounts of banking here and there all over the place - as opposed to just having a crude categorisation where there are flat roads on one hand and ramps on the other.

If you don't do that then large parts of the game world end up seeming like ice rinks with roads painted on them.

Is that so? Sounds like this commandment has a lot of authority, I'd better start following it.

Used in space but NOT cleared for attaching the Space Shuttle to the fuel tank.

The whole GitHub paradigm has muddied the meaning of the term "forking". It used to imply a serious intention to diverge. Now to a lot of people it just means doing any development on a copy of a repo. The "Fork" button on GitHub is really "Clone (to my account)".

That's the holy Unix justification for self-flagellation via deficient tooling and you're sticking to it.

When drawing outlines, tables, etc, I hope the new approach (vui) uses real Unicode box-drawing characters and not - | + etc. It's high time TUI people raise their standards a bit and consider unbroken line drawing (no gaps between repeated characters) a requirement rather than a luxury!

The strange thing is that they never did manage to get it done for Ruby.

AFAIK macOS does not ship any version of Python in the normal installation, and it's Xcode / Xcode-CommandLineTools that bundles a Python.

I feel this topic is approaching circlejerk status. Basically any mention of StackOverflow on HN/Reddit is just teeing up everyone to go on about how the SO moderators are the worst people ever.

OCaml is a scripting language in this sense. No need to compile an executable ahead of time, just have a `#!/usr/bin/env ocaml` shebang (or more realistically: `#!/usr/bin/env -S ocaml -I +unix unix.cma`) at the top of a source file.

Though, I don't think it has the capability for single-file scripts to declare 3rd-party dependencies to be automatically installed.

What I got from this is that the author doesn't like the term Extensible being used for situations that don't follow good software engineering practices. Maybe the term Hackable is less offensive and implies dirtiness being okay.

What's obvious to me is that the PRIMARY motivation for Liquid-Glass-ifying MacOS was not to improve MacOS, but simply to make it look consistent with the new version of iOS/iPadOS.

So for Apple to start with a level of disrespect for the existing product where the question of whether each change is actually an improvement is effectively off-topic, it's no wonder they made a dog's dinner of Tahoe.

e.g. https://pkg.go.dev/github.com/zyedidia/generic/mapset

Hopefully it gets added to this comparison:

https://htmlpreview.github.io/?https://github.com/python/typ...

If that table is anything to go by, Pyright is not to be underestimated.

I have briefly tried ty (LSP) in Emacs and it seems to work well so far. The only questionable thing I've encountered is that when the signature of a method is shown, the type annotations of some parameters seem to be presented in a particularly verbose form compared to what I'm used to - maybe they're technically correct but it can be bit much to look at.

Anyway, odds are pretty good that ty is what I will end up using long-term, so thanks and congrats on releasing the first beta!

Sounds like you haven't learned your lesson and are still in mania.

The contrived example used in the first half of the post is offputting. Why would you have a function of 1 argument that only accepts a string with a specific value? There's no point taking an argument then - it might as well be a constant inside the function.

I'm happy if that feature has been descoped because when I last read up on it, it seemed like it was being ramrodded in by an inner circle who were hardly interested in constructive criticism even from other Ruby core maintainers.

You can make really cool flooring with lots of pennies in grids.

If you consider the pipeline for new employees in big tech, I doubt many of them have experience of (or much interest in) true native Windows app development. They have probably been marinated in web-style development and so that's what they are good at and indeed prefer to do.

In a way, the blame lies with Microsoft (and not e.g. Meta) for failing to keep new generations interested in its native frameworks.

Good example of being confidently wrong. You are thinking of the little Basic interpreter that was on the pack-in consumer demo disc. Not the Linux Kit which was a very real initiative and had universities involved. We were using them in a big dedicated lab.

Isn't it strange that they created a new language where one of its main selling points is concurrency, and punted on that design issue.

(Yes I'm aware that Go literature 'encourages' the use of Channels and certain patterns)

There's a (much less severe) instance of that peeve with computer video player apps that have slightly rounded corners on the windows.

Since Smalltalk is effectively an OS unto itself, when we hear about the days of commercial applications being written in Smalltalk, how did deployment to end-users work?

Were the users running, say, Windows and then the Smalltalk "OS" would be running on top of that, but in a sort of "kiosk mode" where its full OS-ness was suppressed and it was dedicated to showing a single interface?

Unsurprisingly there are many frameworks/initiatives that end up falling by the wayside over the years, e.g. MacRuby was being lined up to supersede Objective-C for app development at one point.

I'm very interested to read your article, but there seems to be a never-ending redirect loop of brettchalupa.com ↔ www.brettchalupa.com

Does it use WasmGC, or bundle its own garbage collector?

IIRC in Erlang, not only you cannot mutate a variable, but you cannot even shadow it either.

There's an existing site for this: https://www.clojure-toolbox.com/

> But I do find myself often yearning for the "simplicity" of desktop app development.

Yep, isn't it great to use an API that is actually all about UI widgets, rather than having to indirect through a document markup language.

To me the charming thing about Emacs is how introspective a program it is. This goes beyond all the documentation being built-in, and being able to redefine things on the fly. For instance, it's easy to define a keybinding that does "Take me to the source code of the command that's bound to the next keybinding I type". When you use that and land at a destination, it will probably be Elisp code, but in some cases will even be C code - it works either way.