HN user
I got this sense as well, particularly from the section about assertions. Most of the use cases they describe (e.g checking function arguments and return values) are much better handled by an expressive type system than ad-hoc checks.
Does it matter? I’d rather use a 90% accurate tool than an 80% accurate one that I can subject to retribution.
On the other hand, I’ve found the integration in Confluence quite helpful, particularly for making sense of acronyms.
TiVo has stopped selling Edge DVR hardware products,” the company said in an AI-based message.
What does this actually mean? An AI-authored press release? A customer support bot message?
It’s even in the standard library now: https://doc.rust-lang.org/std/cell/struct.OnceCell.html
You can use pgrep to avoid this.
For the `-j` issue specifically, exporting `MAKEFLAGS=-j8` should work.
There is a well settled practice in computing that you just don't plagiarize code. Even a small snippet.
I think way many developers use StackOverflow suggests otherwise.
“Man” is probably being interpreted as the Isle of Man.
Looks like only the code is Apache, not the weights:
the code in this repo is Apache 2 now added, the model weights are the same as the Llama license as they are a derivative work.
https://github.com/canopyai/Orpheus-TTS/issues/33#issuecomme...
Looks really interesting. I like the approach of writing pure functions that return descriptions of IO tasks to perform. A couple of questions:
1. Why async?
2. Why couple to anyhow instead of using an associated error type?
From the sound of it, a whole bunch of them.
What would HP bring to this hypothetical merger?
I think this is exactly the intended use case for Ninja. It’s discussed in this recently posted article.
and it’s ultimately done to show that OpenAI is making an effort to mitigate the risks that regulators claim it creates.
I’d go one step further — the subtext is that only Open AI is willing to do this, and that LLMs are just too dangerous to open source/not another with regulation that only big companies have the resources to adhere to.
I think IAM would be a lot easier to interact with from a dev perspective if the error messages were more clear. I suspect that they are sometimes intentionally vague (or misleading) as a kind of security-through-obscurity. For example, S3 returns “file does not exist” errors when the real problem is that the caller doesn’t have permission to access the bucket/prefix.
Gleam's labelled arguments are AFAIK a unique feature. This lets you have named function argument appear differently to the caller than they do internally. The caller may way to refer by verb ("multiply_by") and the function may want to refer to it as a noun ("multiplier").
Swift has this feature as well.
It’s accessible via the Wayback Machine, fortunately.
I find that kind of surprising; the lack of “customer service voice” is one of the main reasons I prefer the Mistral models over Open AI’s, even if the latter are somewhat better at complex/specific tasks.
The fact that, at the time of writing, all of the comments on this post are about the Oxford comma rather than the actual thesis of the article goes a long way to proving its point.
Greyed-out buttons are similarly terrible UX. Far too often, it’s impossible to figure out why a button is un-clickable.
I’m partial to the Python port of parsec. (https://pythonhosted.org/parsec/)