skysight-inc/HackerNews huggingface dataset:
Yeah, 1) seems to be much more cost effective. Building the equipment on off-the-shelf hardware and software could potentially reduce the costs quite a lot, and there's no reason all the stuff around the lander shouldn't be able to communicate over standard TCP/IP instead of some proprietary protocol.
> ORMs are very leaky abstractions

I think this is where a lot of the anti-ORM crowd trip up. They start with the idea that an ORM completely abstracts away a database, show that isn't true, and then condemn ORMs. But ORMs don't do that, aren't advertised as doing that, and aren't useless because they don't do that.
Well, consider Slack as an example.

Performance-wise, it's bottom of the barrel quality. A single developer has done, in this compartment (Ripcord), much better than their team did. If we want to consider similar languages, Microsoft did enormously better with VSC.

The result is, sadly, that Slack is still widely used.
But the inherent problem is still the inability to deal with dependencies in a standard and portable way. As you said - pkg-config is standard on POSIX, but the world is bigger than this.
On the other hand, one of the highly specialized stored procedure I wrote in PostgreSQL have being successfully and flawlessly re-used/tested on multiple out-of shelf clients app (BI related all developed in different languages) simply because they all support SQL.

I agree this only apply for data-model related functions. But this has proven really low maintenance, and improvements of this "API" are automatically available in all clients.

I'd bet that accessing this stored procedure through an ORM raw SQL query would provide more benefit than rewriting it from scratch in ORM's language.

PS: Also yeah people do write unit test for SQL (never enough but that's another story).
https://pgtap.org/
Thank you for the summarisation. Does the article give any examples of such arguments, or is it something stated as a commonly known fact? Coming from an artificial intelligence background I am not aware of such opinions. I know that deep neural nets were considered difficult to train until the re-discovery of backpropagation, but not because of anything to do with the shape of the error function.

However, as usual there is confusion about what "generalisation" means. For example, I was in a summer school at Oxford a couple of years ago and one of the lectures made a similar point, about the surprising generalisation ability of deep neural nets. I approached the lecturer after the lecture and asked what they meant because the way I knew it, neural nets can't generalise, and they explained that they meant that they generalise surprisingly well on the test set but not on unseen data, or out-of-distribution data, i.e. not on any data that was not available to the researcher during training (as training, validation or test set).

In other words, neural nets are great at "generalisation" in the sense of interpolation, but are almost completely incapable of "generalisation" in the form of extrapolation.

I like to quote Francois Chollet of Keras on this:

This stands in sharp contrast with what deep nets do, which I would call "local generalization": the mapping from inputs to outputs performed by deep nets quickly stops making sense if new inputs differ even slightly from what they saw at training time. Consider, for instance, the problem of learning the appropriate launch parameters to get a rocket to land on the moon. If you were to use a deep net for this task, whether training using supervised learning or reinforcement learning, you would need to feed it with thousands or even millions of launch trials, i.e. you would need to expose it to a dense sampling of the input space, in order to learn a reliable mapping from input space to output space. By contrast, humans can use their power of abstraction to come up with physical models—rocket science—and derive an exact solution that will get the rocket on the moon in just one or few trials. Similarly, if you developed a deep net controlling a human body, and wanted it to learn to safely navigate a city without getting hit by cars, the net would have to die many thousands of times in various situations until it could infer that cars and dangerous, and develop appropriate avoidance behaviors. Dropped into a new city, the net would have to relearn most of what it knows. On the other hand, humans are able to learn safe behaviors without having to die even once—again, thanks to their power of abstract modeling of hypothetical situations.

https://blog.keras.io/the-limitations-of-deep-learning.html

In short, if the point of the article is that neural networks "work" because they generalise in the sense of extrapolation, then that's not right.
The two are not mutually exclusive. Dapper provides types safety cleanly and imo is more readable than ef. Ef is heavy, requires trading to understand and is a giant pain if you need to implement performant sql.
The more I work in and watch the ML/AI space, the more I’m convinced the better approach is similar to what you describe: “augmentation” of humans’ abilities and skills rather than replacement of them.

Using advanced AI, or even a bunch of semi-decent models to condense information, highlight things humans might miss, enrich with predictions, etc so that humans don’t have to spend as much time wading through data themselves to try and extract meaning and can instead jump straight to more informed decision making seems like a better approach to me than “lol can we make a neural net that does lawyer things?”
I do wonder how many projects actually have const and let in their production code, vs. how many are writing them, but still compiling their code down to ES5.
Rails with Arel is really special, the queries it creates are really impressive coming out of an ORM. I would be curious to hear an updated version of this critique which focuses on Arel.

Now of course learning SQL is still a good thing to do, but for some a good ORM can be a way of doing that
Social media customer service: how to make it great
Social media are a great tool for business, but also to keep in touch with customers! Social media customer service means using social media to provide the best customer care and create a relationship with your customers, and it can be revolutionary.
AMD's Radeon “Big Navi” RDNA 2 GPU Lineup Leaks – RX 6900 XT RX 6800 XT and More
Everybody and their uncle have an idea about how they would "fix C++" - but these ideas mostly contradict each other and would make for rather different languages :-)
Came here to say exactly this. Also a gopher, who is also vaguely horrified at all the "use GORM, and a framework" advice to newbie gophers.

