skysight-inc/HackerNews huggingface dataset:
It's just a structural thing though?

Like you have a pipeline of [coro1, coro2] where coro2 is using data as it's yielded out of coro1.

But you can also just have like, coro2 yield from coro1 or similar.

I think I like it. Not sure yet. It might help composibility if you find yourself slapping together a lot of discreet little coros.
I don't know why you are getting downvotes. Vitamin D is a hormone. Everything upwards of 4000 IU per day is currently disputed territory.

It may be safe to take 5000 IU a day, some even suggest 8000 to 10000 IU per day. But studies still vary on this and discussions are being held. Don't be the lab mouse.

Take max. 4000, otherwise get blood work done and take over 4000 long term only on supervision until this is really clarified. You DO NOT want hypervitaminosis D.
I think the time of divergence in spoken language is much longer than that, maybe 300 years (and with lots of second-language speakers, which speeds it up). And starting I believe from dialects closer to Flemish.

The formal written language was indeed standard Dutch, but was not widely understood. For example (IIRC) around 1900 the dutch reformed church in the Cape partly switched to English, on the grounds that at least this was a real European language, in which people might actually understand the sermon! After that Afrikaans got formalised, e.g. the first official bible translation was 1933.
Are you seriously arguing Python has about the same complexity as C++?

An extensive standard library is not the same at all as an large base language size. Adding a million books to a language doesn't make it more complex, adding a million words and verb conjugations does.
JavaScript doesn't have to blocked to be unavailable. So many accessibility devices that don't have the capability to run it, and read noscript allowed, etc...
One way Herb Sutter looks at it is — most advanced programmers could probably write a Python or a Java interpreter. It might take them a few years, and they might struggle with some complex language features like metaclasses, reflection, or the type system, but the language spec is understandable enough that it’s feasible.

But give them five years and they would generally not be able to write a C++ compiler.
Learning pairs (normal, alphabetical) doesn't take anything like twice as long as just learning the normal word. Our brain is funny with associating things, especially if there is some logic to it like always rearranging the characters in the first word alphabetically.
Agreed.

Just gonna drop this here:
Nicolai Josuttis “The Nightmare of Initialization in C++” [0]

[0] https://youtu.be/7DTlWPgX6zs
Essentially any info you have posted that you remember that can be linked to any of your real ID can be traced to you. Sometime it doesn’t need to be public as hackers sell a lot of these info from hacked sites. I would say difficult to hide unless you don’t really use the internet or you are so careful it takes the joy out of it.
There is [1] a pure python package for expect. It provides essentially the same interface and is incredibly useful.

[1] https://pexpect.readthedocs.io/en/stable/
"In addition, in some potential realizations of IM2000, email would become mutable in practice"

That objection is invalid, as common and widespread DKIM message signature can be pushed with other headers. Author is likely aware of this, so he inserted a qualifier "in some potential realizations". Then it follows that this is not objection to IM2000, but to an easily fixed realization flaw.

This makes the author look like he has an agenda.
Try to grasp coroutines outside the async/await framework. Alternatively, try to understand corutines within the framework as state machines, like so:

async def foo():
conn = await DB.connect()
results = await conn.query("SELECT bar, baz;")
restresult = await REST.get("somewhere.else.prod.example.net/v1/BAR", id=results.id)
return restresult.xyz

->

class foo():
future = None
conn = None
results = None
restresult = None

def call(self):
self.future = Future()
future = DB.connect()
future.add_done_callback(self._db_conn)
return self.future

def _db_conn(self, fut):
try:
self.conn = fut.get_result()
except:
self.future.set_exception()
return
future = self.conn.query("SELECT bar, baz;")
future.add_done_callback(self._results)

def _results(self, fut):
try:
self.results = fut.get_result()
except:
self.future.set_exception()
return
future = REST.get("somewhere.else.prod.example.net/v1/BAR", id=self.results.id)
future.add_done_callback(self._restresult)

