skysight-inc/HackerNews huggingface dataset:
Hi, thank you for your feedback.

Tool calling is very helpfull when humans can manually define those functions. However, it's also very limited because humans have to define those functions manually unless the function is very simple without any external resources such as accessing an external API with API keys, etc.

Someday, we'll have AI agents that work like our secretaries or employees. But just like a CEO doesn't have to know how to use all the apps that his employees use, some apps would be created only for AI agents. In such a scenario, the interface of these apps would look very different from HCI. For example, they most likely wouldn't use vision or sound as a part of the main UI, unlike HCI.

Interestingly, most apps can be re-rewritten as a Decision Tree. If you push this button you'll be navigated to this page, where a different list of actions is available, etc. I think an AI-Computer Interface if it is ever invented, might look like a text-based Decision Tree without vision or sound unless they are absolutely necessary.
AI for the REST of US
> Like the executives don't even see them as people.

The username above was GreedIsGood. I think they think the executives are doing the right thing.
Funny. This is exactly how I feel about most of the AI/ML papers posted here. Very strange selection of pretty sketchy papers.
We don't need to take money from the fools. They'll give it away.
What does the government do with the monies they receive from said securities?

They use it to fund programs, pay salaries, etc.
Is it true there are dead wasps in figs?
OMG. I have one of the original SGI 24” 1080p flat screen CRTs (went with the onyx2) in storage. One wonders what that’s worth :) fundamentally a better tube ..
i don’t see your contact info.
> Why this works is that the #H hash literal syntax is a true literal. Every time that expression is evaluated, it yields the same hash table, which is mutable.

While this is cool and I think I grok the semantics, the identification of it as a "true literal" has me scratching my head. To me a literal is a syntactical term, so putting a literal into a rom image only makes sense in terms of storing the source itself (which is not necessary most of the time, but might make sense in a lisp).

First-class support for partial evaluation looks really cool. I've been playing around with a scheme dialect built around this very concept.
I had these around my house earlier this year. Hopefully they really are gone...
From the article “It would be laughable to argue the low-end SG2002 AI SoC poses a threat to any country…”

I can see a great deal of trouble capable of coming from a networked device capable of watching the screens 24x7 and potentially intercepting passwords being entered. And those are the legitimate functions for this device. Wouldn’t take much to throw a reverse shell for external access if you wanted to be particularly nefarious.

Not saying there’s any evidence this kvm is malicious. But I probably wouldn’t put it in anything more than one of my toy home lab servers.
8$ a month isn't a fixed cost, it's recurring.

> Plenty of Android devices make it virtually impossible to side-load (Xiaomi)

OK so cherry picking specific android devices vs everything I've managed to buy in the last 12 years to your recurring cost (Primarily Samsung, sadly) for Andoid.

> iOS only allows safari wrappers because the kernel prevents mmap W^X to save Apple the support costs when Chrome gets a 0-day.

How's that going for them again? With the 0 days and kernel exploits?

I'll agree it's better than Android but the overall is still smoke and mirrors IMO. You can have a non-safari browser boxed in non W^X env and it can work but JS might be trash.

I really -do- want to experience the RDF sometime, can you help me? What am I doing wrong?
Am I understanding correctly, and the only thing with a bit of actual data released so far is the ARC-AGI piece from Francois Chollet? And every other claim has no further data released on it?

Serious question. I've browsed around, looked for the official release, but it seems to be just hear-say for now, except for the few little bits in the ARC-AGI article.

So some of the reactions seems quite far-fetched. I was quite amazed at first seeing the benchmarks, but then actually read the ARC-AGI article and a few other things about how it worked, learned a bit more about the different benchmarks, and realised we've no proper idea yet how o3 is working under the hood, the thing isn't even realeased.