I also use stored procedures, and treat them as function calls from my application code. So I effectively build a "data storage API" in the database, that I then call (as you say, like any other service) from my code.

I also have views for all the data sets that will be returned to the application, so I can use them easily as a type for function returns, and enforce consistency.
Not having consistent rules about what code belongs where is a people problem, not a technology problem. In order to write maintainable software, you always need proper code classification, regardless if you use stored procedures or not.
I'm an advocate of lightweight ORMs, in C# world, I've used Dapper a lot, and now using RepoDB. Lightweight means I can easily craft SQL and quickly map it to types, and things like CRUD on simple entities is very straightforward. But I generally agree with learning SQL, and avoid mapping it to types if you are just going to pipe into json for the front end. SQL is good for query and projecting data into new forms, complete waste going through a type if not needed
I understand the usefulness of an ORM and how much its use can clean up a codebase but... truly performant queries (that take advantage of every aspect of your DB not just some vanilla lowest common denominator provided by an ORM abstraction) are done in SQL. In the end one has to make the tradeoffs between development speed (something an ORM has going for it) and performance and the eventual issue of having to handle the object impedence mismatch. For me it's just so much more clear to read a handful of queries and see how things work. You can even create user defined functions and call them like an API from your codebase (a sort of ORM) and get the best of both worlds. It's not a easy choice to ORM or not but SQL should be a skill everyone learns.
David Attenborough: A Life on Our Planet – Official Trailer
One of the great things about Rust is you can write platform-specific code for each platform and then package it all up into one interface so anyone can trivially use it. They get the simplicity of one interface and the performance of platform-specific code.

Though I haven't used it personally, it seems like the trust-dns project is one such example:

https://github.com/bluejekyll/trust-dns
Still going strong at 93 of age!
>Condor plans to spend one year in the development of Diablo. Personnel will consist of: one designer, one chief programmer and two junior programmer; two art director/artists, one illustrator/sculptor and three pixel artist/illustrators; and one music/sound effects person.

Wonder if that worked out.
You could use a query builder for this, rather than a full ORM. Programmatically generating SQL is a subset of what an ORM does, and it's one of the less contentious parts.
> is that you can't hit that specific pitfall of forcing layout interspersed with DOM or style manipulation.

This isn't true though, useLayoutEffects that perform a read/write littered through your code is going to quite easily induce layout thrashing and there's no way of splitting this throughout a tree
>> Any stored proc codebase is guranteed over time to become a maze of complexity and footguns.

I think this is a very valuable and important point and wanted to highlight it.

>> Any stored proc codebase is guranteed over time to become a maze of complexity and footguns.

There's no absolute law that states that SP using environments will always end up as a mess, but there should be such a law, because they do!

I've worked across dozens to hundreds of enterprise environments, and the pattern is clear.

I suppose it comes from personality and culture with the people working on db coding more often in the 'get it done' end of the spectrum vs programmers where you find a significant number interested in 'get it right'.

An even stronger reason is probably that db coders are more likely to be autonomous instead of in large centrally driven teams. That central hierarchical organisation is a necessary but not sufficient condition for working to tame the entropy of large complex systems, without which they evolve into "a maze of complexity and footguns".
There are built-in solutions but also quite severe limitations when you get to advanced usage of activerecord. Especially with regards to composability. Of course, raw SQL is also really bad in that scenario.
Used it since my employer rolled out Palo Alto in March. Zero problems and it was really easy to setup.
> a whole range of instruments going from

I know but I simply didn't have the vocabulary to distinguish them by name or type, so emphasised their common size and appearance. Thanks for the comprhensive answer, and never even heard of Morphine, ta for that!
4G hardware is mature and fairly reliable at this point. There's probably 5G base equipment that would work too, but the client hardware is probably also an issue.

4G speeds ought to be more than enough for a lot of traffic -- it's not that the astrounauts will be streaming movies off Netflix when they're outside or anything.
This is so true. It is always Windows people trying to bend libraries to make them easy to "install" for them. On Unix installing libraries system-wide was never too much of a hassle, and now with Nix you can have reproducible distinct development environments for each project. I hate that sadly a lot of the projects I work on must also work on Windows, but I'd just hire a Windows person simply to deal with their build system stuff.
Saw the title, searched the comments for jOOQ.

