skysight-inc/HackerNews huggingface dataset:
And the problem is?

Copyright was created as a response to the printing press being able to copy and distribute. However, with the advent of AI, this may no longer be effective. But to use existing copyright laws to control the output of an AI is wrong. May be new laws are needed. Until then, i dont think copyright infringement apply to the output of an AI if the output would not already infringe copyright had it been done by a human.
imagine trying to sell redit coins because "they dont go away". :'(
They don't try to take information assurance seriously?

Are projects like SELinux[1], SE for Android[2], or the STM/PE[3] serious enough?

[1]: "Retrospective: 26 Years of Flexible MAC" https://www.youtube.com/watch?v=AKWFbxbsU3o

[2]: https://selinuxproject.org/page/SEforAndroid

[3]: https://www.cyberscoop.com/nsa-firmware-open-source-coreboot...
The solution is to use something closer to a compile-time SQL or DSL, such as jOOQ or SqlAlchemy (sans the ORM pieces). These are terrific technologies that improve upon SQLs weaknesses and achieve some level of portability.
> A better question would be, why do you think you did not succeed.

Is that a different question than "why you failed?" from the GP?
Not all of it, but I'm sure most statements follow some kind of CRUD pattern.

Getting that out of the way is exactly what an ORM can help with.
The thang is, what is an object in the context of the relational model has been generally grossly misunderstood. For a detailed analysis, see C. J. Date’s The Third Manifesto.
As more people move to city cores from rural areas... I think computers are becoming the next generations 'car', in terms of an object to soup up with new parts.
I'm trying to pick up FeathersJS right now and I will tell you it is hard to find ANY examples of complex queries translated to the ORM's logic. I can find bits and pieces but without any sense of the underlying purpose.

There are 500 tutorials of installing Feathers and making a CRUD app, but something as simple as combining results from two requests or doing a raw DB request seems to exist only deep in the docs (and more often than not, requires bonus functionality from an add-on).

I am familiar with managing databases and I can see benefits of ORMs, but I feel like "glue" technologies could benefit from deeper real-world examples that move beyond day 1 tutorials and get into translating existing code to their style. Half the time I am left digging through outdated github code to grasp the basics of how and where mid-level functionality can be used.
They will come.

In a the world of music equipment (synths in particular), it went like this:

--70s: twisty knobs and flicky switches.

--80s: We got CPU's now! Forget knobs, we got button arrays now.

--90s: We got LCDs now! Forget buttons, here's one rotary control and menus on menus.

--00s: If you pay us a lot, your menus will be on a touchscreen! Neat? No?

.....No?

