xgstation

> This is one reason why Deepseek & GLM are priced so cheaply, they are competing with impossibly low token prices in China. They have to keep prices low, in order for people to use them.

This one does not make sense to me at all.

Deepseek and GLM are openweights, even US inference provider are selling them at much cheaper price. The price is cheap because the model is more efficient.

I imagine FPGA could just be part of general CPU that provides user space APIs to program them to accelerate certain work flow, in other words, this sounds like exactly JIT to me. People may program FPGA as they need to, e.g. AV1 encoder/decoder, accelerate some NN layers, or even a JS runtime, am I thinking something too wild for hardware capability or is it just the ecosystem isn't there yet to allow such flexible use cases?

there is only 160MHz on 5Ghz that's non DFS/Weather Radar

even in single language, how do you handle schema evolution (detect breaking changes at compile time) without IDL?

is using Rust to rewrite existing package managers a new trendy thing

feels we eagerly need cv -> C/C++ package manager

sure there are hype around MCP, but how does that bridges to "MCP Is Mostly Bullshit"?

the title is more or less click bait, even author admits it

> I am not even saying MCP is bad tech or useless. It’s just one way among others to provide context to AI assistants/agents. If you have ever built an LLM-based application, you have more or less done something similar.

but beyond just similar, it's very good to see there is a standard protocol that everyone adopts it, and the MCP will make the existing tools & services immediate ready with better models being released in the future much easier

nit: replace "may have" with "has"

but yes I am tired of seeing this kind of "news". they don't carry much useful information, more like noise nowadays

It is really fun and sarcastic to watch all this happening. U.S. Gov. tried to block China from accessing GPU resources very hardly to stop their AI development, but actually helped China to take a leap on developing efficient and more cost-effective LLM model with constraint GPU access.

I can imagine how depress Lee felt when being beaten by AI the first time, but looking at the bright side, we see Shin Jin-seo as the rising star in the AI-era of Go by leveraing AI to help him training.

from Company perspective, I think the answer is yes

but from individual perspective I don't think that is the case. Since AlphaGo first time was released and beat world-class players, have all these players gone? not really, but it even promotes more people study Go with AI instead.

As a software engineer myself, am I enjoy using AI for coding? yes, for many trivial and repetitive works, but do I want it to take my coding works fully away such that I can just type natural languages? My answer is no. I still need the dopamine hit from coding myself, either for work or my for hobby time, even I am rebuilding some wheels other folks have already built, and I believe many of ours are the same.

if U.S. could have opened its market to Chinese EVs (yes yes I know Chinese Gov subsidizes those vendors a lot, but U.S. can still do punitive tariffs, instead of just ban[1], and of course, making excuses out of national security, meanwhile Tesla is doing okay in China) these U.S. vendors have no competitions is the reason why they are far behind.

[1] https://www.reuters.com/business/autos-transportation/biden-...

> I did not "claim" or "state" from myself directly, I said "recognized as malware" (as per automated analysis from sites), let's learn properly understand the things we read, before "hater expert readers" jump into conclusions. Because the questions I was asking is not "is this malware or not", the questions I did ask across multiple occasions and we should all ask, and some intelligence individuals did just that

Hey, hackernews readers aren't stupid, we all know what communication effect (click-bait) it brings when you put "Chinese" and "Malware" together in title.

as long as human has written self-dialogue and introspection into text that LLM can be trained with, it is expected LLM will produce similar content, this is not much different from any other text

I know other ecosystems do the same and those are baffling too, especially for the newer created languages like rust, which is why https://internals.rust-lang.org/t/pre-rfc-sandboxed-determin... exists

I think sometimes the problem is coming from accidental typos instead of not trusting, say if one accidentally typed `pip install requests` into `pip install requestss` and if `requestss` is malacious then by the time one noticed the typo the setup.py could have already run to do the harm

the fact that `pip install` just runs whatever is in `setup.py` is still mind baffling, even if the author weren't mallicious the `setup.py` can still do harm (say delete a file by mistake), there really needs to be an official way of sandbox its running.

the security is really not just memory safety from its lifetime & borrow checker.

it is that from language perspective, without writing unsafe, you won't have hit undefined behaviors, while provides same level performance of C++

even with unsafe code (usually needed because of performance need), there are very clear guidelines, and tooling (miri) to help check against undefined behaviors

the pain part of C++ is that i would never be confident enough to say i didn't write some undefined behaviors by mistake/accident, and requires extra tools like UBSAN in runtime to find them (C++'s miri)

however most of the time i don't need to run miri when writing rust, as they are slow for large enough project, unless i write unsafe, where it can be well scoped to be run with miri

