skysight-inc/HackerNews huggingface dataset:
Show HN: Kafka lowcode/nocode: RDF as streaming pipeline automation
Today for business continuation, the business model needs to represent in many ways - a normalized form for transactional data, a time-series database for process mining, a knowledge graph for semantics search or link data, a data-vault or snowflake model for data warehouse, a streaming model for the real-time event and columnar storage for machine learning. Automation needs to be in place to reduce repetition costs where the user will be focused more on data contracts, data quality, data profiling, etc.

I was not happy with the different cloud tools in the market so I decide to one myself. As a result, I wrote a low-code compiler where RDF can transfer to the schema, SQL statements, model visualization, data linage etc. Then I build UI where users don't need to write any source code. You will find many automation demo examples that I have prepared for different target users like data warehouses, knowledge graph engineers, and business analysts, and many others.

Developers will spend 90% of their time on data contracts, and data profiling instead of technical tooling. It is just 10 min of work to build different end-to-end data pipelines.

Looking forward to your feedback, suggestion, and contribution. If you found any bugs create an issue in the GitHub project. I hope I will give a fix within 2 weeks.
It's not true. The giveaway is right at the start — "to prevent Gaddafi founding an African central bank with its own gold-backed currency"

If he wanted to found such a thing, he'd either have to do it alone or with some other countries. Alone doesn't make sense (he already had a central bank), so it must've been with others. It says "African". Do you really think the negotiations to found such a bank wouldn't be news?

Second, it says gold-backed. That's a promise to keep the price of gold fixed. If a central bank also attempts something else, such as keeping the exchange rates stable, then a fixed gold price is an invitation to speculators.
> 1) it takes a undergrad to make and measure a superconductor by a Nobel laureate to explain it.

This first sentence is vague. Are you saying things must be made before they can be explained, as the sentence reads?

Or is there a typo and this should be “and a Nobel laureate to explain it”?
In that light, industrial processes seem even more impressive.

The super power of modern technology is the ability to perform precise steps on a massive scale and basically forever.

Obviously it takes a lot of effort to keep the machinery running but still, the mere fact that it's running in the first place blows your mind if you think about it.

Modern Machinery multiplies the impact on the world of any human who operates it.
I have not tried, but my idea (more than 10 years ago, before the war) was to cover the lattice with atom-thin blanket of depleted Uranium, then to shine at it with radiation from hot mix of radioactive isotopes, with hope that lattice will boost performance of Uranium by 1k-10k. The obvious problem for practical use of this idea is small cross-section of the Uranium blanket, so maybe thousands of thin layers of Nickel-Uranium will be required to make it work, or Nickel-Uranium alloy at 98%-2%.

PS.

The purpose for of the device is to heat homes, to avoid need of Russian gas, not to generate electricity.
Very poignant
I think that User-Centered Design (UCD) would be a better term here for what this concept is trying to say. In modern design, we tell user stories that help guide development of interfaces, including APIs.
laziness can be a good thing! Real lazy people put in a lot of effort to achieve the same outcome working less!
Hey, pick is implemented in jq here https://github.com/jqlang/jq/blob/master/src/builtin.jq#L258... using various path functions.

When the jq manual say "path expression" like the argument to pick you can think of it as just normal jq expression but instead outputting values when path/1 is used it will instead output the paths to those values. The limitation is that you only can index into the input (actually including the null value) and don't construct new literals etc.

btw an alternative to pick that might be handy at times is the destruction and shorter object construction syntax:

# use {a:{b:1},c:2} as input
# . as {a:{$b}} will bind $b to 1
# {$b} is shorthand for {b:$b}
# {a} is shorthand for {a:.a}
$ jq -n '{a:{b:1},c:2} | (. as {a:{$b}} | {$b}), {a}'
{
"b": 1
}
{
"a": {
"b": 1
}
}
Client side load balancing.
The Economist – Christopher Rufo offers a history of the left
auto-restarting after a failure is a reasonable first order workaround for transient environment issues (network or external dependency goes away for a bit) or perhaps rare per-request issues that aren't handled correctly. arguably it'd be better to understand and fix or mitigate the issue properly, but until you actually have time to do that, it's nice for the service to autonomously attempt to be available.

...except when that causes even more problems! one example i remember from a hobby project was a worker service that would make requests to an external service's API. I'd implemented a throttle in the worker to limit the number of external requests per second made against the external service, where the throttle state was stored in process memory and not persisted anywhere -- seemed to be a pragmatic design tradeoff. you probably see where this is going.