:(

--10's: twisty knobs and flicky switches.

Walk into Guitar Center synth section, it's all about spaceship-kind of controls (one physical component for one parameter, and tons of blinkenlights).

It turned out (suprise!) that all those menu-driven controls are cheaper and easier to make, but were not what the users needed nor enjoyed.

These days, it's all about the analog equipment having digital control with a physical, tactile user interface (and no menus except for some niche parameters).

It really looks like cars are following the same path.
Have you checked out MyBatis or JOOQ? They sound pretty much like what you're describing.
That's a very odd measure. That would put driving the car at 15mph getting 20mpg as better than 30mph getting 30mpg.
God bless him. He wrote extensively and very concisely on the topic. He was struck by a car last year and killed. He left behind a wife and many children.
A dead simple tutorial on how to forward Rsyslog messages to a file
I'm not sure what you mean about Merge being non-sequential. All Merge does is take two elements α and β, then return a binary branching structure with α as the head, like so:

{α, β}

Both α and β can be either some atomic unit, eg a word or a morpheme, or the previous output of Merge (a tree).

This is their first example as rendered as cons:

(cons I (cons drink wine))

As merge:

{ I, { drink, wine } }

As a tree:

Edit: I can't get the tree to look even remotely correct in HN formatting, but you get the idea. It's in the article.
They've been explicit about their motivations in this regard (claiming innocence). Then they backtracked when convenient (surprise!), but in a way that still broke AMD processors. See here: https://www.agner.org/optimize/blog/read.php?i=49#49

By the way, it's interesting to note that Intel has a disclaimer on every MKL documentation page about this; my speculation: this was required by terms of a settlement.

From the above link:

>The Intel CPU dispatcher does not only check the vendor ID string and the instruction sets supported. It also checks for specific processor models. In fact, it will fail to recognize future Intel processors with a family number different from 6. When I mentioned this to the Intel engineers they replied:

> > You mentioned we will not support future Intel processors with non-'6' family designations without a compiler update. Yes, that is correct and intentional. Our compiler produces code which we have high confidence will continue to run in the future. This has the effect of not assuming anything about future Intel or AMD or other processors. You have noted we could be more aggressive. We believe that would not be wise for our customers, who want a level of security that their code (built with our compiler) will continue to run far into the future. Your suggested methods, while they may sound reasonable, are not conservative enough for our highly optimizing compiler. Our experience steers us to issue code conservatively, and update the compiler when we have had a chance to verify functionality with new Intel and new AMD processors. That means there is a lag sometime in our production release support for new processors.

> In other words, they claim that they are optimizing for specific processor models rather than for specific instruction sets. If true, this gives Intel an argument for not supporting AMD processors properly. But it also means that all software developers who use an Intel compiler have to recompile their code and distribute new versions to their customers every time a new Intel processor appears on the market. Now, this was three years ago. What happens if I try to run a program compiled with an old version of Intel's compiler on the newest Intel processors? You guessed it: It still runs the optimal code path. But the reason is more difficult to guess: Intel have manipulated the CPUID family numbers on new processors in such a way that they appear as known models to older Intel software. I have described the technical details elsewhere.
Ya I’ve heard this one a lot. It’s kind of funny to say and does humorously underline the complexity of the problem but people take it seriously. So to take it seriously for a second:

There was no good reason to be in Vietnam; even taking the stated rationale as a given, which many people did not, it was a concern many levels removed from the actual safety or functioning of American society.

ORMs in contrast achieve much more proximate goals — they solve a real problem and can measurably reduce the amount of code you have to write. It is tedious to write the same sort of SQL query over and over. Even if you prefer to use literal sql for the complex stuff (as I do), ORMs tend to be a significant win (in fewer LOC to write) on abstracting out basic queries.
IMO the difference here is like comparing early versions of blackberry around 2008 that tried to compete with the iPhone. They were really bad too...
Just 2 weeks on the couch starts to damage your body
Oh, they requisition budget for the IAD mission, and they use it on IAD things. In reality, the most important thing NSA does is get budget allocated to itself! But does anyone believe that in a conflict between IAD and CNO/SIGINT, IAD has ever won?
Used physical copies degrade and are an objectively inferior offering to new copies.

Digital copies don't degrade unless artificially made to do so. The copies can be traded for infinity without ever degrading or lessening in value. Which essentially mean that with time the demand for any game would be vastly outnumbered by the supply of cheap "used" copies that never ever degrade.

It would be very hurtful to indies since they will be the first ones to have their games dumped on the market, even if they're good.
I said it once, I'll say it forever: ORMs are people who don't know SQL.
I really like this! I particularly like that it is oriented around a useful workflow, rather than for just "small code at rest".

It looks like it parses the schema to find type information (2 minute skim, so please forgive me if I got it wrong!) Hoe does it handle schema changes?
You can buy touch screen friendly gloves... I always keep a pair in my car... nice thing about an electric car is you pre-heat without burning gas and being generally evil to the environment:)
Beginning programmer: ORMs let me write code without learning SQL!

Intermediate programmer: ORMs just get in the way! SQL isn't that hard after all.

Advanced programmer: I write a lot of SQL, but I use ORMs to cut out most of the boilerplate.
an analogy is not about comparing, it's about communicating an idea.

pointing out that the comparison is not perfect does not invalidate or refute anything. Every analogy, by definition, is not perfect. If the analogy were to ever become perfect, it would stop being an analogy and would instead be a tautology.

"an ORM is like an ORM".

IOW, the differences are WHY analogies are useful.
Top Paying Companies from 2018
I think a non-trivial part of why deadlines are always wrong is something akin to the Coastline Paradox [1], where the closer you are to something, the more details there are.

At some point you have to just say, "Fuck it. It's good enough" and leave it as the terrible flawed pile of crap it looks like at the detail level you're at.

Often once you step back and look at it from a customer perspective, you had just gone in too deep and they didn't need half of what you were preparing for anyway.

[1] https://en.wikipedia.org/wiki/Coastline_paradox
TL;DR: industry momentum

I've read this elsewhere on HN, basically it boils down to having great tech doesn't mean everyone drops all their existing Intel tooling or Intel-optimized source code. If you care a lot about performance, then you'll care about those things. For everyone else, they just want a reasonably priced processor, and most PC manufacturers have large contracts to get those CPUs at a good enough price from Intel to also not want to switch all their motherboards and factory setups and driver in order.
or for that matter, imagine trying to sell Angry Birds off your iPhone to someone else. Madness.
I'd prefer to live in a world where the government doesn't run my life and where I don't have to constantly watch my back (both literally and financially). Neither of those is freedom.

Now, you may be tempted to say "Sure, and you'd like a pony, too". But in fact, there are societies that are much less fraud-prone. Ravi Zacharias talked about going to a dairy in Holland, and being surprised that you could just walk in, take milk, and leave money in a bowl. There was nobody there to watch you. He said that in India, there would have to be somebody there to watch customers, or they would steal the milk. He told this to a man from Egypt, who replied that in Egypt, they would steal the cows.