It could be doing the same thing that chess-engines do except in several specific domains. Which would be very cool, but not necessarily "intelligent" or "generally intelligent" in any sense whatsoever! Will that kind of model lead to finding novel mathematical proofs, or actually "reasoning" or "thinking" in any way similar to a human, remains entirely uncertain.
For me it is actually a disturbance, especially autocomplete. So yes, I need to remember stuff, but if I cannot or just don't know the codebase, I look it up very quickly and then can learn more from looking at the specific code.

At the start of learning rust I used a bit more help from the IDE, but now not anymore.

For me it is just easier to have a much deeper knowledge instead of "only" have knowledge about the tools. A good example was when I used SVN back in the days, I only used a GUI and always struggled if something does not work out. I had basically no idea, what is really going on. So when Git became the new normal I forced myself to use the command line only and because of that I can always help myself (with Git atleast :D).

Certainly not something for everyone, but it works for me :).
Does anyone have evidence that these so called “idiots” have fewer grandchildren as a result of being scammed? If not, this “natural selection” mechanism isn’t working
This article seems kinda confused. It makes a lot of points, but I'm struggling to extract why that means C++ is more/less fun.

The simultaneous description of modern C++ as "extremely high quality" and yet pervasive legacy bs, horrible tooling, etc is confusing. They say unique_ptr is great yet they "really hate RAII". Many of the discussed topics are largely irrelevant or incorrect. Metaprogramming used to be everywhere but now isn't (what?? Take a look at concepts)? C++ has the best graphics libraries (surely not true)? Installing Python is harder than C++? These seems like odd obsessions of the author, with little relation to the argument.

I think the author just finds C++ fun for some complex combination of personal factors, which is fine. Perhaps partly due to a "hacker" type personality. Some of the most fun I've had with programming has been C++, due to its performance and technicality. At the same time, C++ is in practice crap for "real" software development where your own short-term enjoyment is not paramount (for a billion reasons we all know). C++ is a deeply conflicted language, scarred by decades of legacy and politics. Ignoring the reality of C++ is the biggest mistake of those who discuss it. My attitude towards C++ these days is of tiredness. I don't want to jump through the hoops C++ has thrown at me for the past many years. We don't need to beat an already long dead horse. It's ok to let C++ be what it is.
You have to do a very similar operation to has_value() .value() with Rust's optional though... How is opt.ok_or("Value not found.")?; so different from the C++ type?
I don't understand any of the statements in this post. They don't seem to form a coherent argument, and they don't match my understanding of how lockfiles work.

There's a bunch of very strongly worded statements ("hack", "legacy tooling", "poor design"), but no actual explanations of _why_ or _how_ lockfiles are supposedly bad.

Package managers _are_ deterministic, but they also are reliant on the published package versions that match the listed constraints, _at the time the package manager ran and generated the lockfile_. A dep listed as `foo: ^1.2.0` will match version 1.2.3 today. If 1.3.0 or 1.9.57 is published tomorrow, it will match that newer version.

So, the main purpose for lockfiles is to A) cache a set of resolutions so that the package manager doesn't have to re-run the resolution process every time a repo is cloned and deps are installed, and B) make sure that a _consistent_ set of resolved packages is installed each time, so that you don't accidentally get newer versions that might cause different behavior.

The arguments about hashes seems to ignore what lockfiles already do. They do normally include hashes of the resolved packages, both standalone and possibly as part of a download URL.

The one statement that has any seeming validity is that they _can_ be "attack vectors", in that they are large, border on unreadability, and no one reads the diffs.

But beyond that, this post feels like it never makes a coherent argument.
>> Final note, inflation helps encourage people to use their money and keep the economy moving.

> This is just something people say.