def _restresult(self, fut):
try:
self.restresult = fut.get_result()
except:
self.future.set_exception()
return
self.future.set_result(self.restresult.xyz)
Firefox 82: new automatic downloads protection
Java 15?! I hardly realised they'd moved past 8.
The biggest reason that macros are not going away is backward compatibility (a very important reason of course). Adding hygenic macros or "module friendly" macros would not help one bit with that.

Also I belive that macros do not escape modules by default. That's a huge improvement.
> One thing about a democracy, if poor choices are made and poor leaders are selected, it’s only temporary until the next wave of elections.

With sufficiently bad choices in a democracy it ceases to be a democracy before the error is corrected. Also, even when that doesn't happen, its possible for a choice to be bad but repeated in a democracy.
Yes I am, Python even changes stuff between minor releases.

Also I think many aren't aware how powerful Python actually is.
Getting to the top at almost any activity is a massive timesink. Lot to be said for not being too competitive.
Isn't that the quintessential lazy programmer solution? A quick hack that is beautiful but will cause lots of wasted time later.
This is great. When I worked graveyard on New Years I'd SSH into my server from my phone and watch the countdown with NTPD, knowing I had the most accurate clock of them all... not withstanding some 3G latency of course. This would have been the perfect accompaniment.
China threatens one country, but NATO and mainly US actually did total destruction of dozens of countries.
The header looks exactly like a bandicam watermark... which does capture a certain aesthetic
Personally I find it’s the other way around. Promises are so easy to understand. They are literally that: the promise of a result that you can await later on.

Maybe another helpful way to see it is that each sync function is one atomic block that is executed in one go. On the other hand, see each « await » in an async function as a split of the function into atomic blocks that can be executed separately, allowing to do other things while waiting between each block.

This abstraction catches up because it works really well. It is very composable as well. For example adding a queue instead of naively processing a lot of promises at once is 2 lines of code with this https://www.npmjs.com//promise-queue

Now I am waiting for async generators to catch up as well, to replace streams... I recently worked with this package for example and it was so much better than plain streams https://www.npmjs.com/package/streaming-iterables
Apart from the technical side of things, there is a level of maturity regarding behavior and high level approach that comes into play. Maybe you have these traits naturally, thus ppl assume you are a senior developer.

I wouldn’t get too stuck in levels (junior, senior, principal, etc.). They don’t map between companies the way you’d expect.
What's it offering that's more idiomatic than the `isinstance()` it breaks down to other than resembling virtual functions in C++?

What's costlier, the new stack frames plus conditional for a decorator or the `elif isinstance()`s in one function definition?

How does a programmer reference the correct function definition by name if they're using @typedispatch instead of `isinstance()`?
Fantastic, I've been wanting something like this since before async.

What is the mechanism used to parallelize, threads, processes or something else - it's worth mentioning in the readme.
This is a side effect of those languages being much more accessible to beginners and more widely used than C++.

You won't find that as much for for Haskell or Clojure or Brainfuck but that doesn't make them better languages or less tolerant to bad code.
I love FreeBSD. Are you using it in a laptop? If so, which one? I've been looking for a friendly laptop to check out the latest FreeBSD. It's been a while.
New version bumps after 8 are not necessarily major.
I don't think Rust is in any way losing anything by whatever is happening in the C++ world. With every iteration of the language it's biggest downside is becoming worse: it's a complex language very few people fully comprehend these days.
Or foreign song lyrics. During the international “Celtic music” fad of the 1990s – when bands like Clannad, Altan and Capercaillie were briefly much bigger outside their native countries than within them – I listened to a lot of these songs and memorized the Irish- or Scottish Gaelic-language lyrics just through pure exposure. In spite of not actually speaking Irish/Scottish Gaelic (I know just a handful of isolated words), I could reproduce those lyrics now with probably a high degree of fidelity.
There's also https://mousefix.org which has the extra bonus in that it tries to solve the smooth scrolling problem that can occur when using a mouse on a mac.
Yes! The spaceship operator (three way comparison a la strcmp) is very welcome, and the no_unique_address attribute will be helpful for people who care a lot about optimization. Simplifications like these really help, and don't take a programming language genius to utilize.
The body regulates vitamin D production from sunlight exposure. It cannot regulate orally taken vitamin D because by the time you absorb the supplemented vitamin D you have surpassed the regulation step.

