Not paying for a book when you have the full ability to do so is just greed.

But there are also those who come from places where monthly wage is like $200, so they wouldn't be able to afford a $30 book even if they wanted to

Sadly this program seems to segfault on Wayland.

Try the web version: https://web.imhex.werwolv.net

Working fine with me under Wayland, on Ubuntu 24.04 + Gnome 46

While this is true now, I expect this to be the case since it's a reasonably fresh language, and most maintainers of Rust projects are enthusiasts that are fine with breaking changes.

Once you get those 10 year old legacy Rust projects that's when you'll be in a different situation.

There's also a potential paradigm changes (like OOP -> functional pattern) that require a complete redesign of the language, since incremental changes can only get you so far.

Python barely managed to pull of v2 to 3, so I guess the future is open to all options.

Nope, editions cover that use case nicely: Rust breaks things every three years -- without breaking existing code.

Basically you have to opt in your project to the new normal. All your projects dependencies can opt in, too, whenever they want to make the jump. Nobody has to opt in though.

Maybe C++ can do something similar eventually once modules are used everywhere. Those have a much cleaner separation of code between individual project parts than you can have with headers.

Rust is already at a done/stable stage, and won’t make major changes even if it theoretically could.

Change proposals that cause churn are regularly shot down.

Knowing the industry there's a bunch of people out there on the payroll continuously knocking out these assets all day long every day.

Google routinely uses agencies for this kind of work (I have been on both sides). A marketing website like this would be a ~$100,000 spend (depends how many pages and how many creative assets).

That sounds a bit high, but I'll trust your expertise.

Regardless, 1/50 the value of the prize doesn't seem egregious to me.

Sorry, I don't want to be that guy, but I'm curious why use Java and not something like Rust? Is it because of the Lucene ecosystem?

The short story is I'm productive in Java, and I enjoy its mature ecosystem and stable APIs. Systems programming is awkward, but it's also a very small part of the project and for what it is, an interesting challenge.

What I'm building is what Lucene does (i.e. document indexing) and then the rest of the search engine as well including crawling and serving traffic.

Have you tried C# for those kinds of things? It's normally the same level of abstraction as Java, and has similarly mature ecosystem with stable APIs, but it also has unsigned types, unmanaged data and function pointers (with pointer arithmetic), unions, the equivalent of alloca etc for when you need to go low-level.

Have you ever tried Kotlin? For non-system-level stuff on the JVM, it's IMO a direct upgrade to Java. `value class` for type aliases, `when`, and better null handling. But then, modern Java is doing all that stuff too, I hear.

I did this.

I previously worked at a search engine which did its index building and querying in C, with its higher-level stuff (web-apps, scheduling, tooling, etc.) in Java.

Later when I built my own version, I started with C for the low-level and Haskell for the high-level. I made a few iterations in C, but eventually rewrote it in Rust, and I was pretty happy with that choice.

I was more familiar with C, and it was a really good fit for what I was writing. Terms and Documents just become termIds and docIds (numbers) sitting in indexes (arrays). Memory-mapping is a really comfortable way to do things: files are just arrays; let the OS sort out when to page things in and out of disk.

But where C fell down for me was in the changing the code. The meaning of the data&code were lost in nested for-loops and void-function-pointers, etc. Rust gave me a better shot at both writing and rewriting the code.

Java for the low-level was a non-starter for me for a few reasons, but the biggest two were startup time and difficulty of the mmap api (31-bits of address-space for a file? c'mon!).

> Java for the low-level was a non-starter for me for a few reasons, but the biggest two were startup time and difficulty of the mmap api (31-bits of address-space for a file? c'mon!).

Neither of these are issues anymore though. Especially not with graal's native images.

This isn't quite right, linked lists and trees in functional languages can be represented extremely succintly, i.e.

  data List a = Nil | Node a (List a)
  data Tree a = Leaf a | Node (Tree a) (Tree a)

there is nothing stopping you from writing something like this in JS

  const list = { kind: 'node', val: 3, next: { kind: 'nil' } };

And then using a switch case to navigate the list/tree matching on the kind field.

Absolutely. The navigation behaviors will have to be in functions though. And from an application code developer's perspective, the connection between these objects and functions may not be obvious. If only there were some way to associate behavior with state.

The whole point of the top comment is that they appreciate how this library chose not to associate behavior with state, and instead organized things as functions and data structures.

With the latter approach, the user is not limited to the bahaviors that the library author wrote. The data (not state) can be used freely. Similarly, the functions are not tied to any particular state - the data can come from anywhere, as long as it has the right shape.

Right about now KDE is moving to Wayland. KDE Plasma 6 released a week ago will use Wayland by default, with X11 being an opt in mode. I think that X11 while it might exist for the next decade, it will at best be a second class citizen, at worst a buggy and unsupported mess

And even if they pull X support, do you have to use Plasma 6, 7 or 8 in the next decade?

Sometimes it's okay to use old software, especially if it works well for you.

This is approximately how most Haskell libraries are versioned

  -- PVP summary:     +-+------- breaking API changes
  --                  | | +----- non-breaking API additions
  --                  | | | +--- code changes with no API change
  version:            0.0.0.1

[0]: https://pvp.haskell.org/

[1]: https://pvp.haskell.org/faq/

That only happened in the first few weeks/months following the invasion, and since then people returned to calling them "Ruskie". The general consensus is that the name refers to the historical area of Ruthenia

https://en.wikipedia.org/wiki/Ruthenia

I no longer live there, but when I visit now, I often see the name "Kresowe" having replaced "Ruskie", Kresy being the name of a historical region around the Polish/Ukrainian border.

Kresowe is even less PC than ruskie, but people don't care it seems :)

> I think it's better than TypeScript - fight me

I used Python type hints and MyPy since long before I used TypeScript, and I have to say that TypeScript's take on types is just plain better (that doesn't mean it's good though).

1. More TypeScript packages are properly typed thanks to DefinitelyTyped. Some Python packages such as Numpy could not be properly typed last I checked, I think it might change with 3.11 though. Packages such as OpenCV didn't have any types last I checked.

2. TypeScript's type system is more complete, with better support for generics, this might change with 3.11/3.12 though.

3. TypeScript has more powerful type system than most languages, as it is Turing-complete and similar in functionality to a purely functional language (this could also be a con)