A society full of people who are looking to steal is an objectively worse society to live in than one with people who are not looking to steal. The trick is, how do you create such a society when you don't have one (without a heavy-handed government)?
It wouldn’t take a whole decade to count. Just hire more people. A census’s cost is proportionate to the population.
My "toy" project with several hundred tables and tens of thousands of users does fine.

I have, at most, a couple dozen "complex" queries in this project.

Whereas I have an order of magnitude more queries that need to be composed from several different query criteria, a task for which SQL is very poorly optimized for and most ORMs excel at.

I have used my ORM for so long that writing a report in SQL or the ORM language is basically the same to me. Neither technology is something I would consider to be "hard", as most of the problems encountered in practice are well-trodden.

Nontheless, a simple ORM query is 20% the length of an equivalent SQL query. And I can compose them trivially. And then I use the model code for the _hard_ part: dealing with the rest of the business logic for template rendering, email sending, API interactions, and so on, for which SQL is completely useless.
This is super cool, what are good ways to distinguish between using a different color vs just changing opacity of a primary color?
ORMs look like sonething that violates Occam s razor
OMG YES, I LOVEE Ecto!.

it lets you create beautiful sql like declarations

```
payment_types = from(s in Ecto.assoc(order_cycle, :splits))
|> join(:left, [s], p in assoc(s, :payments))
|> select([s, p], %{
type: p.type,
card_type: p.card_type
})
|> Repo.all()
```

its the first database library that makes queries easy to compose together. On top of that transactions are a snap to put together thanks to Ecto.Multi
What I mean by concurrent display code is the display of the pdf file is always up-to-date even when the renderer cannot display the data fast enough.

The trick is to abandon the current render whenever the position in the file changes, and start a new render.

I did this back in the 1970's (!) when I designed and built a 24x80 glass terminal. The 6800 microprocessor simply could not keep up with 9600 baud serial data coming in. So what I did was hook an interrupt handler to the serial port, which stored the incoming characters into a 24*80 circular buffer.

The display renderer would start at the beginning of the circular buffer, writing characters to the display buffer. If more characters entered the circular buffer which would invalidate the display, the renderer would simply start over.

Whenever the data coming in paused slightly, the display would catch up almost faster than you could see.

It worked great!