jOOQ needs to be mentioned in this context. With jOOQ you basically write Java-SQL-DSL, and with some code generation from your schema you have really neat type safety (and code completion).

String SQL queries are not the answer to ORMs, imho, we need a level in between. jOOQ provides a really cool set of features in that space.
They required every graphics stack to add support for color fonts. And because new emoji compositions are invented every year, it's common to see uncomposed glitches like <facepalming woman><male gender marker> or <thumbs up><white skin color marker> on all sorts of semi-smart devices.

In my opinion Unicode went from a slow-moving standard that carefully absorbed the world's languages, to a pop culture product that serves to make old software obsolete even faster.
Hum, I think this person is missing the other side. It isn't that discipline will save you, it is that some programmers want power and control, and don't like restrictions. Those programmers do sometimes believe they know better, or just prefer and enjoy the creativity given to them. Thus any language that restricts you isn't something they favour.
TLDR: Humans make mistakes, use better tools/languages that prevent this, since discipline can't enforced.

Wasted few minutes reading this blog post.
Show HN: Free 3D Avatars for the Community
I think the assumption is that nginx is your frontend server / load balancer, so all external requests go through it.
I guarantee that companies (at least large companies) do reconcile hiring decisions with performance review data. Google, at least, has entire teams of analysts focused on exactly this sort of analysis.

Fundamentally, hiring is simply not an easy problem. There's a small cohort of candidates who can be reasonably confident will perform well in a job (mostly people who have performed a similar job at a competitor) that everyone competes over and a marge larger group of candidates whose possible performance is very hard to judge.
> society has not even come close to collapse

> change diets slightly to account for the lack of constant refrigeration

Maybe I have unreasonably high expectations of civilised society compared to you. What country, and what is the longest (contiguous) period your area has gone without power?

I'm just doing rough estimates, but after ~72 hours any food that needs refrigeration is at risk, mobile phone networks are gone and electronic transactions are gone. That is a pretty crippling level of stress on a modern first world nation.
I use a Docker instance for localhost development, so much easier.

There are so many problems that can occur in that communication to the database, it's invaluable to test it
My assumption would be that this can be easily solved by a bot in 2020 or am I missing something? Especially because every time I got the galaxy captcha so far, they always asked for the spiral one.
Now you need three experts, one in the domain, one for automation and an engineer. But only the engineer will be needed in production.
It would blow your mind if you saw how much slower querySelector is compared to old school getElementByid, getElementsByClassName etc.

We tend to think that newer is better and faster, but it's also wise to think that old apis had to be fast on old hardware. Hardware that is not the target of new APIs.
> I view move semantics as not a memory safety thing at all (in fact, use-after-move can be exactly as ugly as use-after-delete),

Note that move-destructors were also considered for C++11, and were not added for lack of time / implementation experience . And this is really too bad, because they are at least as important as move constructors if not more so; I've yet to encounter a case where you actually want to use a moved-from object after the move.
well, most ORMs give you the ability to drill down into native queries if you want, and often even will help you with the conversion into native objects if what you are pulling back is still a native object. So it's not a binary thing, you can use ORMs to reduce the amount of boilerplate for simple queries and then where it makes sense you can drill down into native SQL.

(a lot of what ORMs give you is just a reduction in boilerplate code, manually populating 30 different fields on an object and so on.)
This is the approach I like as well, with the caveat that the stores procedures themselves should be kept as dumb and as late in the process as possible.

I have made many mistakes in my career in terms of systems that were either overly complicated or inefficient or both, and it has almost always ended up boiling down to either trusting the SQL that an ORM produces, or putting too much of the business logic in hand crafted stored procedures. I have done both, regretted both, and nowadays advocate for sticking to simple, predictable, and dumb stored procedures so that you can both have the benefit of knowing/controlling exactly what will execute in the database and having things like validation occur code side whenever possible.

In the real world, that simplification of stored procedures isn't always possible. But if it's your starting assumption, then you can fight for it until you are certain that there isn't a practical alternative to pushing the logic into the stored procedure. And if a compromise of these principles needs to happen, I would push complexity into a stored procedure before trusting the SQL produced by an ORM every time.

But where I fall on that spectrum may just be due to the severity and types of problems I have seen happen with each approach, do YMMV. And I wouldn't go so far as to call myself an expert, so also YMMV on that front. I am just a guy who has made a lot of mistakes. But if it'll help others, this is my takeaway.
Show HN: Lifetables – life tracker. Simple monitoring dashboard for the life
Just use a mature ORM where you can easily combine ORM capabilities and raw SQL, like Hibernate / Spring Data. There you can do raw-raw calls to the SQL driver, map your optimized by hand query to an object or let Hibernate fetch a whole graph of stuff by itself.