You cannot get too much vitamin D from sunlight but you sure as hell can overdose by taking it orally.
Java designers don't follow fashion, they rather wait to see what actually works when the dust settles and how to keep those binary only 25 year old jars running on modern JVMs.

I have been working with Java, .NET and C++ since they exist, and C# being more feature rich than Java doesn't help if the libraries or OS support that a customer needs isn't there.
Agree, Wago’s Lever Nuts especially are a game changer.

Those DIYers who reject the “licensed electrician and I need a permit” model could benefit most from them - they’re almost foolproof.

Instead they’re expensive, hard to find as Lowe’s/Home Depot don’t sell them, and not too many average people are familiar with them.

I won’t ever buy plain wire nuts again unless it’s to cap a single wire.
I can't wait (normal) GCC to support modules!

(it already does but in a dev branch version, not very handy as it requires a full reconfiguration of the environment variables to switch between this and the normal GCC)

The status is here: https://gcc.gnu.org/wiki/cxx-modules
> yet drop someone with a beginners loved language like Python 3.8 and they will have fun throughout the almost 2000 pages of documentation plus all major libraries in use across the ecosystem, and Python implementations.

I would agree that the Python ecosystem is as complex as the C++ language.

I would not agree that the Python language is as complex as the C++ language, or that they Python ecosystem is as complex as the C++ ecosystem.

I will agree also that the Python language has very comprehensive first-party tutorial and reference documentation, but that doesn't add to the complexity.
This is pretty cool, but I also feel it's old tech. Safari on Mojave always asks if I want to allow downloads on a domain I've never visited before. To me that's a good balance between usability and safety.
It is! You just need to use asyncio correctly and put coroutines you want run in parallel in tasks. It's the second example on the asyncio documentation for coroutines and tasks: https://docs.python.org/3/library/asyncio-task.html#asyncio....
Yep, some people love their outdated GC algorithms and JIT implementations.
Curio is really good and underrated
LibreOffice Online API
My main gripe since buying a MBP last year is the sheer amount of third party applications I need to install in order to restore basic functionality.

I guess most users never discover these limitations but between this, the absence of window snapping (and associated key shortcuts), and the terrible external monitor support it’s hard not to regret the move when I stare at my (admittedly very pretty) laptop.

I get that most reviewers aren’t really heavy users, and seem to think (like Apple) that a “pro” user is someone who works exclusively in photo and video editing, but I need to get my work done.

It’s really disheartening that they don’t seem to understand these types of problems.

But hey, at least they’re giving us Escape keys back.
As someone that really likes C++ templates (no other language seems to come close in power for such a compile-time typed system), I'm particularly looking forward to concepts, and I believe (correct me if I'm wrong) that they will make compiler errors for templated code much more straightforward, which will be a nice quality of life improvement even if not using concepts directly.
One step beyond: the ascent of mountain runner Kílian Jornet
Whether code is written to a file or just executed in memory is irrelevant. JIT compilers compile code at run time, and may also recompile the already compiled code again to optimize it based on run-time analysis. SBCL however has distinct compile-time and run-time.

For example, you have a function that does a bunch of math without knowing the types of the arguments. A JIT compiler can first compile it with generic math, but later observe that it's almost always called with fixnums, and choose to create a specialized implementation for fixnums. SBCL relies on the programmer to implement and call the optimized version when appropriate.
There are plenty of opportunities for a Python Puzzles quiz.
This well known Tesla fatality [0] illustrates my point. Unfortunately. The model built up by the system was free (enough) of contradictions and the reaction of speeding up right into that barrier was a totally correct one. From the system's "point of view". Neither sensor- nor interpretation-wise we are close enough to humans with those systems if the operating domain is not extremely limited. All general highway systems are operating in a too open environment to be safe (that is, we won't see real L3 or higher systems there in the near future). Sorry, Ghost. Ask other people who have been there.