another aspects rust put a lot efforts on is the soundness, that comes with the type system, that you know how to and when the code needs to handle errors when using someone else's code, so you never hit problems like NullException or silent racy conditions because thread safety comes with Send & Sync trait.

all these benefits just allow people to focus on the real problem, instead of wasting time on figuring out things like "oh this is undefined behavior", "oh it can return null in this case", "oh this function cannot be used in multithreading context", when the real problem to solve is something like "I need to send this trasaction to some background worker to be processed"

If I have to guess that is likely the case, but if that is the case then reasoning and formal process should me made clear and transparent, while the weird part is that Huawei is also under sanctions and has a lot people contributed to Linux, but they are not removed. So what is our standard process here?

By technical, it means decision is to be made objectively through logical reasoning following certain rules. It is a patch at the end and should follow kernel development process. However, the reason for that patch removing Russian maintainers until now is still not made fully transparent by either GKH or Linus. Instead, calling it "I am Finish" and "Russian aggression" has nothing to do with the patch itself and is not constructive discussion. Even we trace down to the road, none of the maintainers today has done that aggression to Finland. If the reasoning of rejecting the revert patch is "Compliance issues based on our lawyers suggestsion" etc. then just say it.

Linus Torvalds said

> As to sending me a revert patch - please use whatever mush you call brains. I'm Finnish. Did you think I'd be supporting Russian aggression? Apparently it's not just lack of real news, it's lack of history knowledge too.

The concerning part to me is that kernel development will not only be based on technical discussion anymore (or maybe it never was): why would a revert patch or not has anything to do with nationalities or personal's political and hisotrical view. Bias towards either side to accept/reject technical contributions for such large project is only going to be harmful for the project regardless of open-source or not.

not sure if this is what the op referred but like this one https://news.ycombinator.com/item?id=41450347

didn't find threads that regarding "clarify APIs semantics", but kernel docs are indeed not in a very good condition. Since C does not provide same level of soundness that Rust does, there are many hidden traps.

asahi developer had a good discuss about this https://threadreaderapp.com/thread/1829852697107055047.html

to be fair, Qualcomm runs on Linux (Android) all the time

We will just need to use quantum to beat the quantum. QKD (quantum key distribution) is much more mature comparing with quantum computer which is still far away for cracking crypto algorithms from real practical application standpoint.

Twin-field quantum key distribution over 830-km fibre https://www.nature.com/articles/s41566-021-00928-2

ddr5 ecc is on-die ecc, that is built in with the ram die, while the regular ecc relies on extra bit width(72 bit instead of 64 bit) going all the way into CPU such that it's detectable also on cpu (hence OS level) side, which also ensures the error during transmission get corrected as well.

I desperately think GPU programming(or specifically CUDA) needs some language level support like coroutine/async/await to organize the data flow and the executions among different dispatched device side function calls, and more on that to have some synchronize primitives between different blocks/warps etc.

This is interesting. The article mentioned Zen4c is architecture same to Zen4 but optimized for density running at lower frequency. Question here if anyone knows the answer: it seems like high frequency requires significantly more transistors? And is optimized for density also means less power consumption(assuming both zen4 and zen4c running at same frequency)?

afaik some famous ones are like InfluxDB, Fish, and of course some parts of linux kernel (v4l2) that most of them improved the performance while rust provides abstraction at zero cost so it does make life easier

AFAIK physicists use it very heavily, but I barely know any mathematicians use it. To me this is a great tool for people who use Math heavily as a tool but not study Math itself.

I use it for symbolic calculation, solve differential equations, and many complicated integrals, and its visualizaion build upon those with easy parametrize support is very nice. Starting from my ungrad sophomore year as physics major, we have courses require us to finish some homeworks with Mathematica.

I can hardly find any other tool to replace mathematica in terms of symbolic calculation and doing complicated integrals (there is a joke by calling mathematica "large-scale integral table")

> The uncertainly created by the law has already put a freeze on making offers to research students in China for the fall of 2024, which normally happens in December and early January. “We have missed that window,” says Zhong-Ren Peng, a UF professor of urban planning who leads a center for adaptation planning and design. “And the best students cannot wait. Instead, they will go somewhere else.”

It reminds me back to my undergrad time there was a Iranian mate in my class (physics major already) blocked from getting second F1 visa (visa for foreign students) for grad school for studying quantum information, and just end up with being a software engineer. The irony part is that most of quantum information works are more public accessible than proprietary code in some big corps.

Resizing/deleting items in list in most implementations are either not lock free or not threadsafe