Do you keep your savings under a mattress? Or do you put it someplace where the money can do work in the economy, like a bank account or bonds or stocks?
It is very difficult to break a CRT from the front, even deliberately. The neck is fragile but a CRT TV falling on its face (which is what tends to happen as they're very front-heavy) is far more likely to break the case or the boards inside than the tube.
Concepts did not actually make it into the standard. I vaguely recall they were cut at the last minute or something.
My mistake. Updated.
Amazing. This is a great resource for knowing how to invest your time wisely in learning. Wishing for its expansion.
Judging from the posts I’ve seen, others have already started. Someone had a drone with a lit Roman candle going the other day. Or it was FAA compliant aliens. One of the two.
Same as driving in the city without Waze. Replying to an email in German without Google Translate. There are a bunch of reasons, one of them is because I like it.
You should try turning off those features yourself for at least a month and see what happens ;) You’ll learn the answers yourself, much better than us trying to explain them.

You’ll learn where all the reference docs live for your language, libraries, and frameworks, and along the way you’ll learn more by actually reading the docs.

You’ll learn the value of good project organization and file naming, and explicit import statements.

And you’ll learn that the speed of typing, even long method names, is not the limiting factor of your productivity.
Related

Some insects I found inside dried Turkish figs from Trader Joe’s (410 points, 2 years ago, 340 comments) https://news.ycombinator.com/item?id=34621956

Why aren't figs considered vegan? (115 points, 6 years ago, 102 comments) https://news.ycombinator.com/item?id=19680445
Just get a tea infuser, open the bag and put it in the infuser.
There are a few different projects that one keep hearing about when it comes to tracking donations and lobbyist money towards politicians and elections. Open secrets being one of them.

What does the collective consensus say about the senate and the Judicial branch? Is there a significant difference in how much donations/lobbying/bribing in terms of political alignment, or are both side getting about the same?
Is the custom circuit board something that mortals can get made? That seems to be the sticky point to me.
Only local (read batch size 1) ML inference is memory bound, production loads are pretty much compute bound. Prefill phase is very compute bound, and with continuous batching generation phase is getting mixed with prefill, which makes whole process altogether to be compute bound too. So no, tensor cores and all other shenanigans absolutely critical for performant inference infrastructure.
I tried copilot for a few months, found it annoying, and uninstalled it. These tools make IDEs/LSP unnecessary for my workflow:

1) regex be it grep, or equivalents built into the editor. 2) Multi-cursor editing. 3) dumb autocomplete. 4) knowing how to type fast.