By the way, Google's tiny slow cars driving in the valley only were exactly the strategy to limit the operational domain. Once they opened up that domain, they started to struggle again with the same problems as all others (admittedly on another level of mastering it though)...

[0] https://www.theverge.com/2020/2/24/21150546/tesla-autopilot-...
AFAIK (at least in most European countries) such robbers didn't attack villages, and people willing to travel tried hard to do it in groups (pilgrims, merchants).

You now have nearly no way to escape your (Occidental) government. Wherever you go, whatever you do, whoever you associate with.

If you really believe you can change the power-that-be by voting let's say we disagree.
If you use a tiny subset of C++, then you get a dialect of C with more
type safety, namespaces, mostly-not-unsafe subtype polymorphism through
class inheritance, and also okay parametric polymorphism through
templates. That dialect will compile a bit slower (it's still C++ after
all), but produce code which either has the same performance as C or is
only slightly behind C.
Nice I love these sort of language differences. In English of course you can add an "s" to many words to make them plural, and that is permitted in Scrabble.
I never heard of that before, cool idea.
Solar eclipse measured on Mars, affects interior
There are indeed lots of ways of getting around. Walk, tram, bike, e-scooter, escalator, funicular, metro, schwebebahn, car, train, taxi, rickshaw, boat, bus. The best cities utilize a mix of those that work for them. Rental solutions have exploded in recent years.

You can't pick just one and say it's the best for everything.
What has systemd-resolved got to do with the fact that you have to use black-boxes? If they had used no DNS management at all and instead just dumped entries in /etc/resolv.conf, you'd be just as SoL as you are now with systemd-resolved. If you can write to /etc/systemd, you can set whatever DNS config you want in the config file for systemd-resolved. I fail to see how our woes with bad software products have anything to do with systemd-resolved.
Yes, I have many positive things to say about C++.

It certainly has a lot of warts, but over the past decade, it has become easier and more straightforward to write code in various styles which used to be possible-but-a-pain (like functional programming), or not quite possible.

So with C++ you get performance + backwards compatibility + paradigm flexibility for the price of difficult, sometimes ambiguous syntax, some historical baggage you need to ignore, and slower compilation time. It's a decent tradeoff IMHO.

Specifically, regarding C++20:

* std::span is the best thing since sliced bread. How was this not in the library already? Cuh-razee... https://stackoverflow.com/q/45723819/1593077

* I'm happy that ranges support is inside the language. I can now `sort(my_container)` rather than the clunky `sort(my_container.begin(), my_container.end())` for example. And there are a bunch of useful lazily-evaluted range views. I only wish more of the ranges library could have been added. And I hope the compilation of ranges isn't too slow.

* Modules can now start replacing include files. Initially, this will only be a theoretical possibility, but within several years, no longer will your compiler have to deal with 100,000 lines of text or so per translation unit: It will be like in Java and other languages, where it's just your current file that needs to be compiled and the rest is already compiled. Of course the transition will not be smooth (feature macros, conditional compilation - not obvious to me how to replace them when using modules), but this is a good direction. We could see faster compilation times and content suggestions in IDEs.

* Expanded constexpr support means we can do more work once, at compile time, rather than repeating it at run-time (e.g. dynamic memory allocation - so you can have constexpr std::vector).