Use the right tool for the job.
> The harder part is now getting a computer that will take the firewire (you may have an old laptop -- macs had them until like 08 -- or get a firewire-to-usb2.0 cable or thunderbolt to firewire adapter on amazon)

Modern computers with thunderbolt will take a converted fw stream without any problem. I am using several old fw400 sound interfaces with a string of adapters without any problems, on both mac and pc. The mac laptop has tb built in, for my workstation pc (Windows 10) I bought a PCI Express io adapter for 30 euro. Works perfectly.

Sound interface -> fw400 -> fw800 -> tb -> tb3 -> mac|pc

YMMV with video, but I can't think of why it wouldn't work. I haven't tried a converter.
I agree, there are things that can and should be done to prevent crime.

But good prevention is really hard, education being a good example. Today most people have internet access and you can educate yourself there (Wikipedia, Khan Academy, YouTube...). Access to education is not a problem - getting people to educate themselves is. Nerds do it on their own, many don't. It takes individual effort to get children's minds to learn. You need teachers who like teaching and can get children excited about the world. It's not as easy as giving everyone an iPad, funding without understanding the problems doesn't work. (I guess there are situations where funding easily solves problems depending on your country and school.)

(I'm not against funding education, I just wish it would happen in a smarter way.)
Or use something lightweight and configurable like https://github.com/a8m/rql to just handle filters.
The development speed with ORM's is ridiculous fast and easy on the mind.

I do agree that for large, complex performant queries, ORMs might not work out, but I would say that those queries are better written as SQL procedures / functions because they are bound to be modified or changed anyway.

Having said that, most LOB apps, small apps, apps that have in-frequent access of the DB, etc, can benefit from using ORMs.
Thanks for the corrections, suggestions, and comments everyone!

@twic Thanks for the correction. Didn't know this wasn't a Hibernate but instead a Spring Data feature :-)

@watt You're right, I could've added an offset/limit. Wasn't the main point though (readability was).

@vitro Depends on the approach, but it won't be done /for you/, the mapping is a manual step (grab field X, etc.).

@piokoch, nice suggestion. Of course in the real world we work in teams and some people will prefer this ;-)
I think what he has experiences is something I have also seen a lot of times (and am still seeing in my current company):
Some developers put their application into SQL. That means, that the whole business logic of the app is SQL, and the app is just executing SQLs in order and does some front-ending.

But I don't suspect that is what the original author meant.
I'd hardly call for example firecracker a "pet project by mismanaged megacorp". It's running production workloads - and at AWS scale, I'm fairly certain it's running more work than most of us here ever touched in their career total. https://github.com/firecracker-microvm/firecracker

> And they at least have PEPs.

Rusts language development has been guided by RFCs since like the beginning. There's no comprehensive standard as in "somebody went and wrote down the current state", but it's also not the case that there's no written spec of how things should behave. You could base a new compiler on that and there's actually developments to have different backends to rustc. Cranelift for example https://github.com/bytecodealliance/wasmtime/blob/main/crane...

> "The Rust development team isn't interested in supporting your obscure embedded architecture" or "sorry, this platform was phased out due to technical debt" is what I mean by not serious.

So any compiler team that stops supporting some sort of architecture because it's either rare or no longer worth the effort is not serious in your opinion? Like GCC, that has a decision making matrix for that? https://gcc.gnu.org/backends.html And dropped various architectures along the way?
that's for instantly detected fraud clicks, OP is speaking about it being marked as fraud later.
> for (let elem : arr) { ... }

Do you mean:

for (let elem of arr) { ... }

Unless this is a joke about writing in Java & C++ (for which the colon syntax is valid) instead of javascript.
sorry, I don't get this at all. How is using stored procs instead of an ORM going to adversely affect your cache strategy?
I had to read the whole "storing comments in GitHub repos, triggering builds, etc." thing a few times. I feel like we've left the realm of what's reasonable here.
I absolutely will run Edge on Linux as soon as it's ready. It's the same Chrome but with a much stronger privacy promise from Microsoft.
That's quite a broad statement. Can you explain how you come to that conclusion?
how do you unit test your stored procedures on a CI agent?

serious question - this is nigh impossible in every db i've ever used.
Going from Hibernate to JOOQ for the DB managment has been the best change ever.

JOOQ is a wunderful SQL abstraction that is very nice to work with.

What I would really like is a Datomic style Database and have a JOOQ like Datalog, but I can't have everything at the moment.
Unmetered energy supplies in order to faster public charging network development
Typical unmetered equipment is street lights, traffic signals, illuminated signs and bollards but can also include telecommunication cabinets, CCTV, advertising displays and Electrical Vehicle charging. Thanks to the use of public space, the development of publicly accessible charging points has become much easier. An example from the British market is an interesting view on the implemented smart cities solutions.
NASA's Osiris-Rex spacecraft touches down on asteroid Bennu