About 70% of the code I write at work is C. Another 20% is Rust (which does have a nice LSP implementation that I use, though I wouldn't call it essential), and the remaining 10% is the usual bash/Python/Ruby/cmake/make mumbo jumbo.
Rogue Is the Best Project
The market is definitely efficient. Try to find arbitrage opportunities (which is what actual market inefficiency is); they disappear in milliseconds.

What you're saying is that it's not infallible as far as predictive power is concerned, which is true. But every current bit of knowledge is definitely priced in.
If you're below-average, AI writing looks great. If you've above, it looks horrible. That goes not just for writing but anything else created by AI --- it's the average of its training data, which is also going to be average in quality.
> There's a point when learning's fun, I think the OP is still there.

What a horrible idea that one might no longer be there.
Maybe from Modular (the company Chris Lattner is working for). In this recent announcement they said they had achieved competitive ML performance… on NVIDIA GPUs, but with their own custom stack completely replacing CUDA. And they’re targeting AMD next.

https://www.modular.com/blog/introducing-max-24-6-a-gpu-nati...
My bottleneck is how efficiently or completely I can keep the problem I'm working on in my head, not how quickly I can look up a function name or variable or type out the actual code. Really, only the latter is helped along by autocomplete. I find myself with that feeling of my mind slowing down more and more as I get older. When I actually get around to writing the code itself, the problem is mostly solved from my perspective, I'm just dumping out of my head into the editor, that part is easy. Until an autocomplete is wired up with an LLM and LSP which knows exactly how I think and approach problems and remember the codebase, it'll be mostly useless for me. So I don't bother.
This benchmark doest look right. Is it using the tensor cores in the Nvidia gpu? AMD does not have AI cores so should run noticeably slower.
I think it’s far more likely that a specialized model would be make for a such a task. Just like with chip design.

I’d be surprised if they weren’t already using some kind of ML/statistical analysis in the design of engines.

When I read AI, though, I was assuming you meant LLMs, not one of several statistical modeling technique.
I used to code in pure vim, so no autocomplete and syntax checking. It is definitely possible.

Is it a better way to work though? Well, in some ways, it forces you to use more cycles in your head, so you do gain proficiency, and you can spot mistakes more quickly. This is a skill.

But once I started working on larger codebases and higher complexity code, I felt it was better to redeploy those brain cycles toward thinking more about architecture, and letting the LSP check the code. With an LSP, I'm now able to write more correct code in fewer iterations.

Like everything it's a trade off. Am I impressed by people who can do complex mental arithmetic? Yes, but for anything complicated that I'd rather not get wrong, I will reach for a calculator. Same idea here.
> With properly structured data, machines should be able to interpret the guidelines. Charting systems could automatically suggesting diagnostic tests for a patient. Alarm bells and "Are you sure?" modals could pop up when a course of treatment diverges from the guidelines. And when a doctor needs to review the guidelines, there should be a much faster and more natural way than finding PDFs

I have implemented this computerized process twice at two different startups over the past decade.

I would not want the NCCN to do it.

The NCCN guidelines are not stuck in PDFs, they are stuck in the heads of doctors.

Once the NCCN guidelines get put into computerized rules, they start to be guided by those computerized rules, a second influence that takes them away from the fundamental science.

So while I totally agree that there should be systemtticization of the rules, it should be entirely secondary and subservient to the best frontier knowledge about cancer, which changes extremely frequently. Annually after every ASCO (major pan-cancer conference) and every disease specific conference (e.g. the San Antonio breast cancer conference), and occasionally during the year when landmark clinical trials are published the doctors need to update their knowledge from the latest trials and their continuing medical education, which is entire body of knowledge that is complementary to the edges of what the NCCN publishes.

Having spanned both computer science and medicine for my entire career, I trust doctors to be able to update their rules far faster than the programmers and databases.

Please do not get the NCCN guidelines stuck in spaghetti code that a few programmers understand, rather than open in PDFs with lots of links that anybody can go and chase after.

Edit: though give me a week digesting this article and I may change my mind. Maybe the NCCN should be standardizing clinical variables enough such that the rules can trivially be turned into rules. That would require that the hypotheses that a clinical trial fits into those rules however, and that's why I need a week of digestion to see if it may even be possible...
There are still a lot of developers out there that basically are at the hammer and nails level of programming. They use a basic editor with basic syntax colouring and when they write broken grammar, the editor just misbehaves telling them they've typoed something.

Many still use rg and fd or fzf outside or within their editor and are anti IDE.

I think ultimately they do waste time, particularly they see refactoring as a big 4 hours job when people using intelliJ and other proficient IDE will see it as a 5' job.

That said, have you every felt, that using all the bells and whistle, half the time you're being impaired by them? Auto-complete nags you, copilot is completely off the plot and spewing tons of stuff all the time.

The key, I think, is to have all the bells and whistle but have shortcuts to turn them on/off. I have auto-complete only drop down on ctrl+space shortcut, not automatically. And for copilot, I have ctrl+cmd+c for turning it on or off.

That way I can free flow type code as I think of it and get the tools to assist whenever needed. It's the best of both world. The IDE as clutter free as possible, and all the tools at a finger tip.

But renaming symbols throughout large projects without an LSP? Nah, been there, done that, for decades, and I'm glad that's over.
> there is a clear distinction between alcohol and almost anything else at the store given that it requires special permits, has age restrictions, and a lot of red tape surrounding it

This varies state to state.
Lego Loco was cool in there was a network version that let you send your train to other people.
Opinion piece by https://en.wikipedia.org/wiki/Tommy_Tuberville
- Google search will be split off.

- Research will prove that "attention is all you need" LLMs have a ceiling, but new theoretical LLMs will emerge.

- Putin will launch a nuclear strike against Ukraine.

- Bird flu will become zoonotic, but milder.

- Taylor Swift will get married, biggest event of the year.

- Apple and Disney will merge, raising prices to everything in the solar system.
We already require labelling for added sugars. No SNAP for added sugar products seems reasonable. (More reasonable: no school lunch subsidies for that crap.)
What book was it that you found helpful?
They absolutely do have similar cores to tensor cores, it's called matrix cores. And they have particular instructions to utilize them (MFMA).
Note I'm talking about DC compute chips, like MI300.

LLMs aren't memory bound in production loads, they are pretty much compute bound too, at least in prefill phase, but in practice in general too.
Some people are also forgetting who is the CEO of OpenAI.

Sam Altman has long talked about believing in the "move fast and break things" way of doing business. Which is just a nicer way of saying do whatever dodgy things you can get away with.
Another Criticality Score Project
Our project aims to evaluate and rank open-source projects based on their criticality within the open source ecosystem. Unlike traditional methods that rely solely on GitHub metrics, our project incorporates data from various Linux distributions, corresponding package managers and more code hosting platforms to provide a more comprehensive analysis. By collecting and analyzing metrics from multiple sources, this project offers a robust and comprehensive framework for assessing the criticality of open-source projects. With this ranking at hand, we will spend more resources on the security of these open-source projects.

Difference from ossf/criticality_score：
- Distribution Dependents: Collects data from various Linux distributions (e.g. Debian, Arch, Nix, Gentoo) and corresponding package managers to evaluate the dependency of open-source software.
- Support for All Git Repositories: Analyzes repositories from any Git platform, not just GitHub.
- Comprehensive Metrics Collection: Gathers a wider and more precise metrics from Git repositories and package managers, for example, the number of commits, organization count is more accurate than GitHub API.
- Friendly for Metrics Customization: Customizes any metrics used in the criticality evaluation algorithm other than metrics that can be only collected by Github API.
- No Dependency on Google Cloud or BigQuery: ossf/criticality_score depends on Google Cloud service, making it hard to migrate to other platforms. This project runs independently of specific cloud services, ensuring ease of deployment.
- Easy Deployment: Runs a script, and the system will be easily setup with Docker.
Provides Additional Information: Provides extra insights, such as relationships between projects and dependencies.

We greatly value your valuable feedback and look forward to your generous guidance!
>I don't think this is true. I don't think it has anything to do with null pointers

The paper that proposed std::optional literally uses examples involving null pointers as one of the use cases that std::optional is intended to replace:

https://isocpp.org/files/papers/N3672.html

Here is an updated paper which is intended to fix some flaws with std::optional and literally mentions additional use cases of nullptr that the original proposal did not address but the extended proposal does:

https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p29...

I am going to be somewhat blunt, but if you're not familiar with how some of the use cases for std::optional is as a replacement for using raw pointers, along with some of your comments about how C++ treats undefined behavior, as if it's just results in an exception, suggests you may not have a rigorous enough understanding of the language to speak so assertively about the topic.
The spec provides an expression for "well-formed" URIs. Good luck with real-world input.
I tried it for engineering calculations. It'll give you numbers, with the right units, but often times they are the wrong numbers.
Salesforce: We're Going to Hire 2k Sales Execs Now to Sell AI
One is undefined behavior which may manifest as entirely unpredictable side-effects. The other has semantics that are well specified and predictable. Also while what you wrote is technically valid, it's not really idiomatic to write it the way you did in Rust, you usually write it as:

if let Some(value) = some_optional {
}

At which point value is the "dereferenced" value. Or you can take it by reference if you don't want to consume the value.
>> E.T. will get a sequel

Sweet! Maybe he'll arrive with a queen that lays eggs. E.T. aliens can't be mammals, right?