https://hemingwayapp.com/ gives you advice about your writing.

This is called Hemingway because he was apparently good at communicating efficiently which made him a popular author.

This is an interface, not an LLM. Do they say which LLM they use? Many of these are interfaces to one of the big three model providers. Others run through OpenRouter to use one of the better open models, all of which have their own quirks.

What happens if you take the output of a mainstream LLM and send it through this app? Would that solve the issue of the original article?

It's been a while since I touched it but I have a very similar GB emulator in rust:

- The library: https://github.com/shaoner/padme-core

- The web/wasm backend: https://github.com/shaoner/padme-browser

Love the idea, my only concern is how to trust that at some point you're not going to include sponsored products?

That's a non-answer to the question. You're saying that you would like to recommend good products only, but the question was about sponsored products.

And on another comment about adding high margin results as "best" you seem very interested in that concept.

I'm not trying to be hateful, but if you're thinking about how to seed results with high margin products for yourself, instead of the actual best results already in the life cycle of your product, I think it's just a matter of (not much) time before any quality you have will immediately plummet. This makes me very cautious about your product. Very.

My company moved to Jira 2w ago and I feel the burden, it's a horrible tool. I don't care if my manager set it correctly or not. 1) What correctly means in Jira? 2) Honestly it's not a good use of all our time to learn how to use it correctly.

Right now, I can't move a task to another column which gives me a non helpful generic error. Should I spend time investigating this?

And yeah it's not only slow but sometimes it crashes your browser, sometimes it doesn't even load what you click on.

I can't seriously understand the appeal. I would prefer anything else, including post its.

I have a python script that builds the pdf from a Yaml file https://github.com/shaoner/resumy/

In my opinion, it comes back to search engines not giving you a the best answer. If you're looking for the best headset with whatever feature, you'll find mostly sponsored reviews, or at the very least hard to trust reviews.

On the other hand, some random people's opinions in a Reddit community with -apparently- no further agenda seem somewhat more honest.

Not that the answer is better but it gives you new data points in your search.

Basically, it's not one or the other, you can use both tools and that's probably why it makes sense to include Reddit in AI models (which do this job for you automatically)

Any shell script that uses files should use double quotes for at least the variables: `mv $1 $2` is not safe, should be `mv "$1" "$2"`

I've been using Emacs for 15y, I can't replace it. Emacs-server is just amazing for me.

I truly believe that its weakness is elisp, it's not hard but at the same time it's not a language you want to learn or spend time with, so of course that means less packages, less support and less interest in customizing it well.

Other than that, I would be quite happy to see a modern version, with support for another scripting language and maybe dropping all these UI features, like menubar, toolbar etc.

If we acknowledge there's a learning curve, the UI buttons are non essential. VSC & others are probably better at this.

I faced the same kind of issue lately and thought that implementing a From trait for each type of error was kind of annoying.

Taking the article example, I ended up doing this:

    #[derive(Debug, Clone, Copy, Eq, PartialEq)]
    pub enum MyError {
        MyErr1,
        MyErr2,
        MyErr3,
    }

    fn read_number_from_file(filename: &str) -> Result<u64, MyError> {
        let mut file = File::open(filename).or(Err(MyError::MyErr1))?; // Error!

        let mut buffer = String::new();

        file.read_to_string(&mut buffer).or(Err(MyError::MyErr2))?; // Error

        let parsed: u64 = buffer.trim().parse().or(Err(MyError::MyErr3))?; // Error

        Ok(parsed)
    }

As I'm a beginner, I would love to hear some thoughts on this

Nothing wrong with that, although you could use ‘map_err’ instead of ‘or’ to preserve the original errors as well if you want to.

I really like the thiserror crate for cutting down boilerplate and you can add annotations to automatically implement From. However, if you want to handle errors with more granularity, e.g. IO errors as noted elsewhere in the discussion, then you'll need to implement From yourself.

And as others noted, .map_err(...) is slightly better than .or(...) for wrapping errors.

The downside of this approach is that you have discarded the original error information. It’s also somewhat verbose at the error-handling site.

The only downside of this approach is that you can't pass a dynamic string giving details on the error, but that's because Rust's enums are not powerful enough to express this (as opposed to Kotlin or Java).