skysight-inc/HackerNews huggingface dataset:
I've never even SEEN an Apple store let alone been in one. Looking on their site it looks like the nearest one is 90 miles away from me.
Every time TimescaleDB is brought up, I feel the need to point people to their shadily worded proprietary licence[0], and pg_partman[1].

Do the same benchmarks against a pg_partman managed partitioned db and you'll get the exact same performance. We do, at least - 150k or so metrics per second, 10 columns per metric.

Not trying to crap on the TimescaleDB guys, I've found a lot of their writeups extremely useful and can totally see how their commercially supported product fits. However, I like to see pg_partman at least mentioned somewhere in the article/comments. It's awesome and does the same job.

[0]https://github.com/timescale/timescaledb/blob/master/LICENSE

[1]https://github.com/pgpartman/pg_partman
If you're really interested, read the book Why We Sleep by Matthew Walker. The book references a ton of studies that show, definitively, getting less than 7 hours of sleep is hugely detrimental to your health.

The book actually talks about how psychiatric disorders cause insomnia which creates a feedback loop of getting less sleep, which amplifies the detrimental effects of the disorder, which in turn worsens the insomnia.
Oracle has some pretty beefy hardware. They can afford the cycles. ;)
Also keep in mind that often the existing application is the only real artifact you have capturing all of the complexity and corner cases your rewrite will have to deal with.
I don't understand this at all - what is it? You are right in your comments at the start of main.rs: it does scroll smoothly. But then what? All you apparently are able to do is open up - for viewing only - a bunch of source files.

I visited the GitHub page and after going through the _very long_ readme I still don't understand what this is. Best I can get to is that you're making a CAD program with Rust as a scripting language. Is that right?

I guess more concrete feedback would be, text doesn't render nicely (at least on Mac OS). No anti-aliasing.
> rewriting the Windows implementation using the library `wepoll`.

Interesting idea but I don’t like it too much. While removing the huge complexity of manually managing IOCP and required resources, It’s an undocumented API. New Vista+ threadpool-based IO also removes that complexity, removes complexity of implementing thread pools in the higher level in Tokyo. It’s documented and supported, and Rust has issues with WinXP support anyway.

> What would be the advantages of supporting AIO on Linux?

Faster async disk IO for the apps which are OK with the limitations, i.e. which read/write complete blocks of O_DIRECT files. Databases come to mind.

BTW, io_uring feature coming into Linux kernel removes most limitations of AIO while also improving performance.
I didn't realize, until recently, that satellite 6 is no longer based on spacewalk.
From the bibliography:

> In terms of benchmarks, I ran some numbers comparing io_uring to libaio
and spdk. The tldr is that io_uring is pretty close to spdk, in some
cases faster. Latencies over spdk are generally better. The areas where
we are still missing a bit of performance all lie in the block layer,
and I'll be working on that to close the gap some more.

From a status update in the article it looks like it's less than 2% slower than spdk now. Trading 2% throughput for lower latency sounds like a useful thing to me, as someone who gets judged by response times.
U.S. Officials Confirm Tariff Increase, Continuation of Talks
I can ignore "how to do #1" when discussing whether entropy is drained by using it or not.

You need to get 256 bits of high quality entropy. We assume there are ways to do that.

On a device that has no way to do that, you can't do crypto (unless you accept the entropy from outside, which is key escrow, but might be ok for an IoT device that communicates only to its mothership).
Does anyone know if this will affect uploads? We are getting an upload URL using s3.createPresignedPost and this returns (at least currently) a path-style url...
In this case, they mean invisible from earthquakes. The building's architecture resembles meta-materials which are used to make objects transparent to microwaves.
Visual Basic vs. Delphi for RAD/GUI programming comes to mind as well.
I'm co-chairing the Code for America Summit this year, and we're hosting an international design in government day at the Summit on 29th May in Oakland.

The International Design in Government Day is a one-day event: $150, in Oakland, and it's not just for designers working in or on government!

If you're a designer and interested in working with people -- tech and non-tech, many of whom are government lifers -- passionate about improving how government works, then please come along!
The instruction is signalling success, but returning FFFFFFFFFFFFFFFF as the random value.