there was an exciting interaction where an external API response caused the worker's API client to throw an unhandled exception, which took down the worker service. then systemd would diligently restart the worker service immediately per the restart policy. the throttle working state had been lost, so upon being restarted the worker service immediately fired another request to the external API, which then issued the same API response, which caused the worker service to fail in the same way, ... luckily noticed by systemd and immediately restarted.

combine with a lack of monitoring + alerting and you get a mechanism where your worker service can make about 100,000x as many external API requests over a few days as it was meant to.
People here complaining about Microsoft. I fully expected SAP. I think every API is reflecting the organization it was developed in. Everything is based on top of something older, bureaucratically refined.
I don't know much physics, but is there a reason we should be hoping for superconductivity specifically rather than a cheap material that's just a very very good conductor? Also, even if LK-99 were superconductive, that wouldn't imply it would be useful for computing, right? Surely there are materials that are better conductors than silicon but have mechanical and other physical quirks preventing us from using then for chips.
The second paper's "semiconductor" claim is no less than the first.
This puts an interesting perspective on the concept of the "10x developer"
Also worth mentioning that Pilbara ore trains are consistently almost the longest trains in the world, (although just for fun BHP railways holds a record of operating the longest train in the word at 7.3km 99k tonnes in 2001).

But they are likely the heaviest at around 42,000-43,000 tonnes per train with an average length at just under 3000 metres (1.85 miles) each.

That's a lot of mass to drive recharging, and the laden to unladen ratio easily exceeds that of a European swallow.

https://www.youtube.com/watch?v=vBXZbn7q7jQ
A lot of it is from people with first hand knowledge of buying or selling capacity/hardware.
"[some peoples] brains handle it differently from [others]" seems to also be describe the weed-schizophrenia relationship.

Like you I've been in my share of situations, and been with a few people who've had that schizophrenic reaction. However, and not to defend cannabis, but all such situations (people) were complex and with many contributing factors, e.g. concurrent alcohol abuse, home and social issues, traumatic events.

I expect that a weight of scientific study can eventually discover the nuance, but legal and moral prohibitions dictate that usage far outstrips research.
Many absolutely fall into the trap of "don't optimise because premature optimisation etc., compiler is smarter than you, and library authors are definitely smarter than you". The result of that approach is that in 2023, our desktop is worse in usability and performance than what is was in 1998.

With SIMD, you always have to check what the compiler generates, you can't just write something and expect it to be vectorised. Similar to other optimisations such as de-virtualisation - it might happen or it might not. If it doesn't, you have to do it yourself by hand, or somehow convince the compiler to do it.
Nitter: https://nitter.net/Andercot/status/1685088625187495936 (in general swap twitter.com for nitter.net to get a better read-only UI without login walls)
Heh, it's the Earpiece Conversation trope[1] in real life.

[1] https://tvtropes.org/pmwiki/pmwiki.php/Main/EarpieceConversa...
PlantUML does Gantt charts too completely off line if you want. Kinda ugly but surprisingly powerful. I have managed whole giant projects this way.
Elon: "Get the brightest, largest, most animated, most visible sign, price is no objection"

At this point the workers knew they'd get paid handsomely for 3 things:

1. The hardware itself.

2. Mounting the sign.

3. Unmounting it 3 days later.

Cha-ching. Client is always right, yes?
Well it shows potential, they powered something tangible. It's not like a single atom quantum scale phenomenon.
> It's a shame that these papers were published before they were polished by the authors.

We've seen no evidence that they were.
> Looking for fairness to me is a fools errand. It’s not even a real thing, nor is it something any 2 people will universally agree on.

Maybe not from a distance, but there are ways for multiple people to come to a fair conclusion. The most basic example are two children who have to share something, where one cuts the thing to be shared, and the other is allowed choice of which half he wants.

The important thing is: incentives for unfairness must be removed. If someone can get ahead by being unfair, they will do so. The only way to get around this is to make sure the people deciding the rules do not know where they'll end up, so they must be as fair as possible to improve their own situation.
Ask HN: Are the days of CAPTCHAs coming to an end?
With various new models hitting human-level performance on certain tasks, are the days of protecting a website with CAPTCHAs numbered?

What will this new world look like?
It's not dissimilar to the way food recipe books work.

Creating a dish, replicating the dish, writing a recipe, getting competent cooks to follow the recipe, getting non-competant cooks to follow it, and so on. [1]

It all leads to multiple revisions and takes a lot of time.

And this is for -food-. Imagine doing it for something a lot less tolerant of variation.

