gignico

I was about to start arguing why I don't agree but then I thought it was better not to :P

Yes, but logic gates with constant fan-in, crucially, otherwise that's called AC.

That's true for two `rectangle` paths, but for two nodes that's what I would expect as a user. Anyway, not an easy problem for sure.

I've tried it now a little. The UI looks very cool, and generally the project is cool so congrats!

However, the generated TikZ code is not good in my opinion. Everything uses absolute coordinates, which in TikZ is seldom needed.

Just to start, if I place a single node I get absolute coordinates for it. Why? If you just write `\node {Hello};`, TikZ will put that at the center of the bounding box. No need to tell it's at `(0.5,2.91)` like it's happening in my test. Then features such as "align bottom" for a selection of multiple nodes should are manipulating the absolute coordinates instead of using TikZ's alignment features (anchors etc.).

I understand generating such code is more difficult. Maybe it can be something to point at for the next version, who knows...

Indeed! Not scientifically controversial at all, but politically controversial, unfortunately.

We all should feel sad and angry. That said, this was never about saving money. This is about keeping scientists under tight control by the government, in order to suppress research on climate change and other controversial topics. If the government can cut your grant at any time without notice or appeal you will think twice before publishing results that go against their ideology, or even before publishing a criticism on Twitter. This is true especially if you are not tenured, which accounts for the majority of the academic world.

Afaik std::span does not need anything that was not in C++98 already, or am I missing something?

It seems that some people are really losing the taste for good readable code.

It seems that some people never had taste for good reliable code. Use `void ` and now any error whatsoever is a direct undefined behavior. Moreover `std::span` clearly says that you are not* taking ownership of the memory (even though the language does not check it of course), while `void *` does not.

I understand that people can have many things to say about C++, and I do as well, but `std::span` should have been there decades ago and is such a life saver in these situations. A truly zero-cost abstraction which effectively saves you from a lot of troubles.

Too bad HN nicknames cannot be put for sale :)

So LLMs are destroying the economy and the environment but at least “catastrophic risk” is still low. Ok then…

Off topic, but I sincerely ask: am I the only one that is disturbed by the use of the term "Mac OS X" to refer to modern versions of the OS that is currently called "macOS"? (and not MacOS either)

I mean, the name was changed ten years ago...

Is it really worth? YMMV, but yes if you ask me.

For reasons, I used to go to Rome quite frequently in the 2010s, and the construction of Metro C was already a meme. But now some of the stations are quite interesting indeed.

Thanks!

The arXiv submission says the paper is submitted to SAT26, did it get accepted?

Positively surprised to see stuff like these on HN first page!

If any author is around, do you have an implementation that can be compared with CUDD and similar BDD libraries?

I know about reproductive pressure and I’ve read The Selfish Gene. What you say is correct but does not explain that “if evolution did not, better not do it” attitude of the original comment, which I think is wrong for many reasons as I’ve wrote.

The problem is implying that “if evolution did not do it there must be a reason”, because 1) it makes evolution look like an engineer evaluating trade offs, which is not and 2) it considers the current state of affairs the final “product”, which is not. For example, flowers did not exist in the Cretaceous, so somebody looking at what evolution did until then would say “if evolution did not invent flowers, then we’d better not do it”. But of course that’s absurd.

Also as I said evolution is not a process towards a goal. There are 8 billion people around the world which proves Homo sapiens is quite fit for its environment so the pressure to evolve further features is quite low.

Running Windows 3.1 in True Color Full HD

People from the time would be astonished by the hardware we have now yet bloated software globs up every ounce of performance. What a waste! </granny mode=off>

Evolution is not a process toward better quality of life and life expectancy of individuals. As long as enough individuals can reach the age to procreate in their environment evolution is done. Evolution didn’t train our bodies to reject the diseases we already have the vaccines for neither, so your reasoning would apply to smallpox as well. And what about viruses appeared after Homo sapiens evolved (such as HIV)?

Until you need to do more than all-or-nothing parsing :) see tree-sitter for example, or any other efficient LSP implementation of incremental parsing.

I don’t know if someone said it already, but when Steve Jobs said this famous quote (“reports of my death are greatly exaggerated”) he then died maybe just a couple of years later.

Hope this does not happen to code :)

Your statement contradicts itself. It was unusable hard before non-lexical lifetimes, but they vastly increased the complexity? Then maybe what’s complex for compiler writers to implement can make the user’s life easier by lowering the complexity of their code?

I'm not sure it shows that. Even basic features of Rust we take from granted come from concepts common users do not need to understand. Borrowing of lifetime draws from affine types, but nobody cares when writing Rust code. If in 2012 you read a similar article explaining borrow checking in academic terms you would have thought Rust would be unusably hard, which is not.

Also I do not think that adding features is always bad to the point of comparing with Scala. Most of the things the article mentions will be almost invisible to users. For example, the `!Forget` thing it mentions will just end up with users getting new errors for things that before would have caused memory leaks. What a disgrace!

Then, pattern types allow you to remove panics from code, which is super helpful in many critical contexts where Rust is used in production, even in the Linux kernel once they will bump the language version so far.

Well, Rust as well has been around for more than 10 years now. I don't imply Rust invented the approach. Surely academia knew about it decades before. I was rather commenting on how one's mental model of things can change by learning new languages.

I think the misunderstanding here is that the article was not intended to users but to other language designers.

As a user, using a feature such as pattern types will be natural if you know the rest of the language.

Do you have a function that accepts an enum `MyEnum` but has an `unreachable!()` for some variant that you know is impossible to have at that point?

Then you can accept a `MyEnum is MyEnum::Variant | MyEnum::OtherVariant` instead of `MyEnum` to tell which are the accepted variants, and the pattern match will not require that `unreachable!()` anymore.

The fact someone does not know this is called "refinement types" does not limit their ability to use the feature effectively.

It’s unbelievable how that 16th century book looks like it is written in LaTeX. Or plain TeX, probably, given its age XD

I think the problem is the under representation of other branches of AI research: knowledge representation, automated reasoning, planning, etc.

These are important topics with important industrial applications which have the only downsides to not be suitable for implementing friendly chatbots and for raising the stocks of Silicon Valley companies.

Under the hood, a virtual table (vtable) is created for each class, and a pointer (vptr) to the vtable is added to each instance.

Coming from C++ I assumed this was the only way but Rust has an interesting approach where the single objects do not pay any cost because virtual dispatch is handled by fat pointers. So you carry around the `vptr` in fat pointers (`&dyn MyTrait`) only when needed, not in every instance.

That’s great news!

I was under the wrong assumption that defer was approved for the next standard already.