I since incorporated the same idea into the MicroEmacs text editor in the 1980s, meaning the editor display was always crisp and responsive despite running on an 8088. (Other editors would fall behind, and when you took your finger off the auto-repeat page-down key they'd eventually catch up. This behavior is what most PDF readers exhibit.)
"...They are an acceptable way to represent a data definition, but a poor way to write queries and a bad way to store object state." Rails perspective: Pump your brakes there, friend. This claim depends completely on your application's needs. I write web apps for research that don't need to scale and don't need lighting performance. I have built apps that ended up needing some optimized-SQL-versus-ActiveRecord experimentation, and sometimes, writing raw queries is certainly worth it. AR has been evolving for 15 years, is extremely useful, and all that is needed for many use cases. We're not all trying to do the same thing.
Is AVX512 really an advantage though?

Intel is infamous for severely downclocking the processor for these and other AVX/SSE family instructions, to a point where sometimes using them makes the program slower than it would be otherwise, especially if you're constantly provoking frequency switches between them and regular instructions.

AMD might not have implemented AVX512 specifically yet (there's nothing legally keeping them from doing so however, they have patent sharing agreements with Intel regarding the entire x86/x64 ISA and extensions), but what they currently DO have is all common SIMD extensions implemented (up to SSE4 and AVX2 if I'm not mistaken) without incurring any frequency penalties on clock speeds for using them.

I can live without AVX512 for now, even though I'd be happier to have it. But I would really rather not have it if it came out in the same crap implementation that Intel has.
Anonymous DNA Sequencing from Nebula Genomics
They can, what I'm saying is that a single application doesn't scale well over multiple cores. Multiple instances on a single cpu generally works fine, but the biggest impact on performance is per core speed.

Edit: I was really just responding to "who spends $15,000 on a mid-high end server to run single threaded applications anyway?". I would absolutely consider this a "single threaded application".
> Everything they said about the BMC was plausible.

Not just plausible; something not altogether dissimilar was documented to have been happening by the Snowden documents back in 2014: https://www.engadget.com/2014/05/16/nsa-bugged-cisco-routers...

I'm good with Bloomberg being expected to do a better job covering this activity than they have. And, without further evidence that it's actually happening, I can't quite take the step into believing that it's probably happening, because that way lies tin foil hats.

But for all the security researchers that straight up claim that what Bloomberg reported was impossible, I wonder what their opinion would have been about reports that the NSA was bugging routing and server hardware in transit before 2014?
This is completely false. The joins I do in the ORM are completely transparent to me as a developer and there is no mismatch whatsoever. The data layout and data migrations are well described.

And I have, at most, a half dozen difficult queries which require serious optimization, and that optimization isn't defined by the query but by the indexing and storage strategy for the tables in question.
In ‘The Language Instinct,’ it's explained why Chomskian mental grammar is likely to be universal, despite isolated counter-examples: pidgin dialects have crappy grammar and are bad at recursion, but children who begin by learning a pidgin from adults, soon develop it into a creole with full-fledged grammar that has all expected features. This happens even when the children speak no other language, e.g. deaf children who learned pieces of a sign language from hearing adults.
Since 2014 we've gotten new tools to play with.

For example, Ecto isn't technically an ORM but it lets you do ORM-like things. It's Elixr's data mapping and query language tool. It happens to be one of the nicest "I need to work with data" abstractions I've ever used.

It's a bit more typing than ActiveRecord and even SQLAlchemy, but you feel like you're at a good level of abstraction. It's high enough that you're quite productive but it's low enough that it doesn't feel like a black box.

You get nice benefits of higher level ORMs too such as being able to compose queries, so you can design some pretty compact and readable looking functions, such as:

def eligible_discounts(package_id, code) do
__MODULE__
|> for_package(package_id)
|> with_discount()
|> active()
|> usage_count_less_than_usage_limit()
|> after_starts_at()
|> before_ends_at()
|> maybe_code(code)
end

Each of those function calls is just a tiny bite sized query and in the end it all gets composed into 1 DB query that gets executed.

I think Ecto's biggest win was having the idea of changesets, schemas and repos as separate things. It really gives you the best of everything. A way to ensure your data is validated but also flexible enough where you can separate your UI / forms from your underlying database schema. You can even choose not to use a database backend but still leverage other pieces of Ecto like its changesets and schemas, allowing you to do validate and make UIs from any structured data and then plug in / out your data backend (in memory structs or a real DB, etc.).
Your problem is that absolutely anything can be explained by a conspiracy.

This case was a few guys writing software in their free time - 100% likely it was an honest mistake. See https://www.buzzfeed.com/chrisstokelwalker/the-internet-is-b...
At least you get six weeks to move to a different "cloud".

The mean life of cloud services seems be under five years.
> you automatically invalidate one of ORMs biggest selling points which is being SQL-database agnostic

1. If the suggested alternative is writing only SQL from the get-go, then why would one even care about database agnosticism?

2. A large part of SQL is compatible between databases, so this might be a non-issue.

3. You can always use specific in-database abstractions such as Views and Stored Procedures for those complicated bits.
When You Electronically Sign Documents, Always Keep a Copy
Uber Sues NYC Taxi Authority over ‘Arbitrary’ Congestion Rule
Anyone know whether it's 30x WGS? Doesn't specify on their website
What makes you think that the DB will always by the dominant data store for a business object?

Business objects need a lot more, from rendering, processing, email sending, notifications, etc.

All those things are well approximated by an object and poorly approximated by SQL.
A data mapper is not an ORM, it's a data mapper. It's a different access pattern.

But I do agree that data mappers tend to be better.
> I don't. I use sqlite for unit and local integration testing, and aurora-mysql for production.

That's a recipe for tests that don't catch edge cases.
This article was one sided. It never seriously considered the relative value of almonds, particularly when roasted and salted. Sad.
query builders are useful for building queries dynamically.
we'll find that out once it is correctly priced with a carbon tax
EVs will not be affordable for the masses even if they are able to get under $20k since home ownership is still effectively a prerequisite for owning an EV right now.
I am sure the Babylonians thought tablets to be superior to papyrus.
let's grow them where no water is sustainably available...
Sad that the patent system has been so corrupted that obvious UI designs are patented and defensible in court. From the descriptions of a couple of the patents these don’t describe intellectual property, that an inventor worked hard to discover. Rather they are legalese tricks that make obvious improvements that belong in intellectual commons, appear to belong to a single entity. IBM is behaving like an enterprise parasite.
I think that's reasonable -- but also the reverse is reasonable. "Company decides to continue working with US government" should not be news.
Apple isn’t anti-advertising or pro-advertising, but it is pro-privacy. iAds failed because Apple refused to allow invasive tracking.
You're missing the larger context. ICE's are on their way out due to climate change and the rapidly dropping prices of li-ion batteries. In the last year big auto companies have woken up to this fact and are rushing as fast as they to get into EV's. This announcement by Daimler is just one of many recent developments all moving in the same direction.
The looks a lot better than the utterly stupid climate control interface on my Prius.
I Buy Kegs for the Office. Do I Have to Buy Tampons, Too?