* https://github.com/systemd/systemd/issues/11810#issuecomment...

H. Peter Anvin's educated guess was that some MSR flag, that has the effect of controlling this instruction, is not being saved and restored in the processor across a suspend, and the result is a processor state where it signals that the instruction is succeeding but it is not actually returning random values.

* https://bugzilla.kernel.org/show_bug.cgi?id=85911#c4
But does it at least do that 5% well?
I think the probability is very small indeed. I've never met (or even heard about) a deck that you can't destroy with a matching counter. That's why the metagame is so important for higher level magic play.
Eh, it already is. We call those legal golemns companies.
I am not steeped in this concept, but it strikes me that IQ can be totally replicable of the same biases, year after year. Meanwhile, what are you going to do with that information? I'd be a little disappointed to see it suggested that you can reduce an individual human to a number and make decisions affecting people's lives. Have you not had life experiences where the person with the highest test scores, most amount of praise, recognition, money, earning power, etc., is actually a comparatively ill-equipped human for some task? This intuition should make us skeptical of drawing too many conclusions from such metrics.
There's are two pretty simple explanations for that.

1. It's rare, so not many programmers have the pattern matching built up to read it easily.

2. Chained if/else statements have the benefit of indentations helping to show structure. The moment you add newlines to help show structure, a chain of ?:?:?:'s becomes much easier to read.

Most ?: expressions I see are uses inline, such as foo(a ? b : c). When you do that, you sometimes have to mentally unwind "ok so if a... what's a? why a? ok, so if a, then foo(b), else foo(c)". Putting the if(a) up front means you're already thinking about it by the time you get to the function call. So I reserve using ?: for when the difference between the two outcomes is minimal.
I would be very interested in a Linux distro by Microsoft. Could be very compelling.
How to remove a coffee cup or other object from your video using After Effects
That APU is from 2011. Can't imagine whatever rig this is has much life left. Maybe drivers don't play nice with it because it's nearly a decade old.
Sounds like a hiring problem. Start hiring some new devs and keep them separate so as to not contaminate them. As they come up to speed, let one of the other devs go. Wash, rinse and repeat.

Note: I'm a dev and I can tell you I very much dislike working with prima donnas.
Not the person you're replying to but I believe docker just hasn't added support. There's been a few issues regarding it open for a long time with no movement at all.
That shipping container model would be ideal for remote villages in Alaska! Making fuel locally would be so much more energy efficient!
In my experience an ORM will cause issues if used thoughtlessly throughout an application. Objects created by an ORM can be used "naively" and cause many round trips to the database, very inefficient queries, etc., but they boilerplate they can save is really helpful also.

I worked on a simple Python CRUD app project a few years ago with some folks who were absolutely against using an ORM for those reasons. There was so much code written that basically just took tuples returned from the DB and instantiated Python objects with them (and vice versa for inserts) that making changes to anything was absolutely maddening. I find that SQLAlchemy Core can be used very simply to essentially take a DB query and return Python objects.
Perhaps shipping simply produces more value for you than it does for them?
In my experience it takes months of looking at existing code before you see the good architecture under the superficial mess.

In other words, work in the current code for at least a year before proposing a re-write.

Source code older the the application doesn't mean much as a statement - any good process will build off a CI system which only takes old source code. The question is how different is the application the code generates from what exists, and what to do about differences.

Massive methods are sometimes a sign that the good architecture missed something. Refactor them of course, but that doesn't mean the architecture is bad, just that it needs to change to fit current requirements.

Documents/comments lie. Their value needs to be contrasted to the risk that they mislead you. I'm not saying you shouldn't have them, just not a much as you think.

The problem with books and research is knowing when to apply them. The rules exist for good reason, but they are really guidelines not rules and sometimes they need to be broken. I'm considering that now in my application, the GUI depends on the business logic depends on the network at first glance, but looking closer I'm debating calling it fine because there is no business logic (network sends 5, business logic changes the type from int to mm/s, GUI displays 5 mm/s), so the complexity of making the business logic the thing everything depends on doesn't seem worth it. Maybe, I'm still trying to figure out where we go next, different guesses result in different optimal architectures: if we were really sure they wouldn't be guesses.