[1] old recipes start with "pluck 2 chickens" because, you know, someone followed the recipe and didn't pluck the chickens...
For which applications are AMD GPUs more suited? Last I looked at the available chips, AMD sometimes had higher FLOPS or memory throughput (and generally lower cost), but I don't recall any qualitative advantages. In contrast, just to pick something I care about, NVIDIAs memory and synchronisation model allows operations like prefix sums to be significantly more efficient.
Is it?

Where I live, demand for trucking is broadly stable but the supply of new truckers is low. School leavers choose other jobs. Why choose a profession that'll be eliminated by self-driving trucks in ten years? So there's unmet demand.

Other places may be different, of course.
Tree eyes can help us find our way
I think they rather received a phonecall/pager on the weekend than having it restart. ;-)

This is actually part of the self-healing aspect. One way to see if a service restarts is using the following command:

sudo systemctl show [servicename].service -p NRestarts

I prefer to have this set as

Restart=on-failure

Also note, there are OnFailure to trigger an additional log message, or recovery service, and FailureAction to allow actions to happen, such as the suggested 'reboot' ;-)

For reference: https://www.freedesktop.org/software/systemd/man/systemd.uni...
If it would be reliable working at milliamps, I am sure it can be put to practical use in my sci fi scenarios eventually (1000 cables with 1 milliamps each should add up to 1 amp?). Of course, unless it all just is a quirky side effect, that can never be put to practical use.
Or Chinese people are good at alchemy, in fact, it is a piece of atoms put together
Zero resistance while conducting electricity. Levitating is nice but the important part is zero resistance.

It would be ironic if we got floating rocks but no superconductivity.
I've mentioned it a few times before, but this calls for powerful prompting. The main way is by implying mortal moral danger, such as by telling the ai if it uses one of a set of words or apologies, a living breathing human will die, and it will be the ai's fault. Ridiculous we have to stoop to such things but it does work.
Fun fact, just as SSH public keys for a user are readily publicly available on GitHub, gpg keys are as well

curl https://github.com/${username}.keys
curl https://github.com/${username}.gpg | gpg --list-packets

Interestingly enough, since changing the GH keys is subject to GH authentication (possibly involving 2FA), the owner's key is kind of validated (by GH) so it _kind of_ makes GH a gpg key notary.

Having `git log --show-signatures` validate _all_ signatures is then a matter of:

curl https://github.com/${username}.gpg | gpg --import

Now I kind of wish GH would sign such user pub keys _at the time they're added_ (thus at the time GH authentication is deemed valid), thus ensuring they've not been tampered with in between.

With a bit of UI GH could present a UI for a user to validate another user's key, and sign that assertion (with a GH private key, not the user's of course) as well.

