rootlocus

I don't understand what you mean. The issue with boastful and vague landing pages has started long before LLMs became viable for generating content.

That's commonly implemented with shaders. Support for shaders is guaranteed in virtually any game engine.

> It's full of clichés, buzzwords, and empty promises. For example, you claim that your product can "help you achieve your goals faster and easier than ever before." But you never actually explain what your product does or how it works.

This perfectly captures my experience with almost every product web page today.

I'm not really experienced with programming language design or with compilers, but it seems to me the design of a systems programming language has to compromise on the side of performance. If the implementation of the design requires additional space or cpu time, it may not be a good fit for the language. As such, it's not orthogonal.

> “If you wish to make an apple pie from scratch, you must first invent the universe” :)

This is something I posted on Casey's first handmade video, together with some counter arguments to his rant on the shortcomings of c++ and windows. He has since disabled comments.

    def group_by_interval(timestamps, interval_duration)
        # do the stuff

Why does this require a comment?

Sarcasm is hard to detect in written form.

We learned borland pascal and borland c in high school. Java is perfectly fine.

Exceptions reinforce the rule. The other games that have Deluxe in their title have such strong titles, that the "Deluxe" part is often overshadowed. The article gives some examples:

* The Elder Scrolls IV: Oblivion Deluxe

* Assassin's Creed 2 Deluxe

* Mass Effect 2 Digital Deluxe

When the fast cognitive System 1 [1] has to make an initial impression on a title, it uses all biases available to waste as little energy as possible to come up with an answer. "Unknown Deluxe" is very fast labeled as " janky cloned 5-minute games with 50c in the discount bin". "Assassin's Creed Deluxe" is just as easily labeled "some newer / improved release of Assassin's Creed".

[1] https://en.wikipedia.org/wiki/Thinking,_Fast_and_Slow

They recently released Return of Rome, where they added Romans to AoE2 and also implemented AoE1 inside of AoE2, using the same engine and QoL improvements from AoE2. You can now play the full AoE1 game (except ranked multiplayer) within AoE2.

https://www.ageofempires.com/games/aoeiide/return-of-rome/

Between duck-typing languages like python and javascript and the minefiled that is C++, I think Java and C# fit a pretty nice sweet-spot. Java absolutely has "just data", they're mostly used for DTOs and database Entities, with tools like lombok @Data and `records` being some nice mechanisms of implementing them.

Inheritance, when used for implementing is-a relationship, is a pretty powerful tool. If you're surprised by overriding, maybe instead of complaining about `Parent parent = new Child()` examples, try to see a `Writer writer = new PdfWriter()`. Are you still surprised that `writer.write(document)` generates a pdf?

There are absolutely horrible ways of designing code in Java, but that can be said about any language.

Simple anecdote: A colleague of mine had a really hard time getting some topologic sort to work. I kept finding issues with his implementations and he was getting frustrated so we aggreed to have a pair programming session. He wanted to put all the code in a single method (not terribly long, maybe 30, 40 lines), but the conditions kept nesting and no matter how much he tried to figure them out, he couldn't get them to work. I convinced him to extract two methods which would only be used once and only inside this sorting method. He was vehemently against it. After he finally agreed he realized the code was so easy to read, it was basically self-explanatory and obviously correct. No ammount of fiddling with the if statements could've produced that.

I don't impose fixed line counts for my methods. But when it makes sense, the readability improves a lot.

And part of that context is your personal preference. Zig purposely chooses to prevent hidden control flow [1]. If operator overloading is a preference of yours, the language will get in your way. And that's fine. But it doesn't mean you can't build the "right abstraction" with it. These tradeoffs force you, for instance, to add an allocator to every type that needs dynamic allocation. For me that's great because it's evident which components need memory and I can make a conscious decision on what strategy to use with each one (or to avoid them entirely). For someone else, that might be a PITA. There is no "right" abstraction here.

1. https://ziglang.org/learn/overview/#small-simple-language

If you want total control over your hardware, you're free to use machine code. Is a type system a leash? I mean surely you want to interpret memory however you want without the language getting in the way of forcing you to use methods. Are unique/shared pointers a leash? Or the borrow checker? They restrict what you can do with your objects because you're a poor programmer who can't code correctly. No true developer needs memory safety. Are calling conventions a leash? Surely you know better how to manage the stack and registers and everyone else should listen to you and do it the way you prefer.

There are no "right abstractions". There are tradeoffs with advantages and disadvantages. Your preferred abstractions are by no means the "right" ones, especially since you don't even define what they are.

Google has stolen data from pages and showed it without attribution on their search page: https://docs.house.gov/meetings/JU/JU05/20190716/109793/HHRG...

Disney employs full-time artists that can do that anytime. They pay her specifically for comissions.

It's original enough that Disney pays her for contracting work.

> as you don't need to lift the pen/pencil from the paper as often Except for crossing your Ts and dotting your Is and depending on your language's alphabet, other diacritics which breaks the flow since you're switching from gliding over the paper to pattern matching letters and words from the start of the sentence.

> great interop back and forth with Java.

That's something all JVM languages share. Not that easy with compiled languages unfortunately.

> The problem is that all and I mean all of these idealogical driven agendas require tyranny because I for one do not agree with your world view.

There's always someone who disagrees with someone else's world view, that doesn't make it tyranny.

Sounds like it has lots of benefits and no downsides, which begs more research. The website however seems to have a leftover placeholder text under "Our bugs are bettering the world" > "Disease Free":

That wasn't real text. Just holding some space here. Real text is going to be awesome.

A bit forced, and they all sound like denial, but I can see all the stages if I squint.

> If I use square tiles and hide the seams between adjacent tiles, will it look OK?

Square tiling is very obvious, as you can see from the first example [0]. Hex tiling shifts tiles to a less obvious pattern. Also, as I can see from the video, tiles can be rotated while hiding the seams perfectly, which eliminates repetition altogether.

0. https://github.com/mmikk/mmikk.github.io/blob/master/picture...

https://github.com/ayojs/ayo comes to mind.

I have interviewed "senior devops" candidates that didn't know what procfs was.

edit: We didn't consider them for the role.

It also misplaces C++ in that list.

Graalvm has support for ahead-of-time compilation of JVM languages. They promise "native executables [that] start nearly instantaneously, are smaller, and consume less resources of the same Java application".

This is how things like Babashka (Clojure CLI scripting runtime) are possible [0]

0. https://babashka.org/

Java EE != Spring Framework != Spring Boot

Because it has a VM (portability, multiple languages interact seamlessly, bytecode manipulation at runtime, low compile times), insanely fast GC, best tools in the industry (IDEs, static code analysis, debugger, libraries), and it's still fast enough to write HFT software with it.

It's even possible to compile it ahead of time, making projects like a Clojure CLI scripting runtime with almost instant startup time possible (babashka).