I do agree that you shouldn't do anything without creating a test. Note that test is singular, don't try to create exhaustive tests, not only will it take too long, but you often will waste time on a test that is incidental to the implementation and not required. Create a test or two around something you want to change, and then make your change. You get some assurance you didn't break anything, if you were wrong and broke something, you at least get another test out of it.
I think the primary goal there was to demo Pharo Smalltalk and/or PharoPDS library. Note how there were many examples of the code which show how to use PharoPDS, but do not explain how bloom filters work.

Here is an actual source for the filter: [0], and here is a GUI code which draws the grid: [1]

I am pleasantly surprised -- some Smalltalks used to be incomprehensible in github; but looks like Pharo gets this right and produces human-readable files.

[0] https://github.com/osoco/PharoPDS/blob/master/src/PDS-Core/P...

[1] https://github.com/osoco/PharoPDS/blob/master/src/PDS-Playgr...
I am very happy with ORM.

I'm currently working on an e-shop. I need to display many tables with different filters.

Administrator wants products starting with string? OK: if filter['category']: qs = qs.filter ...
Administrator wants products without category? Ok: if filter['category']: qs = qs.filter ...
Add multilang supprt? Ok: subclass model, mark fields and translatable, run migrate script

I can combine any filters, ORM automatically creats query with necessary joins, subqueries, group by expressions etc.

If i didn't use ORM i would have to write code that generate select with cca 200 ifs because almost every filter can generate join or add fields to group by or generate subselect etc.
Broad general statements are always difficult but FWIW:

- btrfs is fine if you want checksumming for your external HDD with some backup stuff that is mostly sequential i/o.

- For everything else - especially anything that goes beyond a single disk use ZFS. btrfs RAID1 is not really raid1 but rather oddness of pid decides which drive to read from, raid5,6 had serious issues a while back - the write hole problem still exists for btrfs. ZFS stripe, mirror, raidz are well understood and work flawless afaik. btrfs also does strange things when replacing disks, like going read-only when one disk fails - at least it used to be that way.

- performance is a mixed bag but broadly speaking for anything that is not sequential io on an empty disk btrfs is slower than other filesystems[1], for ZFS it depends can be slower or faster than ext4 depending on a lot of settings...

- ZFS tooling is far superior to btrfs - I've used both a lot and you won't go back to btrfs tooling once you've used ZFS.

- btrfs snapshots degrade performance with rising snapshot count. ZFS works fine.

- ZFS has native encryption with zfs send / recv support in the upcoming 0.8.0. So you can do encrypted differential backups this way.

- btrfs quota was for a long time broken and error-prone, not sure what the current status is but it never worked correctly for me.

- ZFS lacks cp --reflink and linux pagecache integration as well as sendfile() on Linux and the ZFS ARC is independed of the pagecache - that has some consequences for e.g. mmap().

- ZVOLs are ZFS only you can create block devices as ZFS datasets i.e. zfs create -V 10G rpool/xfs && mkfs.xfs /dev/zvol/rpool/xfs && mount /mnt /dev/zvol/rpool/xfs can be useful for ceph, running docker on xfs volumes in container

- btrfs works fine inside containers so you can run Docker in LXD/LXC - ZFS is not there yet - overlay2 support is also missing.

- no io-scheduling via cgroups for ZFS afaik because the Linux queue subsystem is not used...

- Last but not least: ZFS has ZIL & L2ARC. ZIL is huge for spinning disks because sync() writes are first written to an ssd storage and later async and sequential to the hdd. TL;DL: apt update and databases are fast even on spinning disks. L2ARC is an SSD-Cache but it's not so effective in my experience (low hitrate for typical hosting stuff)

- Personally I will avoid using btrfs if I can.

1: https://www.phoronix.com/scan.php?page=article&item=freebsd-... it's a little bit apples/oranges because ZFS Freebsd != Linux ZFS but IMHO it shows that the architecture/design is sound.
A 15% decline is slight?
I was worried about this accusation which is why I put this part in:

- You don't mind if someone else solves it, you just hope someone will soon.

And also:

- Your solution doesn't have to involve a business plan and profit generation...

The goal is to discuss the problems we face and allow others to chime in with their own suggestions.
In EPEL probably https://twitter.com/RemiCollet/status/1063323527770750976
I was referring to the string composition [0] of psycopg2, a library which also takes care of converting SQL results to the correct Python data type. IMO that meets the criteria for an "abstraction above text" that GP was asking for.

But yes, SQLAlchemy Core is far more full-featured and gives you more than just a few primitives to work with. It also has a lot of library-specific constructs and is much closer to a full-fledged "ORM" than a query builder; what you're writing is not exactly SQL and is yet another dialect to learn.

[0] http://initd.org/psycopg/docs/sql.html
Well they can. They're just much more likely to be held accountable if they do so without a really damn good reason.
As true now as it was 12 years ago: ORMs are the Vietnam of computer science. http://blogs.tedneward.com/post/the-vietnam-of-computer-scie...

(tl;dr: there is an impedance mismatch / leaky abstraction between relational data and OOP for all but the most trivial use cases, guaranteeing that whatever problems an ORM might solve will be traded for new ORM problems instead)
There has been a proliferation of realtime collaboration within code editors because the underlying data model (a string!) is so simple. As you mentioned, you would need to define a sufficient protocol encapsulating the common functionality between code editors along with defining which aspects would be shared and broadcasted vs kept private (e.g. an independent vs "follow" mode).

The data model could easily be defined in Convergence.
Implementation-wise, the primary limitation would be that at the moment we only offer a javascript/typescript client. I haven't explored the VSCode base but I know it was written in TS and provided as a "native app". We do have an example of Convergence running in node.js (NWJS).
Make sure you enable developer mode in the Windows Store settings, and then deploy the CascadiaPackage app (set as start-up project + F5 in VS, not sure off-hand how to do it from the command prompt.) That fixed it for me.
Reducing boilerplate can be very valuable. Why would you want to spend time writing yet another query when you could be focusing on the parts of the application that deliver value to your customer?

Maintainability is also something to think about. The classes you write for the ORM implicitly document the content model. It can be very hard to decipher the same information from a "show tables" and reading a bunch of SQL SELECT statements, especially if they are all mixed up in the code and broken up with string concatenation and variables. Future maintainers will be able to read the documentation for the ORM which will probably be better than trying to understand a bunch of custom code to deal with complex queries.

For an example of this, notice how in the article the author's "linking table" was nowhere to be found in the ORM section. That got abstracted away! Someone having to analyze the tables directly will be running into those sorts of things all over the place, which is more mental overhead for understanding the system.
Yes there are: https://cbor.io/impls.html
A timeless question.

"Who shall mend the ship of state?" - Socrates, by way of Plato, paraphrased by Bertrand Russell

> Plato's Socrates compares the population at large to a strong but nearsighted shipowner whose knowledge of seafaring is lacking. The quarreling sailors are demagogues and politicians, and the ship's navigator, a stargazer, is the philosopher. The sailors flatter themselves with claims to knowledge of sailing, though they know nothing of navigation, and are constantly vying with one another for the approval of the shipowner so to captain the ship, going so far as to stupefy the shipowner with drugs and wine. Meanwhile, they dismiss the navigator as a useless stargazer, though he is the only one with adequate knowledge to direct the ship's course.

[1]: https://en.wikipedia.org/wiki/Ship_of_State

Plato was not a huge fan of democracy, perhaps because Socrates had been put to death by the Athenian democracy. He defined five regimes[2] of which Democracy is the second most degenerate and says that Oligarchy (rule by the rich), Timocracy (rule by land owners), and Aristocracy (rule by a privileged class) are all better than Democracy, which from his point of view is essentially rule by the mob.

[2]: https://en.wikipedia.org/wiki/Plato%27s_five_regimes