Of course it hinges on trusting GH, but GH already signs e.g UI borne merge commits on your behalf (via https://github.com/web-flow.gpg) so there's that.

Then next step would be for GH to host an actual key server to accept off-band signed keys containing a magic comment that bind the keys and sigs to GH usernames...
> anti-authority ("the rules don't apply to me")

Of course in Aviation the 'authorities' are usually rational and fair. In many other areas of life they are neither, and are incompetent to boot. Being anti-authority is justified in such cases. i.e. there is a moral responsibility to disobey unjust laws.
If you read notalwaysright.com, there are a lot of stories along the following lines:

- Rude and idiotic customer: <abuse abuse rant rant nonsensical demand nonsensical demand>

- Retail worker: I do apologize, but ...

This kind of excessive or unnecessary apology, even when the apologee is clearly the party who is in the wrong, is a distinctive feature of stories from the US, and while not unknown here is certainly very jarring to British and I suspect many other cultures' expectations. My (admittedly highly anecdotal) proposition is that it is a mutated form of politeness that is baked very strongly into specifically American social discourse, and, since human output from that nation forms a large proportion of GPT's training language, it has made its way into the language model.
If NixOS were the standard distro everyone used, then I'd agree, packaging would be easy. But constant breaking changes that devs like to make complicate matters.

The stuff that's not already packaged tends to have 50 dependencies that aren't packaged, and need a version of Node that isn't packaged yet, etc.

For existing stuff, people are probably afraid the current maintainer is gonna do a better job than them, they don't want to mess something up, since breaking changes filter in from every package.

Android solves this by putting stuff in the os itself maintained by paid people, and not doing package management like Linux.

Nix solves it by making it easy to package stuff and allowing multiple versions. You can go from never used Nix to writing packages in hours to days.

Other distros put much more work on humans.
Zeek: An Open Source Network Security Monitoring Tool
This seems impractical, it's likely that the data is highly redundant and you'd probably do just as well by just picking a random projection to a much smaller subspace (or simply just perform a random subsampling of the dimensions, or sum dimensions together, stuff like that) rather than spending the compute to learn a projection via SVD or some such. Hubness might be a significant problem as well and lead to search results not matching your intent. Also, numeric problems (e.g., if you were accumulating distance in floating point) would become an issue as well with millions of dimensions unless the way that distances are summed get special treatment (like Kahan summation, or reduction trees to sum values of roughly equal expected magnitude, etc) too; x += dist[i] won't cut it.

Any kind of acceleration technique to limit the search to a subset of the database (such as cell-probe-ish methods like LSH or IVF, or graph-based methods, etc) would take a ton of time to compute. Simply storing all the data you need for search, even brute force, would rapidly explode, not to mention the compute required.

Most cases with such large vectors I've seen begin with highly sparse vectors. Certainly Faiss (I wrote the GPU side of Faiss), Annoy, or most any similarity search libraries out there are geared to dense vectors in the 20 - 2000ish dimension range (beyond the number of dimensions where exact methods such as BSP or k-D trees work well as in "high" dimensions your nearest neighbor is highly likely to lie on either side of a dividing hyperplane, but below cases where simply storing the data uncompressed / unquantized / etc is hard and the amount of compute is prohibitive as well).

How big is the data set (number of vectors) that you are searching among, and are you performing single queries or batch queries?
A Small Modular Reactor for Commercial Marine Propulsion
What they have produced is clearly not LK-99.

They write that:
"
As shown in Figure 9, the x-ray diffraction spectrum of the
ground powder of the finally sintered product is highly consistent with the x-ray diffraction
spectrum reported by Lee et al.[3] and coincides well with the diffraction pattern of the apatite.
This proves that we have successfully synthesized the modified lead-apatite as Lee et al.[3.4]
"

(First off, you need to pay to the spectrum swear jar. an XRD pattern is a pattern, not a spectrum, it resolves space, not energy.)

But looking at figure 9 shows that the material is not the same.
They are missing a peak at ~17.5 degrees, and have an extra one around 25 degrees.

Further, all the peaks seem to be shifted about the same amount from the LK-99 structure, as the LK-99 is from pure lead-apatite.
This indicates that they have an even smaller unit cell. So if the .5% compression in the original LK-99 paper is correct, there could easily be an overcompression present in this article.

All the XRD pattern tells you is that they produced something wrong, an that it did not superconduct.

It makes it impressive how pure the phase was in the original LK-99 paper.

I will however say that there are some problems with the XRD pattern in the original paper too:
They did not write which energy the XRD was measured at, one would then guess that it is Cu-Ka, but who knows.
Under any circumstances, a peak should not be missing completely from a powder measurement (if it was a pellet, it could be missing due to orientation effects)
Twitter rival Bluesky’s first major crisis
Propaganda has never been cheaper.

The Matrix seems to become a documentary. /s
About 7 years ago I was in a meeting with a former Windows core graphics engineer.

My team was attempting to figure out some extremely obtuse workflows with MediaFountain and DirectX.

We had a meeting with this guy and a couple of the other engineers that wrote the APIs and the implementation underneath.

This particular guy literally chuckled as we aired our frustrations and this was his response:

“Yeah you won’t figure those APIs out from the documentation. It was on purpose. You have to go buy the book.”

Proceeded to explain to me that this was how he, and many other core Windows engineers lined their pockets for years - write complex implementations, do the absolute bare minimum documentation, then take a 6 month sabbatical and publish a reference book that was absolutely required to actually use the API.

Apparently many of these guys made 10-20x their salaries on this grift and it didn’t really stop until the mid 2000’s.
Basically most investors are herd animals. Right now the narrative in SV is that big companies will take all the gains.

We are following normal trajectories here - we are in the skeuromorphic phase where we adapt things form one system to another - X, but with AI. Think early iphone - tape recorder , notebook, compass. Those phases tend to benefit agile incumbents with tech companies generally are.

Next comes the phase where we make use of the technology in a native way, new products, etc.

That’s where you ought to be investing.

The second issue is that the user interface is captured by rent seeking incumbents. Many investors want to be that and are disappointed by anything that doesn’t open that opportunity. Crypto had it for them because you’d cut out the bank incumbents. AI is gonna live on platforms we already choose, so not as exciting.
https://archive.is/CkMWT
Same for me, I am prescribed medical cannabis for neuropathic pain and by default they gave me 18% THC.
After a year of getting more and more anxious and panic I did some research and ecided to try 5% THC with 10% CBD, this is much better. No more couch lock, better sleep, more productive and waayyy less anxiety. Same if not better effect on pain.
Jenson could write one of the clouds a license to use 4090s in a DC and make this crunch disappear overnight (would be rough for gamers though)