* Coroutines are something interesting which I am not familiar with (except the very rough general idea of different control flows being switched between. I can at least say it's interesting to look into.

* libfmt string formatting - Yes, yet another way to format strings: printf-style, iostreams, and now the "Python style", I guess you could say? It combines some benefits of both of the previous ones.

* std::source_location - you know how, if you're writing some error-handling function, you usually need to wrap it in a macro which gives you the filename and line number? Well, that's going away now. I know it's just a minor thing, but I hate having those macro'd error handlers.

* You can now tell the compiler to use a generated equality and comparison operators; this saves you boilerplate. Although in the C++ tradition, this capability is defined in a somewhat convoluted way under the hood.
Yeah, it's unfortunate! I love C++ personally, I've recently commented something positive in another thread:

https://news.ycombinator.com/item?id=24041406
Is My Weather Weird?
Agreed. The bigger C++ gets, the more important it becomes to treat it as "C with some cool extras" and to consider any and all new features as optional extras that you only use if you legitimately need them. The moment you start seeing "C with classes" style as a bad thing, you will slowly wander off into the wilderness.
It only matters at high speeds. Above 120 miles per hour, they provide stability.
Yeah, I remember reading this idea in the 90s in his book The Road Ahead. I thought it was such a cool idea, and was sad it never happened.
Your narrative is a commonly expressed one by the PC left, but it doesn't match reality.

> world class military apartus/nuclear power

This is a good thing for the world, as the US has maintained relative international peace for 75 years. The US stopped the Bosnian conflict (in Europe!) after the EU was afraid to do so.

> not being able to collectively care for each other

There are historical reasons for that, so it's not an accident.

The US people have chosen to not offer single-payer (socialized) medicine, and the CDC failed in their charter during corona. (They had since corona-1 in 2003 to create a corona vaccine, but didn't make it a priority.)

Americans historically have also been mobile, moving away from their parents. The end result is as you said, but only an indictment of the CDC.

> parts of the nation are on the brink of a civil war

Various socialists/marxists are rioting in some downtown areas, usurping the BLM protests. Arson is a capital crime, and arsonists should be shot on sight.

Trump is our elected leader, and he's proven to be mostly correct on China and aviation's role in spreading corona, and the solution to marxist protests. You can watch Dr. Victor Davis Hanson's Youtube videos to learn more about how effective a leader Trump actually is.

Dr. VDH - The Case for Trump
https://www.youtube.com/watch?v=FEXL5USuDGI

We are currently at war with China, so the marxist protests are literally undermining our ability to deal with an existential threat to the entire world that's comparable to WW2. You can learn more about this by watching Youtube videos by NTD, Joshua Phillips - Crossroads and Simone Gao.

https://www.youtube.com/c/CrossroadswithJOSHUAPHILIPP/videos

https://www.youtube.com/channel/UCVWMVBg1RPrDlakdmbyTKBA

I suggest you keep your eye on the ball and vote Trump in November.
I'm more and more leaning towards "run dnsmasq on every single machine and be done with it", it feels like the sweet sweet spot to get flexibility and the predictability. Otherwise, systemd-resolved is not as unpredictable and frustrating as resolvconf or networkmanager.
https://craphound.com/spamsolutions.txt

Your post advocates a

( X ) technical ( X ) market-based

approach to fighting spam. Your idea will not work. Here is why it won't work. (One or more of the following may apply to your particular idea, and it may have other flaws which used to vary from state to state before a bad federal law was passed.)

( X ) Mailing lists and other legitimate email uses would be affected

( X ) Requires immediate total cooperation from everybody at once

Specifically, your plan fails to account for

( X ) Lack of centrally controlling authority for email

( X ) Public reluctance to accept weird new forms of money

and the following philosophical objections may also apply:

( X ) Ideas similar to yours are easy to come up with, yet none have ever been shown practical

( X ) Sending email should be free

Furthermore, this is what I think about you:

( X ) Sorry dude, but I don't think it would work.
Then it is time to learn some clever use of Python metaprogramming, metaclasses, how slots interact with old style attributes, old and new style classes, clever tricks with magical methods, stackless vs regular Python, multiple ways to format strings, arithmetic semantic changes,...
I have spent quite a bit of time invstigating the metaprogramming capabilities of python and I have barely scratched the surface. And I hear they have added a fully parametric type system recently...