Yet Plato's Republic, his own design for a Utopia, is essentially an totalitarian state[3] explicitly based on a lie[4]. North Korea is much closer to Plato's Republic than any country in Europe. It doesn't say much for philosophers as potential rulers that they first declare themselves to be the only suitable rulers, and then immediately propose an unworkable Orwellian nightmare of a society.

[3]: https://en.wikipedia.org/wiki/Plato%27s_political_philosophy

[4]: https://en.wikipedia.org/wiki/Noble_lie#Plato's_Republic

Ever since, the question, "by what means may wise rulers be selected?" has remained open, with no alternative method reliably producing better results than democracy, which itself has failures. Notably, democracy turns out to be worthless if the government controls all information or can manipulate election results. For this set of problems, fair voting systems, rule of law, and freedom of speech seem to be necessary ingredients for the long term success of democracy. However there is another failure mode, for which no solution is known: democracies are susceptible to demagogues. Demagogues have popped up on a regular basis to trouble everyone from ancient Athens[5] and 20th century America[6], always peddling much the same brand of inflammatory and largely baseless rhetoric.

[5]: https://en.wikipedia.org/wiki/Cleon

[6]: https://en.wikipedia.org/wiki/Joseph_McCarthy

The article's suggestion that baby boomers skewed perceptions resulting from being born in a rare window of almost unprecedented prosperity has been suggested as a general pattern:

> “Hard times create strong men. Strong men create good times. Good times create weak men. And, weak men create hard times.” ― G. Michael Hopf, Those Who Remain
Care to elaborate? (I hope you read the article?)

This to me reads like an informative and actionable piece of information that citizens should know about.

Specifically:

- If there is scientific evidence that living in a certain area can cause cancer, that is something you should probably know.

- If there is evidence that your representatives in your state are ignoring EPA recommendations, that is something you should probably know

- If you don't understand that air quality can cause cancer, that is something you should probably know
So are you saying that I could write a fake app that made it look like I was buying stuff and win every time?
> But seriously, has anyone ever empirically verified that the Debian Stable/RHEL model of shipping a bunch of really old packages and then layering years of patches over top actually generates more stable, more secure code?

Debian has released a new stable version every 2 years for the last 14 years. RHEL/CentOS are the only ones on a 3-5 year cycle.
I suppose it depends on your flavor of ORM. My experience using Django has been amazing from day one, and support for more exotic operations has improved by orders of magnitude since I last used it.

I think a good ORM is one that strives to make 80-90% of operations ridiculously easy, leaving edge cases to the developer who can always drop down to a raw query as needed. Django does that fairly well, IMHO, and my limited experience with SQLAlchemy felt pretty underwhelming in comparison

EDIT: Though admittedly I did not have access at the RDBMS level to write VIEWs to match my business needs back when I was using Django. If I did, then perhaps I could have chosen that approach – though I would have to forgo all the useful django-admin stuff that comes out of the box, so there's always a tradeoff...
Labor Groups Investigating Sexual Harassment Claims at Quantic Dream
The Tommy Westphall Theory of a Unified TV Universe, Explained (2017)
At least you have something. You need to tell your boss that all features in the last 2 years need to be rewritten from scratch, with no lessons learned to speed up the effort, but that is still faster than starting over (particularly if the boss can say some things didn't turn out useful).
That jogs my memory; in fact, aha, I used get_user_pages in an early version, and switched to remap_pfn_range; then I nuked all that complicated non-linear access code. The ioctl for attaching the buffer then allocated the memory, and its interface changed to passing down a size and receiving a pointer.
> I know that investments like this can be hard to make, precisely because there aren’t any new visible rewards

Taken individually yes, there's no new 'visible' reward.

Looking at the larger picture, say, 3 months from now, changes that used to take 3 days now take 3 hours, and there are fewer outages, reduced downtime, higher uptime, and fewer (or no) hair-on-fire-we-lost-customers issues any longer.

Establishing both short term metrics (request turnaround time) and long term metrics (uptime, data loss, security breaches, customer satisfaction, team satisfaction, employee retention, etc) will help understand justification of effort.