My Mother's Yiddish - <AUTHOR> https://theamericanscholar.org/my-mothers-yiddish <comment><USER2> _Yiddish was largely derived from Middle High German, and the irony of ironies is that the language that united Jews is so close to the language of Hitler._

Rest assured that the irony is on hitler too: in many polish towns the only thing remaining that remenbers one that this was Germany once are the inscriptions at yewish cemetries.

Just imagine that the holocaust Never happened: German would be much closer of what the Nazis thought it should be, a world-wide spoken language.

Bloomberg didn't study Physics because you had to know German for that. Accadamia abandoned German. As did most of german-americans.

Yiddish was the defacto language of many Zionist settlers. Israel speaking German, unimaginable today but a Real concern for zionist theorists that complained about too few people adopting hebrew.

<comment><USER3> Made me sad... apparently a good 1/3 of Americans spoke German before WWI, after which anti-German hysteria caused a decline in German speakers in America. So it was not only the Nazis that were responsible for German's decline.

<comment><USER4> Take heart, German descent folks are a silent minority (46 million) that have done very well for themselves.

[http://www.economist.com/news/united- states/21642222-america...](http://www.economist.com/news/united- states/21642222-americas-largest-ethnic-group-has-assimilated-so-well-people- barely-notice-it)

<comment><USER5> They aren't all that silent, but the noise they make is in English...

</comment></comment></comment></comment><comment><USER6> Having grown up with a small sprinkling of Yiddish words in my parents' vocabulary, I agree with Sasha Baron Cohen's character in The Dictator, where he says "I like Yiddish, the words sound like what they mean". I actually made this same comment to my Dad 15 years ago, and he told me it only seems that way since my brain learned the words in context.

My grandfather grew up in Brooklyn with Yiddish as his primary language. On his first day of Kindergarten, probably 90 years ago, the teacher held up a fork and asked the class what it was called. He answered "Gopel".

On his first date with my grandmother, he wanted to take her to the Yiddish theatre in NYC. But my grandmother refused, not being proficient enough. Today the idea of live vaudeville Yiddish theatre in the USA is almost unfathomable.

And some of this Yiddish is still getting thru to my kids. Eg, they'll say they bumped their keppe (head, pronounced 'keppy'). I've always liked the sound of that. My wife even heard our Italian baby sitter here in London, at the playground babysitting another child, say in Italian accent "aww did you bump your keppe?"

My favourite Yiddish quote : "A pish on a fartz iz vi a regn on a duner". Translation : To pee without farting is like rain without thunder.

<comment><USER7> > "A pish on a fartz iz vi a regn on a duner". Translation : To pee without > farting is like rain without thunder.

Is that phonetic? You write "on a" twice, but I'm thinking of the German word "ohne", meaning "without". But then I know little German and even less Yiddish.

<comment><USER8> "a" is an article in Yiddish (like English); אָן (on) is indeed the word for "without" (of course it's related to German "ohne").

</comment></comment></comment><comment><USER9> > To be a mensch was the pinnacle of her moral code, and it didn't matter that > it meant "man." Women could be mensches, too...

Nitpick: "Mensch" is actually gender-neutral (in Standard German it just means "person" or "human being", not "man" (which is "Mann").

<comment><USER10> In Yiddish (at least as spoken to me), it often has a masculine connotation.

</comment></comment><comment><USER11> There are couple of books by Leo Rosten, Joy of Yiddish and Joy of Yinglish, that teaches Yiddish words through jokes and anecdotes. It used be my bedside reading for an year! Once you learn Yiddish words and the phrases, the sitcom dialogues started making more sense (like "from your lips to God's ears" or such turn of phrase).

<comment><USER12> Michael Chabon's essay "A Yiddish Pale Fire", which discusses his encounter with a Yiddish travel guidebook that eventually inspired "The Yiddish Policeman's Union", is a great read too, if you can track it down. Looks like it's disappeared from the Web.

</comment></comment><comment><USER13> On a related note, there is highly educative book on Yiddish called: "If You Can't Say Anything Nice, Say It In Yiddish" by L.B. Epstein [1].

Yiddish curses put any other language's curses to shame. They use a lot of very well thought analogies. They also sometimes revive a bit of the (lost) history of the Jewish people pre-wwII.

[1] [http://www.amazon.com/You-Cant-Anything-Nice- Yiddish/dp/0806...](http://www.amazon.com/You-Cant-Anything-Nice- Yiddish/dp/0806527315)</comment>


Ask HN: Examples for end user software hacks/repurposing - <AUTHOR> Which end user software hacks or repurposing have you seen or used yourself? I'd like to collect some examples, be they private, or even more interesting, department or company-wide. A classic one is using excel as a database.<p>My intension is not finger-pointing users' ignorance of "right" tools, but how people come up with own solutions (ideally, you can give some context around problem and solution). <comment><USER2> Using excel as a calendar. My whole startup is built around replacing this terrible process with a good web-app, and automating the scheduling process. The saddest part is that most of US healthcare runs this way- doctors and medical administrators are wasting their time clicking around in excel.

[https://reschedulemed.com](https://reschedulemed.com)

</comment><comment><USER3> I've got a bunch of examples of use of Excel as a calculation engine for pricing and risk management in investment banking at spreadserve.com</comment>


Apple Is Rotting and Google's Got BIG Problems - <AUTHOR> https://hackernoon.com/apple-is-rotting-and-googles-got-big-problems-presentation-cd911d67325f <comment><USER2> You should feel ashamed for even considering posting this. Not only does the website not host any content, but it's equivalent to suggesting the government of Italy is not going to exist in 15 years. It's simply pure bullshit. As if billions and billions of dollars of infrastructure is simply going to vanish. You'd have to be crazy.</comment>


I Know Who You are. What your Browser Can Reveal About Yourself - <AUTHOR> http://blog.florianbersier.com/i-know-who-you-are/

<comment><USER2> I have the feeling people suppose they're in some sort of armored vehicle when browsing the web, when in reality it's an open-top Jeep. It's too bad the general public has no concept of how vulnerable their identity is on the web.</comment>


Costco and Global Wine (2007) - <AUTHOR> http://wineeconomist.com/2007/08/22/costco-and-global-wine/

<comment><USER2> Most wine tasting is bunk:

[http://www.theguardian.com/lifeandstyle/2013/jun/23/wine- tas...](http://www.theguardian.com/lifeandstyle/2013/jun/23/wine-tasting-junk- science-analysis)

It doesn't make sense to buy above your discrimination limit:

[http://blogs.msdn.com/b/oldnewthing/archive/2009/07/29/98515...](http://blogs.msdn.com/b/oldnewthing/archive/2009/07/29/9851534.aspx)

So just go for the German model.

<comment><USER3> I don't think that's what the Old New Thing post is suggesting. Do the Germans buy a lot of 60€ white label wine? According to the article,

 _The average "bottle" of German wine is sold in a discount store, often with a house brand name, and costs about a Euro per liter. I put "bottle" in quotes because sometimes it comes in a juice-box type container. Decent quality for less is what the German market seeks and the discount chain's reputation for value seals the deal._

My experience matches the Old New Thing analysis: There are plenty of good inexpensive wines, but a randomly chosen $10 bottle from a typical 200+ vintage seller is unlikely to be one of them. As you get closer to $50 the ratio of good wines to bad wines rises quite appreciably. After that it's hard to identify the added value beyond variety of experience.</comment></comment>


Rhasspy is an open source, fully offline voice assistant toolkit - <AUTHOR> https://rhasspy.readthedocs.io/en/latest/ <comment><USER2> Author here, happy new year HN! Glad to answer any questions (also see [https://community.rhasspy.org](https://community.rhasspy.org))

Bit of background: Rhasspy was originally designed for Home Assistant ([https://www.home-assistant.io](https://www.home-assistant.io)), but now works with lots of home automation projects (Hass.io, Node-RED, OpenHAB, Jeedom). Its sister project, voicej2son ([http://voice2json.org](http://voice2json.org)), is for command-line use and has fewer options.

With Snips.ai being bought by Sonos, we're now focusing on compatibility with its MQTT protocol ([https://docs.snips.ai/reference/hermes](https://docs.snips.ai/reference/hermes)) so existing plugins/skills will just work. Supporting Snips-like number/duration/dateTime slots across over a dozen languages is going to be a major challenge, so please reach out if you speak a language besides English* :)

* Also consider donating to the Common Voice project: [https://voice.mozilla.org](https://voice.mozilla.org)

<comment><USER3> Just an aside, neither the logo nor the name make me think of "spee." Definitely going to check this out though, thanks!

</comment></comment><comment><USER4> This looks like a lot of fun to hook up to something like this 6 mic hat for the Raspberry Pi

[https://respeaker.io/6_mic_array/](https://respeaker.io/6_mic_array/)

<comment><USER5> The ReSpeaker Core v2.0 looks like it could be fun too:

* Debian-Based Linux System

* SDK for Speech Algorithms with Full Documents

* C++ SDK and Python Wrapper

* Speech Algorithms and Features

* Keyword Spotting (Wake-Up)

* BF (Beamforming)

* DoA (Direction of Arrival)

* NS (Noise Suppression)

* AEC (Acoustic Echo Cancellation) and AGC (Automatic Gain Control)

* All-in-One Solution with High Performance SoC

* 8 Channel ADC for 6 Microphone Array and 2 Loopbacks (Hardware Loopback)

[https://respeaker.io/rk3229_core/](https://respeaker.io/rk3229_core/)

</comment></comment><comment><USER6> This is really cool!

Does anyone know if there's a way to hack an Echo Dot and use it as the speaker/mic for Rhasspy? Rolling out our own hardware that is as effective as a Dot would probably be very difficult?

<comment><USER7> I was looking up this today without much luck, I'd actually like to try to use either the echo dot or google home for generic videoconferencing (zoom)

<comment><USER8> Idk if this is something that'd interest you, but you can use Alexa for Business in AWS for $3 per month and link your echo to zoom.

</comment></comment></comment><comment><USER9> Similar project: Voice2JSON

Website: [https://voice2json.org](https://voice2json.org)

GitHub: [https://github.com/synesthesian/voice2json](https://github.com/synesthesian/voice2json)

(I am not affiliated but am using it in my own pet project)

<comment><USER2> Correct link: [https://github.com/synesthesiam/voice2json](https://github.com/synesthesiam/voice2json)

For those wondering, Rhasspy and voice2json are from the same author (me). If you want a command-line tool for voice assistant tasks (wake word detection, speech to text, intent recognition, etc.), check out voice2json.

See the recipes for some interesting things you can do with voice2json: [http://voice2json.org/recipes.html](http://voice2json.org/recipes.html)

</comment></comment><comment><USER10> I recently came across Rhasspy, and while I haven't had time to play with it, I'm super excited. Often I like the sound of certain projects but want to plug in my own parts. Rhasspy appears to glue all the parts of a modern voice assistant together, but let you swap out any of the parts.

<comment><USER2> Going forward, Rhasspy is being split into multiple MQTT services that should be compatible with Snip.ai's protocol ([https://github.com/rhasspy](https://github.com/rhasspy))

This should make it much easier to swap out parts, and distribute the computing across multiple devices.

</comment></comment><comment><USER11> Have you considered Mozilla's DeepSpeech for Speech2Text? Since version 0.6 it seems to be a viable option for a raspberry pi.

[https://hacks.mozilla.org/2019/12/deepspeech-0-6-mozillas- sp...](https://hacks.mozilla.org/2019/12/deepspeech-0-6-mozillas-speech-to- text-engine/)

<comment><USER2> We have, though my tests prior to 0.6 were not as promising as I'd hoped. With 0.6, though, we're planning to add support for English and French (a German model is apparently in the works: [https://github.com/AASHISHAG/deepspeech- german/issues/3](https://github.com/AASHISHAG/deepspeech-german/issues/3)).

</comment></comment><comment><USER12> This is inspiring hopefully I find some time in the new year to dig into this stuff. I feel like there will be a sort of arms race between open source and top tech companies around AI and privacy. Projects like this are needed imo

</comment><comment><USER13> How good is the recognition?

<comment><USER14> It seems it uses pocketsphinx or kaldi. I've never tried kaldi but I've tried pocketsphinx before and didn't find it accurate enough to be useful.

<comment><USER15> Kaldi is much much better, but when used for low latency recognition on the device, the accuracy will be lower than it could be because one would use much smaller models adapted to the constrained proccessing power of the device.

It would still be much better than pocketsphinx.

</comment></comment></comment><comment><USER16> Does anyone know if this is viable on a pi zero?

<comment><USER17> No, based off of their hardware requirements. See here. [https://rhasspy.readthedocs.io/en/latest/hardware/](https://rhasspy.readthedocs.io/en/latest/hardware/)

<comment><USER18> Apparently it's work in progress: [https://github.com/synesthesiam/rhasspy/issues/61](https://github.com/synesthesiam/rhasspy/issues/61)

Sounds like it's not too far off.

</comment></comment></comment><comment><USER19> Mmm if there were only IP microphones to connect to something like a Raspberry Pi (An Odroid H2 in my case) to have multiple mics, one on each room without the need for multiple servers...

<comment><USER20> AES67 microphones exist. Shure, Audio-Technica, and Audix are just 3 manufacturers that make them. Some of them are called Dante mics and you have to turn on AES67 in a confirmation menu. I don't know that there are any good AES67 drivers in stock Debian or Raspbian, but a lot of AES67 devices can be used with any software that supports rtsp. Whether one install of rhasspy can handle multiple streams at once is a different question. Also, even the cheapest AES67 equipment is expensive enough that a new raspberry pi or odroid h2 per room would be cheaper.

</comment></comment><comment><USER21> How is that useful? Most of the things I use assistants for is locating data online while I'm not on my phone.

<comment><USER22> By "offline" I think they mean the speech recognition and processing is offline and requires no third-party servers. I'm fairly certain you can assign voice commands to do stuff online.

</comment></comment><comment><USER23> Kalliope, another open-source voice assistant ([https://github.com/kalliope- project/kalliope](https://github.com/kalliope-project/kalliope)) also has the option to use an offline wake-word backend like snowboy.

</comment><comment><USER24> Neat! This also looks a little related to a (very much) toy project of mine ([https://github.com/iamsrp/dexter](https://github.com/iamsrp/dexter)). I might try to look to see if I can hook them together..!

</comment><comment><USER25> This looks great!

I'm curious about extensibility - would it be possible integrate with a C# app running on Windows, for example?

I'm particularly interested for accessibility reasons, looking for ways to control tools like JetBrains Rider without shifting my hands from keyboard to mouse.

<comment><USER2> I haven't ever tried running this on Windows. You may get lucky with Docker, but audio input might be difficult. A workaround might be to stream audio in: [https://rhasspy.readthedocs.io/en/latest/audio- input/#gstrea...](https://rhasspy.readthedocs.io/en/latest/audio- input/#gstreamer)

</comment></comment><comment><USER26> Similar project (quite old): CMU Sphinx

<comment><USER27> Seems like this project uses sphinx as the actual recognition engine. This is just a wrapper.

</comment></comment><comment><USER28> I too am super interested in an offline-only voice assistant but really don't want to bother with setting up a mic connected to a pi. Even tough it's not super hard, it'll never be as good as the commercially available options.

I think this project would really benefit from taking one of the excellent existing voice assistant/speakers on the market (Google home, echo dots, etc., and flashing them with some custom firmware.

<comment><USER29> > Even tough it's not super hard, it'll never be as good as the commercially > available options.

Arguably, being offline and keeping your recordings off the cloud, it is already superior to commercially available options.

<comment><USER30> Exactly. I've never considered voice assistants because I don't want recordings of me or my family being used for who knows what.

I've just looked over the docs. I'll probably be playing with this very soon.

<comment><USER31> Interestingly the storage on my phone was used up and Google Keyboard kept on crashing, so I had to use voice for one whole night.

<comment><USER32> Having run into similar problems multiple times, the solution is to clear cache on an app. If, like me, sorting your apps by storage usage never actually completes[1], browsers are a good thing to check first[2]; Unity games are a good second (those analytics pile up, even if the app is firewalled). If you're rooted, check the analytics in Chrome's private data folder, it was taking up 1.5gb on my tablet last time (not sure if this is cleared when you clear cache or not)

If the primary issue is the same as me, that you download too much crap without paying attention to available storage, just use the terminal emulator to create a 25-100mb file you can delete when necessary.

[1] storage  internal  apps [2] If you use PWAs to cache data and avoid high data bills, keep in mind that clearing browser cache clears PWA cache as well (my most-used PWAs are for hn and xkcd)</comment></comment></comment></comment></comment>


CSS Only Macbook Air - <AUTHOR> http://cssdeck.com/labs/css-only-macbook-air

<comment><USER2> Looks great! I can highlight the"MacBook Air" label below the screen. Is it possible to use the  (alt+shift+K) symbol for the Apple logo?

</comment><comment><USER3> Thanks all, I'm Burak Can; creator of this. nikolakirev, it's possible but i'm not sure if this symbol is available in windows computers?

</comment><comment><USER4> WOW! You only have 2 assets (the screen image and the logo)...amazing! This inspires me to re-study CSS3's infinite animation! MAD PROPS!

</comment><comment><USER5> I can barely get my 'Hello World' program to work...

</comment><comment><USER6> This is impressive.

</comment><comment><USER7> Why?</comment>


U.S. Authorities Are Reportedly Gathering Data Using Fake Celltowers on Planes - <AUTHOR> http://techcrunch.com/2014/11/13/u-s-authorities-are-reportedly-gathering-phone-data-using-fake-celltowers-on-planes/

<comment><USER2> > As ever, responses to this news will largely fall into two categorizes: > those who believe that the U.S. — and other governments — should do > everything within its power to find and apprehend criminals; and those who > feel that the government is again running roughshod over privacy rights.

This is a false dichotomy. If you care about apprehending criminals actually responsible for crimes you should care about this too. A reoccurring subtext is that law enforcement cares more about quantity than quality, but data quality is hugely important. These dragnets are the equivalent of a House TV Series body scan, and the arguments that characters in the show made apply here.

One of the consequences of a dragnet and too much low quality data is the risk of circumstantial evidence leading to the conviction of the wrong individual. The minds of investigators and district attorneys are susceptible to all the biases that plague any other field including confirmation bias. Project Innocence has revealed heaps of wrongful convictions based on low quality data, even when police corruption wasn't at fault. Dennis Fritz and Ron Williamson for example were convicted for murder based solely on bad circumstantial evidence while the real perpetrator remained unpunished for over a decade.

It's not just privacy advocates who should care about stopping these kinds of surveillance techniques. That is unless the dragnet apologists don't care about who is being punished for crimes just as long someone is punished whether or not they actually committed a crime.

<comment><USER3> You're right, it is a false choice. But before we get to discussing that, we should first be considering whether there's a choice that needs to be made at all.

I personally am far from convinced that law enforcement has a significant problem with locating fugitives. I may be wrong with this, but I haven't seen anything concrete to dissuade me from those views. How often are such location services actually needed, and what are the consequences of not having them available?

</comment></comment><comment><USER4> I don't understand how if these technologies are being used to convict people in open court how are we just learning about them now through leaks?

</comment><comment><USER5> I'm such a bad vilain: I had this idea only 4-5months ago and I didn't act on it. They built it way before I had the idea.

</comment><comment><USER6> _" allow them to prize registration and identification information from a 'target'"_

Tripped up on this phrase; dusting myself off, I believe the writer meant "pry".

<comment><USER7> Although rather uncommon prize can also mean "the act of seizing; capture".

<comment><USER8> Is that not prise?

<comment><USER9> UK prise, US prize

<comment><USER6> Thanks, I had a nagging feeling I was missing something. I would have recognized the British spelling ...</comment></comment></comment></comment></comment>


Hacker's Summer Guide: Editing Skills – Part 3 - <AUTHOR> https://blog.paymill.com/hackers-training-guide-3/

<comment><USER2> great and interesting insights! thanks for that!</comment>


Is Shelly Cloud faster than Heroku? - <AUTHOR> http://blog.shellycloud.com/2013/05/is-shelly-cloud-faster-than-heroku.html <comment><USER2> Could someone that has used shelly cloud in production share their thoughts on stability and service of it please?

</comment><comment><USER3> Not specifically about this post or topic, but I kind of miss that blog posts don't have the Conclusions...call them summaries, if you will..at the start of a post.

I get it, all authors want all readers to read the whole of their masterpiece. Unfortunately, though, we live in a world where we are deluged with fluff and rubbish; we need concise, detailed, and conclusive summaries at the start in order to make a judgement as to whether reading the details is necessary or even valuable.

I don't think trying to hold out out of fear that the whole post won't be read is all that productive; possibly even counter-productive.

<comment><USER4> I agree. One of the things I love about scientific papers is being able to read the abstract to determine if the whole paper is worth reading.

</comment></comment><comment><USER5> I know that bashing Heroku is popular this days but seriously i don't like what you did.

I'm not a fan of your way of getting users by pointing some non-objective figures and saying hey we're faster & better than the competition.

Seriously, you should benchmark and say "we can do this, this and this", and let your users decide if you're faster, better.. because doing it in your way, is just ugly and not fair.

Btw, I like your design. You mention redis on your site, but there is no redis in the pricing.

<comment><USER6> I like it.

They offered way more information to us than the route you are suggesting and opened themselves up to more internet scrutiny as a result. I know that "Shelly is faster than Heroku says Shelly." isn't the first thing you want to hear but they offered a comparison in key areas that I find interesting.

What if they just took all the numbers that Heroku offered, then offered their numbers in all of those areas. That is essentially what has happened but we don't need to compile both sets together ourselves because it was already paid for someone to do it.

Arguably Shelly offering numbers that could be compared with Heroku's numbers would be nearly the same thing but less convenient.

</comment></comment><comment><USER7> Are the response times faster because the company and its servers are both based in the EU? So, really the response time charts are showing the benefit of simply eliminating a cross Atlantic network hop? So, is this a solution for companies targeting EU customers?

<comment><USER8> The tests were ran from a Hetzner server against Shelly Cloud and Heroku EU, so that shouldn't affect the results.

We are however targeting EU customers, we have servers in EU datacenters. We have plans to expand to the US later.

<comment><USER7> Thank you for the response!

I'll keep an eye out for your US launch! Competition is a good thing.

</comment></comment></comment><comment><USER9> Have you considered data centers located in North America at some point?

<comment><USER8> We're planning to do this eventually, but we're focusing on EU right now.

</comment></comment><comment><USER10> Doesn't matter, only supports Ruby on Rails.

Might care when it supports stuff I actually use, like Heroku does.

<comment><USER8> We support all Ruby frameworks, not only Rails.

We believe that by focusing on Ruby we can provide better service than we would if we had to support multiple runtimes and application architectures.

<comment><USER11> My node.js setup wants to thank you for your attention to our kind. I think I'm also hearing some Django persons hissing on this.

But thanks, reading your "We are so much better than Heroku because X" auto- congratulatory post to then see you stumble on the issue of multiple languages was funny :)

<comment><USER8> We're not saying that Shelly Cloud better than Heroku in general, we're just pointing out that focusing on one language has it's benefits. There is a market for generic solutions like Heroku, and specific ones like Shelly Cloud, Nodejitsu, etc.

</comment></comment></comment></comment><comment><USER12> I would only take seriously tests like this if my apps consisted of displaying "Hello World" to paying customers. So far I couldn't find a business model to monetize this type of application.

As a result, I find these tests to be meaningless no matter how pretty the graphs are.

<comment><USER8> By keeping the test apps simple, we limit the app code's effect on the results, and show the overhead of the providers' infrastructure.

You're welcome to fork <https://github.com/shellycloud/baseline-performance> and provide a better test.

<comment><USER12> No thank you, I have other work to do now. That reminds me I have to drop HN and get back to work. So excuse my short reply.

An even better way to test your platform would be to offer future customers free accounts with reasonable limits to test their applications with real data and load. I realize you offer 20€ for free, but that doesn't cover a real test.</comment></comment></comment>


Spotify responds to Apple, calling it a 'monopolist' - <AUTHOR> https://www.theverge.com/2019/3/16/18268811/spotify-apple-european-commission-antitrust-statement-war-of-words <comment><USER2> Kind of a silly argument as Apple has a monopoly on nothing except their own products. From a consumer point of view you can pretty much ignore Apple's existence and not even notice.

You wouldn't call Nintendo a monopolist because they dictate the rules of the Switch, would you?

The irony being that I think most Apple users are happy they've strong-armed their developers into a single payment product instead of everyone rolling their own. Android is a mess in this regard; I wish everything used Google Pay.

<comment><USER3> OK, Apple is avoidable but that leaves...one option, really? Still not enough. It sucks to have only two cable providers (usually both bad), even two political parties.

I'm leaning towards wanting legislation that treats _duopolies_ almost as harshly as _monopolies_.

If there must be only "two" of something, it at least shouldn't be two entities delivering _the whole stack_. Right now, if you like any _aspect_ of a system you have to accept the _whole thing_ : if you like Apple hardware, you need to like their software, their store, their other services, you can't just get nice hardware and mix in something else.

<comment><USER4> What are you saying the other option is? There're countless other options.

<comment> m-p-3 Other than Android, what else?

</comment></comment></comment></comment><comment><USER5> Will Google make GMaps for iOS as good as the android's counterpart? Or Microsoft to make office suites in MacOS same quality as the Windows counterpart? This is the reason why Apple has AppleMaps, Numbers, Notes, Music ... It's only be monopolist when iOS or MacOS become > 50% of the market, but this is not the case.

</comment><comment><USER6> I am a paid Spotify subscriber but I am not buying their arguments about Apple. Still, they are complaining to the EU, where some pretty brain-dead tech decisions have been made lately.</comment>


Lumnify – an interesting project that helps you hire the best developers - <AUTHOR> https://lumnify.com/ <comment><USER2> This is a very welcome and refreshing change to the usual "lets rip off old ACMICPC and Computing Olympiad O(N) dynamic programming problems and sell them off to gullible lazy recruiters". Yes, I'm looking at YOU Codility and a (shamefully YC funded alumnus) Hackerrank.</comment>


'Remarkable' MIP*=RE proof describes how to solve seemingly impossible problem - <AUTHOR> https://gizmodo.com/remarkable-mathematical-proof-describes-how-to-solve-se-1841003769 <comment><USER3> Here's a (relatively) concise explanation of the result for people without a background in the area:

Suppose a person comes to me, claiming some fact is true. How can I check whether they're telling the truth? I could ask them a series of questions, carefully chosen to expose any lie. Such a procedure is called an "Interactive Proof" (IP). It turns out, there is an upper limit to how 'complicated' the statement being proved can be, before I, a 'simple' verifier, can't possibly tell the difference between a true claim and a false claim. The limit is called PSPACE. Note that in order for the prover to prove such 'complicated' claims, the prover must be very 'complicated' itself - at least as complicated as the statements being proved.

How can we take things farther? Suppose that instead two people come to me, claiming some fact is true. Then, those two people are separated - they are not allowed to communicate. Then, I ask them both questions, again trying to ferret out lies. This procedure is called a "Multi-prover Interactive Proof" (MIP). Again, there is a limit to how 'complicated' the statement being proved can be before I, a 'simple' verifier, can't possibly tell the difference between a true claim and a false claim. This time, the limit is NEXP - <USER2> to be significantly more 'complicated' than PSPACE. Again, note that the prover must be capable of very 'complicated' computations to reach this point, but the only limit based on my ability to verify the proofs is NEXP.

Now for the new result:

How can we take things further? Suppose that again two people come to me, claiming a fact is true. This time, before the two people are separated, they divvy up some entagled quantum states. Then they're separated, and not allowed to communicate. Then, I ask them both questions, again trying to ferret out lies. This procedure is called a "Quantum Multi-prover Interactive Proof" (MIP*). This time, things are different: There is (basically) no limit on how 'complicated' the statement being proved can be before I, a 'simple' verifier, would not be able to distinguish true and false claims. (Basically) The only limit on the ability of the provers to prove things to me is their ability to discover the claims, not my ability to verify those proofs. That's roughly what saying that the limit is RE is saying - there's no limit.

<comment><USER4> > series of questions, carefully chosen to expose any lie

I don't understand, how this is possible. Is it assumed that every lie is necessarily a Bernoulli trial with a known probability? Because if not, what prevents a single oracle from telling consistently false story, taking into account all lies he told you before?

<comment><USER5> The solution is very careful construction of the questions. A working protocol puts a low upper bound on the prover's probability of successful cheating.

<comment><USER4> "Very careful" doesn't really explain much. If lie is not necessarily probabilistic (so we cannot figure it our based on frequency of some contradictory answers), and if we need an oracle at all (that is, there is some piece of knowledge we cannot possibly verify ourselves), why cannot oracle just always lie about that piece of knowledge and take this lie into consideration in all the other answers, to make story consistent?

I'm pretty sure there must be some additional constraints, otherwise I don't see how you could possibly detect a lie that you cannot verify yourself with a single oracle.

<comment><USER3> Here's an example of such a protocol, for the problem of graph (non)isomorphism.

Verifier: Here are two graphs, A and B. Are they isomorphic? (Same except for relabeling vertices)

Prover: No, they're different.

Verifier: Here's one of the graphs, with the vertices relabeled uniformly randomly. Which one was it?

Prover: It was A.

(Repeat 100 times)

Verifier: Ok, you got them all right. I believe you.

Here, we've forced the prover into a situation where if it's lying, and graphs A and B are in fact isomorphic, it can't know which graph we started with, before permuting. As a result, it can only guess which graph we started with and hope to get lucky, and we'll catch it with very high probability.

In contrast, if the verifier was telling the truth, it could figure out which graph we started with, and always answer correctly.

Here it is impossible for the prover to make its lie, "the graphs are not isomorphic" consistent with its later inability to tell them apart, after random permutation.

This kind of 'catching in a lie' is how interactive proofs typically work.

</comment></comment></comment></comment></comment><comment><USER6> One of the authors of this paper, Thomas Vidick, taught the Advanced Algorithms class I took at Caltech a few years ago. The dude is a genius, but the class kicked my ass. He would basically assign recently solved problems from the theory community as homework.

<comment><USER7> Yeah, assigning open/recently solved problems seems to be relatively common in graduate theory/aglo courses, at least relative to other subfields of CS and math. Not sure why. It always struck me as not the most productive use of problem set time. But then, what do I know about teaching theory :)

<comment><USER8> These classes often encourage you to collaborate - with others in the class, and also with outside resources. That is: they would encourage you to go read the paper, so long as you cited it as a source and provided a proof in your own words you had reconstructed from memory. The idea is to encourage engagement in the community and teach people to build off of existing results, a skill often overlooked in undergrad where that would have been considered cheating.

</comment></comment></comment><comment><USER9> I'm not going to claim I understand the complexity class discussion here, but what I find most surprising is the claim that this would make the halting problem solvable. There's a fairly straightforward proof by contradiction that it's not:

[https://en.wikipedia.org/wiki/Halting_problem#Proof_concept](https://en.wikipedia.org/wiki/Halting_problem#Proof_concept)

So how would the new finding override this? Or is it just <wiggles fingers> quantum magic that's running the proof in parallel in infinite entangled multiverses or something?

<comment><USER10> There are plenty of _oracle_ solutions to the halting problem. The simplest one uses the bits of Chaitin's constant, an incomputable number, to solve Halting in polynomial time. Of course, these solutions cannot be physically implemented (eg. calculating N bits of Chaitin's constant requires solving the halting problem for all N-bit machines, so the algorithm is "circular").

<comment><USER9> Yes, but my layman's understanding is that the oracle is a theoretical construct that knows in advance what programs halt and what don't -- but as you note, the real-world issue is that such oracles don't exist.

My question remains, how does this tie back to the proof? Is there a path to building such an oracle now?

<comment><USER11> No there is still no path to constructing such an oracle. The paper basically presents a result built off of a less trustworthy oracle (or set of oracles) that can potentially lie, but that still has unlimited computational power.

</comment></comment></comment></comment><comment><USER12> Here's one intuitive way to think about what this means:

Imagine that you stumble on two infinitely powerful computers that share a bunch of entangled quantum state. Further, let's say you know how to write software for them but you need a way to check that the answers are correct. And you want to know with near certainty that your programs ran correctly, even if one of the infinitely powerful computers is evil and will use its entire intellect to convince you of something that's untrue.

Aside: this means that cryptography doesn't work---you can't use the discrete log assumption to solve this problem, you can't use collision resistant hashing, etc.

Ok, so this paper shows that, if you can figure out how to program those computers to solve the halting problem, you can then create an error detection protocol (see below) that you can check on a laptop computer and that almost perfectly (like, except with exponentially small probability) detects errors in your halting detector's execution.

You can use your laptop to ensure that your infinitely powerful, possibly evil lunatic twin Hal2^9000s aren't lying to you. Or, as BFLS91 says, "controlling a herd of supercomputers from [your iPad]" ;)

(Your error detecting protocol checker must be verified, but it's not too complicated an algorithm and we basically know how to write certified computer software for our laptops.)

(Oh, and also note that you need a perfect random number generator, and your laptop has to communicate with the supercomputers while they're executing.)

[edit for slightly more precision]

</comment><comment><USER13> Some additional context from the always illuminating Scott Aaronson: [https://www.scottaaronson.com/blog/?p=4512](https://www.scottaaronson.com/blog/?p=4512)

<comment><USER14> this should really be the posted link, or perhaps the one Aaronson links to: [https://mycqstate.wordpress.com/2020/01/14/a-masters- project...](https://mycqstate.wordpress.com/2020/01/14/a-masters-project/). The Gizmodo article is not very good.

</comment></comment><comment><USER15> Perhaps a link directly to the arxiv page would be more appropriate?

[https://arxiv.org/abs/2001.04383](https://arxiv.org/abs/2001.04383)

<comment><USER16> I had some chance of vaguely understanding the Gizmondo article. Having browsed the arxiv paper, I wouldn't have had a clue what it was about or why it was important.

</comment></comment><comment><USER17> The paper: [https://arxiv.org/abs/2001.04383](https://arxiv.org/abs/2001.04383)

</comment><comment><USER18> An oracle that doesn't always tell the truth? That seems like an odd thing for an algorithm to have to deal with.

<comment><USER19> On the contrary, this happens all the time in the real world. You ask the user for a password. Maybe the user gives the right password maybe they don't.

</comment></comment><comment><USER20> I just came to say that the first paragraph of that article is so cringe- worthy I had to post... Terrible, argh...

But amazing result.

<comment><USER19> In fairness, its pretty hard to explain what MIP*=RE to a layman (or even to tech people if the comments on hn are any indication). At least the intro kind of evokes the feeling of what the problem is about, even if its pretty corny.

Just imagine, you're about to get a proof that some program halts and just before you verify it you are eaten by a grue.

</comment></comment><comment><USER21> I'm surprised this isn't getting more attention. If this holds it would imply a lot for a wide variety of fields.

<comment><USER22> Not understanding it myself, what I would _like_ for it to imply is that quantum computers are more capable than previously believed. I don't suppose it does mean that?

</comment></comment><comment><USER23> An excellent comment on the halting problem: [https://news.ycombinator.com/item?id=21561031](https://news.ycombinator.com/item?id=21561031)

The the linked Scott Aaronson blog and associated video are fascinating.

</comment><comment><USER24> Would be nice to have a writeup with some details on how this disproves Connes embedding conjecture understandable for operator algebraists with little (quantum) computing background

</comment><comment><USER16> Can anyone here provide more detail on the implications (particularly for physics) of the Connes embedding conjecture being shown to be false?

</comment><comment><USER25> I wonder what the physics implications are they mentioned?

<comment><USER19> Its beyond my understanding, but i think goes into it [https://www.ams.org/journals/notices/201910/rnoti-p1618.pdf](https://www.ams.org/journals/notices/201910/rnoti-p1618.pdf)

From what i read it has something to do with refuting the Connes embedding conjecture, but i dont actually know what that is

</comment></comment><comment><USER26> quantum entangled oracles which don't always tell the truth. science :'D</comment>


Try Redis in your browser - <AUTHOR> http://try.redis-db.com/

<comment><USER2> This tutorial should really encourage the user to type various commands as part of the tutorial, rather than allowing progress by just typing "next" over and over again. The great thing about the try-ruby tutorial was that it actually gets you to type ruby commands to get to the next bit, thus forcing you to try out the syntax rather than just read a tutorial.

<comment><USER3> I like this idea. Interactivity was on my mind while I was implementing the current version. There's lots of ways to improve the actual teaching process it offers, and it's something I'm interested in continuing to develop.

<comment><USER4> I guess you only saw trymongo but never experienced the original TryRuby? If not, please take a look at it :)

</comment></comment></comment><comment><USER5> I have never used Redis, or any other NoSQL database before, but have always been interested. I actually went through the whole tutorial, and now I feel like I have a better understanding of what all the fuss is about.

That being said, and this is outside the scope of the tutorial, but how are these key/data/NoSQL stores at storing up a large value (think of a TEXT or BLOB column)? Just curious...

<comment><USER6> For redis specifically, the maximum size of a value for a key is 1GB - <http://code.google.com/p/redis/wiki/SetCommand>

</comment></comment><comment><USER7> That was quick :-)

<http://twitter.com/antirez/status/9597858680>

Slicehost donated the vps it's hosted on.

</comment><comment> brown9-2 Being able to press the up key in the input textbox to scroll through your previous "commands" is a nice touch.

<comment><USER8> Yeah, I pressed the up key out of habit and was pleasantly surprised to find it did what I expected

</comment></comment><comment><USER9> We can use the command SET to store the value "bar" at key foo:

        SET server:name "fido"

Please, please, pretty please, make your examples match the text that tells you what the example does.

<comment><USER3> I fixed this item. Thanks for the feedback! :-)

</comment></comment><comment><USER10> Needs tab completion or a button to go next. Compared to reading docs this was already boring/waste of time after typing TUTORIAL and NEX...

<comment><USER11> The up arrow works.</comment></comment>


Dark Side of the Mac: Appearance and Materials - <AUTHOR> https://mackuba.eu/2018/07/04/dark-side-mac-1/ <comment><USER2> Frankly, I'm not sure I trust Apple to support this appearance API over time. They've been down this road before.

It's kind of funny/sad to see how Apple operates with APIs. None of these concepts are really "new": they were _there_ , in Carbon, prior to Mac OS 8, in the days when that OS was meant to support really elaborate themes.

The original theme APIs were huge, and 3rd parties were expected to adopt them as needed (e.g. using appropriate theme selectors for fonts and background patterns). For about a year, things looked really cool: you could create a great Platinum-esque UI for any custom control, and it would fit right in.

Then, they threw it ALL away for Mac OS X, ironically right about the time when an appearance-agnostic API would make a lot of sense. They didn't even bother to update their API implementation to ease migration: really trivial changes that would have been helpful, like "update the damned font/color/pattern value returned for X to resemble Aqua", were not done. This meant that an app full of seemingly-appearance-agnostic code would look like _crap_ under Aqua, and you had to _rip it all out_.

And it's not like Mac OS X didn't change its look. Heck, for a _long_ time you could find 3rd party app bundles chock full of images that were there _just_ to implement the Apple-Look-and-Feel-of-the-Week, because the SDK didn't offer _any_ reasonable way to do half of what they came up with.

So yeah, _14 versions later_ , the Mac wants to be appearance-agnostic again. Sounds great. My advice: always have the option of doing your own UI as a backup.

<comment><USER3> Windows also lost the ability to have multiple UI styles after Windows XP -> Vista, and has yet to recover it as far as I know. Microsoft also never officially exposed the API so you had to use performance-degrading hacks like WindowBlinds.

In my experience as a Mac + iOS user and developer for the past 8 years, and for the rest of my life before that on Microsoft platforms, Apple's record has been much better compared to Microsoft re: abandoning APIs or pulling the rug out from under devs.

Take NSDocument for example. It has been around for almost 20 years. All you usually needed to do was inherit from it and adopt its interface and your app would often get new features for free with each release of macOS, like autosaving and version histories.

The foundations for multiple UI appearances have been there since macOS 10.10 Yosemite, 4 years ago. They were hard not to notice.

As a user and developer I'm glad they took the time to work out a sensible implementation that is very easy to adopt now and makes good sense for the future. It definitely seems to be in a better spot than Windows' support for multiple appearances currently, if it has any.

If you see the WWDC sessions on Dark Mode, you might come to appreciate the thought and effort they've put into it:

[0] Introducing Dark Mode: [https://developer.apple.com/videos/play/wwdc2018/210/](https://developer.apple.com/videos/play/wwdc2018/210/)

[1] Advanced Dark Mode: [https://developer.apple.com/videos/play/wwdc2018/218/](https://developer.apple.com/videos/play/wwdc2018/218/)

<comment><USER4> You can say a lot of things about windows but abandoning apis isn't one of them. Windows is the king of backwards compatibility, for better or for worse.

<comment><USER3> DirectInput -> XInput, which dumbed down many of the advanced Force-Feedback features to the level that the simple Xbox gamepads could support, compared to the original Sidewinder line of awesome joysticks (another victim of Microsoft abandonment.)

Often not making many APIs available in their latest programming technologies like .NET/C# (at least initially.)

WPF, Silverlight, the "Metro" experiment that lasted for a single (!) version of Windows (8), and great discontinued apps like PhotoDraw, are some of the other cases that personally affected me.

<comment><USER5> > (!)

They changed the name to Modern UI, some reported [1] because it clashed with their German partner Metro AG. In any case Modern UI started with Zune and you could get for the time nifty looking media player for it on XP [2]. You can still see it in newer parts of Windows 10 with its aversion to skeuomorphic design, preferring text and minimalist 1 color icons.

[1]([https://arstechnica.com/information- technology/2012/08/micro...](https://arstechnica.com/information- technology/2012/08/microsoft-metro-out-windows-8-style-ui-in-amid-rumors-of-a- trademark-dispute/)) [2] [https://archive.ledfrog.com/2011/06/microsoft-zune- software-...](https://archive.ledfrog.com/2011/06/microsoft-zune-software- review/)

<comment><USER3> I was referring to that crippled subsystem with the fullscreen Start Menu/Screen and the touchscreen-compatible apps that launched from it, separate from the "full" "desktop" experience, where you had two versions of IE, Outlook, Skype etc. It was also all you could access on the now-abandoned Windows RT.

Is that dichotomy still present in Windows 10?

See, it's a confusing exercise to even figure out what their sub-platforms are supposed to be called. Apparently they are now "Universal Windows Platform (UWP) apps (formerly Windows Store apps and Metro-style apps)" [0]

Do they have access to the full feature set of DirectX etc.? Do they have support for multiple appearances, Dark Mode, etc.?

[0] [https://en.wikipedia.org/wiki/Universal_Windows_Platform_app...](https://en.wikipedia.org/wiki/Universal_Windows_Platform_apps)

<comment><USER6> Win32 is kind of legacy.

UWP is what was WinRT on Windows 8, they have just been improving it all these years.

Of course they have access to full DirectX 11 and 12.

All new APIs are UWP based, and with they learned with the Desktop Bridge for Win32, they changed their strategy and are now merging UWP and Wi32 into a single container/store model.

Some of the talks related with it were done at MSBUILD 2018, check MSIX, .NET Core 3.0 roadmap, XAML Islands, XAML Direct.

If they don't change direction, in a couple of Windows releases they will be merged, with UWP continuously taking over Win32, like Win32 did before to Win16.

As for Apple, I can quickly refer to Object Pascal, Quickdraw 3D, JavaBridge, Quickdraw Java APIs, A/UX, Dylan, Newton, MCL, Hypercard....

<comment><USER3> If this is to be a simple listout of products and services that were superseded or discontinued because it made no sense to continue them (as opposed to breaking promises or replacing them with inferior counterparts), then on the MS side we have:

Active Desktop, Briefcase, CardSpace, Meeting Space, NetMeeting, Windows Sidebar, Desktop Gadgets and Windows SideShow (which displayed gadgets in a secondary screen on laptop lids etc., kinda cool at the time but I never saw an implementation in the wild), Office Assistant (Clippy in the File Explorer), Encarta and the rest of the edutainment product line (which were actually great and often used as a selling point for PCs at the time), XP themes, HTML thumbnails, the Comic Chat IRC client (my first gateway to social interaction on the internet), the SideWinder game controllers for PC (including the Dual Strike [0] which was way ahead of its time), MSN/Live Messenger, Photo Gallery, Movie Maker, Visual Basic, FoxPro and many others... :)

[0] [https://www.youtube.com/watch?v=MShp4F4cUDE](https://www.youtube.com/watch?v=MShp4F4cUDE)

<comment><USER7> Maybe so, but none of yours (or even all of yours combined) are anywhere near as tragic as the cancelation of HyperCard. ;(

(Although Comic Chat was pretty cool, with all those Jim Woodring characters and backgrounds, and the emotional pie menu.)

[http://www.mermeliz.com/files/mschat_summary.htm](http://www.mermeliz.com/files/mschat_summary.htm)

One question: After being exposed to Comic Chat as your first chat client, do you now visualize everyone you chat with and your online environment as if they were drawn by Jim Woodring?

[http://www.jimwoodring.com/artwork/gallery](http://www.jimwoodring.com/artwork/gallery)

You lucky bastard!

[http://www.jimwoodring.com/wp- content/uploads/Bastard.jpg](http://www.jimwoodring.com/wp- content/uploads/Bastard.jpg)

<comment><USER3> I'm sure the end of Visual Basic (before the .NET impostor) was as much of a big if not bigger deal for many people as HyperCard. :p

The discontinuation of many of those things personally affected or disappointed me at the time. I distinctly remember mourning some of them:

\- Losing people who only ever used Comic Chat and didn't make the migration to other services.

\- The end of offline Encarta at a time when my internet wasn't very cheap, fast or reliable.

\- Owning some great PC joysticks but not being able to utilize their full haptic features with newer APIs, before the joysticks themselves went out of production, when Microsoft's console division cannibalized their PC gaming division.

\- A cool vector graphics editor [0] that worked better for me than Adobe or Corel getting discontinued after 2 versions.

The point of this whole thread is developer confidence, and I have felt betrayed and abandoned by Microsoft many times but I have yet to experience that during my time on Apple platforms.

Apple's current APIs are impressive and very forward-looking, and the only times I felt that optimistic about Microsoft was just before they broke their promises.

Cool link by the way, I hadn't known of Jim Woodring before today!

[0] [https://en.wikipedia.org/wiki/Microsoft_PhotoDraw](https://en.wikipedia.org/wiki/Microsoft_PhotoDraw)

<comment><USER8> Both HyperCard and VB were really great for personal computing because they made it relatively easy for people to start making their own tools.

I made my first game with HyperCard, sadly lost to time unless the floppy is still sitting in some middle-school computing lab's storage room and hasn't degraded beyond readability.

Even recently I had a hobby project where VB 1.0 for DOS was a quick and easy way to hack together a GUI.

I'm saddened by the fact that "modern" desktops are increasingly becoming consumption-only devices. Personal computing is near death and no one seems to care much.

<comment><USER3> > _I 'm saddened by the fact that "modern" desktops are increasingly becoming > consumption-only devices._

I have been lamenting the loss of the ability to code as soon as you switched on a computer, ever since I moved from a Commodore 64 to an IBM PC clone. :)

You can't even use $500+ devices as a simple calculator without an "app."

We need more stuff like Swift Playgrounds, preinstalled on operating systems, but would people care?

The first thing almost everyone wants to do is open a browser and log on Facebook etc.

<comment><USER8> Maybe those people are the majority of the market, but that market will be served by tablets, phones and desktop web kiosks. The market for actual personal computers still exists, it's just being ignored by everyone because it is relatively small, like it was before the web made computers interesting to the current majority user base.

</comment></comment></comment></comment></comment></comment></comment></comment></comment></comment></comment></comment></comment><comment><USER9> I haven't tried the latest macOS beta yet, but I remember a few years back finding a minor bug related this: neither Chrome nor Safari handled appearance / highlight color changes correctly. If I remember correctly, I think changing the value wouldn't be completely reflected on any open page until you either refreshed the page or restarted the app; it was one of those two, but I don't remember which. Funny enough, I think some colors did change correctly, but not all. Admittedly, I tested this out using CSS System Colors, which is sadly deprecated.

I vaguely recall finding a few bugs with Finder as well, where if you switched back and forth it wouldn't update all colors correctly. Of course, it worked fine after restarting the app... But if Apple's own apps have bugs relating to this, it wouldn't surprise me if it's a common problem for other third-party apps.

Another thing people might wanna try out relating to macOS appearance is going to System Preferences -> Accessibility -> Display, and enabling "Increase contrast". It makes some colors look a bit uglier, but I really love how it makes all UI elements stand out. For anyone that doesn't have macOS, or is too lazy to try it out, here's two comparison pictures:

* Default appearance: [https://imgur.com/W93o3Md](https://imgur.com/W93o3Md)

* Increased contrast: [https://imgur.com/oocjMPs](https://imgur.com/oocjMPs)

A bit tangential... I'm hoping that at some point you can use a media query on the browser to test for this value. For example, there's already prefers- reduced-motion [0] on WebKit. I've definitely seen a GitHub issue at some point suggesting that a similar media query be added for users that prefer higher contrast interfaces, but I can't find it at the moment. Unfortunately when I last checked it didn't seem like there was much interest; as usual, accessibility features seem to take a backseat with many browser vendors.

[0] [https://webkit.org/blog/7551/responsive-design-for- motion/](https://webkit.org/blog/7551/responsive-design-for-motion/)

<comment><USER3> > _Another thing people might wanna try out relating to macOS appearance is > going to System Preferences - > Accessibility -> Display, and enabling > "Increase contrast"._

You can also try increasing the "Display contrast" slider (to around the 3rd notch) while in Mojave Dark Mode, to remove the soft gray from the window chrome and replace it with truer black.

It affects all other colors of course, but it can improve reading/writing for those of us burning the midnight oil.

</comment></comment><comment><USER10> "Dark Side of the Mac" is a blast from the shareware past... [http://www.poubelle.com/DarkSide.html](http://www.poubelle.com/DarkSide.html)

<comment><USER11> "Kaleidoscope" [1] needs to be mentioned here as well. A brilliant shareware to apply a "scheme" (graphical theme) to classic MacOS. Wanted your UI to look like Windows, Copland [2] or BeOS? Kaleidoscope allowed you to do that.

Here's a link to previews of some popular schemes (from the Internet Archive): [https://web.archive.org/web/20060925184709fw_/http://www.kal...](https://web.archive.org/web/20060925184709fw_/http://www.kaleidoscope.net/schemes/schemespotlight.shtml)

Sadly, modern OS will probably never allow this level of customizability...

[1] [https://en.wikipedia.org/wiki/Kaleidoscope_(software)](https://en.wikipedia.org/wiki/Kaleidoscope_\(software\)) [2] [https://en.wikipedia.org/wiki/Copland_(operating_system)](https://en.wikipedia.org/wiki/Copland_\(operating_system\))

</comment></comment><comment><USER12> There should be a dumbed down version of this page to explain designers (and sometimes managers...) why the app is not using the exact #353535 grey they've specified in Sketch.

</comment><comment><USER13> i just read it as "NSA ppearance"</comment>


Ask HN: How long to become a senior in a different stack/language? - alex-berlin Right now I'm looking for different roles and there's a lot more Java/JVM based positions around me than Node.js, in which  I'd consider myself a senior.
At what point is it dishonest to apply as a senior for roles that use technologies you don't experience in?
Would expand this question to include:
- Cloud platforms (AWS, GCP, Azure, Heroku, etc
- Languages (different paradigm, differently typed, etc)
- other relavant points <comment><AUTHOR> Being a senior engineer is less about the language and more about your total experience and architecture knowledge. I haven't actively used Java in 10 years, but I'd have no problem applying for a senior position but I'd be very direct and honest about my current Java experience.

When I am hiring people for senior roles, I care less about the language they know and more about their actual experience. If you understand patterns you'll recognize them in any language. If you recognize good practices, they are the same across languages, for the most part. Architectures are less language dependent and more about experience.

Now, that said, there are parts of specific languages which are unique and you need to know the language well. So I am not discounting specific language knowledge, but I'd much rather have a senior engineer that knows their stuff from an engineering/architecture point and has worked in multiple languages than someone who just knows one language. So typically I only view people as senior if they know (have worked in) more than one programming language, but there are exceptions of course. Most likely a person who has 7 years of Java but has never worked in any other language is senior, but more so a senior Java person, than a senior engineer. So, they would not rank as high to me as the person who has worked in multiple languages in the same time period and solved various problems. Mainly because when you only know one language it is a hammer and you'll use it even if you need a screwdriver which is worse then they person who maybe has used 3-4 languages and is flexible about using what fits. Also, this typically goes to the fact when you get stuck in a single language on similar problems you typically have a narrow scope of knowledge. Of course, there are many exceptions, for example, the person who has worked only in Java but has worked at 3-4 companies on different problems will be a lot better then the guy coming out of a Fortune 500 firm where he worked on one product in Java his whole time there.

Hopefully that makes sense.</comment>


Show HN: New,Rising and Top YouTube videos from all channels - <AUTHOR> http://newonyoutube.com

<comment><USER2> An enhancement could be "by country".

You could also propose download button (downloading and removing ads with youtube-dl).

There is also almost free streaming solution with webtorrent.</comment>


Experts say China's Mars rover mission will benefit the military - <AUTHOR> https://www.wired.com/story/chinas-first-mars-rover-launch-could-make-history/ <comment><USER2> NASA's budget is $22 billion, while the Defense Department is $718 billion.

It would be nice if we could divert a little more DOD money into dual use that benefited space exploration, AI research, robotics, basic research, etc.

Sure, we could simply increase those civilian budgets but for some reason we don't see the value.

<comment><USER3> Why don't we just spend the existing budgets in a better way than funding SLS, Lunar Gateway, etc? Those sorts of boondoggles are just noise for the DoD but are critical losses for NASA (setting aside the social value of keeping a significant percentage of Alabama and Mississippi off welfare...:)</comment></comment>


I Switched from Visual Studio Code to JetBrains WebStorm - <AUTHOR> https://dev.to/mokkapps/why-i-switched-from-visual-studio-code-to-jetbrains-webstorm-939 <comment><USER2> And I (after using InteliJ for nearly 7 years) switched to Spacemacs and never been happier. VSCode becoming so popular, people think you're crazy if you're not using it. Monoculture is never good in any environment. It's great that we have different tools and everyone can find something that frustrates them the least.

</comment><comment><USER3> so basically he want to use a IDE, not a editor</comment>


Alternatives To Git Submodule: Git Subtree - <AUTHOR> http://blogs.atlassian.com/2013/05/alternatives-to-git-submodule-git-subtree/

<comment><USER2> One thing that submodules do better than subtrees is scale; in a subtree, everything is part of your repository (thus, index, and the associated problems with having having millions of files).

Submodules, on the other hand, have independent index files tied to independent repositories, so it's possible to not have a huge index anywhere regardless of total repository size.

<comment><USER3> One issue with submodules is if they rebase and GC out the commit you're pointing to, you're going to have a bad time.

This may not be a problem when pointing to the commit of a stable tag, but when pointing to a development commit that might be rebased out later, you may find the submodule not to work.

Not to mention if the server hosting the submodule is down and now all of a sudden you can't redeploy.

One workaround is to fork the submodule and point to a commit in your fork.

<comment><USER2> But that's basically not different than rebasing a public repo regardless of submodules or subtrees - all hell breaks loose

</comment></comment></comment><comment><USER4> Subtree makes the most sense when you have a component that is completely dominated by its parent, but which you want to also release stand-alone. For example, we use it for a build system that gets 90% of its use and testing (and essentially all its development) from one parent project, but is used in a few other much smaller projects.

Submodules provide weaker coupling and make the most sense when the submodule has its own healthy upstream and you want to track those versions. It's awkward if all submodule development is happening from within the parent.

My rule of thumb: If the sub-project has a test suite that is complete enough you can trust it, then use submodules or a different installation method. If the sub-project always needs the parent (preferably only one parent) to verify correctness, such that you prefer to make commits from the parent repository, use subtree.

</comment><comment><USER5> I introduced git at $DAY_JOB roughly 2 years ago and based it on submodules. We use the submodule subscription feature of Gerrit to lessen the pain [1]. So submodules are not _that_ bad but I really believe they are trying to solve a problem better solved by a dependency management system (maven and similar) instead.

So even subtree might be "easier" you should really try to solve your dependency problem using a resolver instead of your version control system.

[1] [https://gerrit-review.googlesource.com/Documentation/user- su...](https://gerrit-review.googlesource.com/Documentation/user- submodules.html)

<comment><AUTHOR> Oh I totally agree! If you can it makes sense to manage dependencies with tools that have been refined for years for the task like maven, gems, pip, npm, etc... I had this exact discussion with a colleague at Atlassian while writing about git submodule. Using git submodule or subtree might make sense if your environment is not homogenous, for example if you need to mix different languages and keep everything consistent. Even then you can use broader focus package managers like dpkg, rpm, apt, etc.

In any case I like the feel of git subtree as I have written in the post.

<comment><USER5> And I agree to this as well. :)

Our setup is quite special and in that case Gerrit/submodule subscription sort of works. But in hindisght we should have also tried to migrate to some generic packaging system. The reason for going with submodules was that we have ~1000 devs and most of their time they spend in their specific part of the code base. So we created submodules for these discrete parts so they wouldn't be "bothered" by changes to parts of the code base they don't normally access. Also we _thought_ there wasn't so many cross-dependencies between the repos, but this turned out to be false.

We have now started to look at subtree for another product but I hope we can go directly to some packaging/dependency tool instead.

</comment></comment></comment><comment><USER6> I've migrated all my project submodules to subtree after a number of frustrations, culminating in finding out that Heroku doesn't support submodules. But it's still a huge pain to actually push changes upstream.

Not counting the issues of submodule support by services that interact directly with Git repos, I think the big question is how often do you need to hit the upstream repo for pulls/pushes. If the answer is "not super often", subtree is probably lower maintenance. I think submodules are a little bit more natural in cases when you are making a lot of changes to the subrepo, particularly when it's more standalone. But even then, subtree is probably worth the extra bit of effort.

Actually, in cases when the coupling is very loose, I forgo both options and just check out the subrepo directly into the superrepo, and rely on .gitignore in the superrepo to keep them seperated.

At the end of the day, I think there really needs to be another strategy, and it would be great if there were a way it could be implemented in to the Git core. The concept of a modular project just doesn't seem to completely jive with the Git architecture. Anyone have any ideas how this could work?

<comment><USER7> what are the issues/implications of "just check out the subrepo directly into the superrepo, and rely on .gitignore in the superrepo to keep them seperated"?

<comment><USER8> When making a new checkout, you have to check out and keep the subrepo in sync manually. That is, unless you're using a dependency manager, which you probably should, as it will give you almost all of the advantages of submodules without their disadvantages.

</comment></comment></comment><comment><USER9> I've used this method:

[http://jasonkarns.com/blog/merge-two-git-repositories- into-o...](http://jasonkarns.com/blog/merge-two-git-repositories-into-one/)

... in order to manage a communication protocol library specific to two programs. Originally there was three repos (Program A, Program B and the library), that I merged into a single repository. I can merge changes from the older repositories, that are still active.

It looks that this method is a close ancestor of git-subtree.

</comment><comment><USER10> > There are several reasons why you might find subtree better to use:

> subtree does not add new metadata files like submodules doe (i.e. > .gitmodule).

So instead you have to memorize the exact information that in the .gitmodule file and type it in every time you run "git subtree" and then out of band communicate this information to your colleagues.

</comment><comment><USER11> My only problem with subtree merging is I have to look up how to do it everytime

</comment><comment><USER12> I would like to point out/plug an alternative to hg subrepos:

<http://mercurial.selenic.com/wiki/GuestrepoExtension>

I was part of the team that came up with it and I am inordinately proud of it. :-)

<comment><USER13> Does guestrepo support non-hg guestrepos (as subrepos does)? My beef with git submodules is it only allows git.

<comment><USER12> Sorry about the delay in answering.

No. Guestrepos does not handle non-hg repositories. I'm not offhand sure how complicated that would be. At some level, it should be very simple: `git clone && git checkout $rev`.

Pretty sure that a simplistic foreign implementation would work quite well.

</comment></comment></comment><comment><USER14> Not the same thing, but I feel like Bundler does a similar thing to git submodules (for Ruby only) but does it much better</comment>


Akamai launches HD Network that delivers TV-like, HD-quality video online. - <AUTHOR> http://www.akamai.com/html/misc/hdnetwork.html

<comment><USER2> _adaptive bitrate streaming_

Ah yes, Akamai as always picking features that maximize the money you owe them.

For the vast majority of content (e.g. anything not live), constant bitrate is a terrible idea: it wastes bandwidth in low-action parts of the video and cripples quality in high-action parts of the video. This is why no major non- live video site uses constant bitrate; it's a terrible idea.

Of course, if you want to maximize user quality at all times, you want to maximize utilization of their connection and adapt the bitrate to the bandwidth available. But in reality, bandwidth is expensive, so nobody does this except in live streams.

</comment><comment><USER3> For those not familiar with Akamai's current product lineup, the new features they've introduced here are:

1) HTTP delivery of live flash content (avoids royalty fees normally paid to Adobe for FMS, so ideally Akamai could lower their prices)

2) Improved analytics (current EdgeControl interface is tricky to use for individual videos)

The rest of the features listed are just current features wrapped up into a nice looking press release. In other words... move along, nothing to see here.

</comment><comment><USER4> I am not sure what they mean by "HD" but this is actually slightly worse than the HD clips on youtube.

<comment><USER2> One of the primary causes of this situation is the sheer atrociousness of most commercial video compression solutions.

Here's a little comparison I did a while back:

[http://x264dev.multimedia.cx/wp- content/uploads/2009/08/qual...](http://x264dev.multimedia.cx/wp- content/uploads/2009/08/quality_chart1.png) (full details at <http://x264dev.multimedia.cx/?p=102>)

Now consider the fact that the majority of websites are still using VP6 or Flash Media Encoder FLV, both of which are significantly worse than Xvid on the chart...

Of course, given that money doesn't grow on trees, many of the top players have switched--Youtube and Facebook are now using x264 almost exclusively, for example.

I would be entirely unsurprised if Akamai ended up being suckered by a company providing inferior solutions. Of course, _they_ don't lose anything by providing worse compression, since their customers pay them for the bandwidth.

<comment><USER5> One of the biggest problems we've run into doing h264 streaming is that there are a huge number of users that don't have powerful enough computers to decode and view h264 in a flash player when it's delivered at 720p. You need a pretty fast system to watch 720p video at even 3 Mbps in the Flash player.

And h264 over HTTP is just a download of the HTTP file starting from a specific marker unless I'm mistaken. Not exactly rocket science. It's HTTP after all...you can't control much of anything on the QOS side. The JW player has the capability to do that out of the box for most of the major CDN networks out there already.

<comment><USER6> The Flash player has a horrifically inefficient H264 decoder. One is almost led to wonder, at times, if it's interpreted. (This would explain a lot.)

HTTP pseudostreaming is, indeed, just a plain HTTP GET with a URL parameter (or an extra header) to indicate what byte position to start at, based on a seek index at the front of the file. It's incredibly "dumb", but trivial to implement even on a shared web host. (You can write the server-side component in a few dozen lines of PHP, for instance.)

<comment><USER2> _The Flash player has a horrifically inefficient H264 decoder. One is almost led to wonder, at times, if it's interpreted. (This would explain a lot.)_

The reason it's slow is that the compositing engine requires that the YV12 -> RGB conversion be done in software rather than in a hardware overlay. This is probably exacerbated by the fact that many sites _still_ seem to turn off the hardware accelerated display out. Note that as far as I know, all current implementations of HTML 5 video have a similar problem (compositing engine requires RGB input).

It's based on Mainconcept's decoder, which while not incredibly fast, isn't particularly slow either. Though I wouldn't be surprised if Adobe stripped out some of the assembly to try to make it smaller (or compiled it with -Os).

My advice for performance would be to disable CABAC; that can probably save 15-25% decoding time right off the bat at the cost of 10-25% compression.

<comment><USER5> Flash only supports hardware accelerated display when you're running full- screen in "kiosk" mode. That is not too useful.

What we've done is sacrifice some quality and encode using one of the mobile h264 profiles (I forget which profile off the top of my head). It essentially outputs h264 in a form that is easier to decode on the client side. It helped us eke out a few extra fps that helped quell an initial user revolt.

<comment><USER2> That's not necessarily a good idea.

Most of the higher profile features of H.264 actually _decrease_ CPU requirements at the same quality level, because they reduce bitrate required for a given quality (in particular, B-frames and 8x8dct).

The only things that significantly affect CPU usage are CABAC, deblocking, bitrate, and resolution. Sticking to a "mobile" profile (i.e. Baseline Profile) is needlessly slashing quality.

</comment></comment></comment></comment></comment></comment></comment><comment><USER7> When are they going to use P2P streaming download playback? Like bittorrent but for a youtube video? Or do they do that already?

<comment><USER7> Found it: they do have bittorrent streaming video - <http://www.bitlet.org/>

</comment></comment><comment><USER8> The flash demo jerked and jumped around in bandwidth a lot.

The SilverLight demo worked better, but the picture was worse than the Flash version.

BitGravity works wonderfully though. Also, we've been using Panther/CDNetworks without a hitch. They even support HTTP pseudo streaming.

<comment><USER9> _> The flash demo jerked and jumped around in bandwidth a lot._

Not only that it was taking 90% of my CPU to display something that did not look even close to 720p in size. And how can they get away with calling that looks more like 360p HD, anyway? I am not impressed.

</comment></comment><comment><AUTHOR> Akamai probably now has the largest video distribution capacity on the internet.</comment>


Design a $200, 100% GNU/Linux Basic Phone with Open Firmware, Make a Fortune - <AUTHOR> <comment><USER2> 1.) Designing and producing a hardware product and establishing the required supply chain is a huge undertaking. As a new player you'd probably end up at a much higher price point than that just to cover your costs. You'd also have to code all the phone-specific UI and APIs yourself.

2.) You probably also massively overestimate the demand for a smartphone based on free software.

</comment><comment><USER3> If that was true you would've started a Kickstarter instead of writing a post (title?) in HN :-)</comment>


The Go runtime scheduler's way of dealing with system calls - <AUTHOR> https://utcc.utoronto.ca/~cks/space/blog/programming/GoSchedulerAndSyscalls <comment><USER2> [https://marc.info/?l=openbsd- cvs&m=157500930922882&w=2](https://marc.info/?l=openbsd- cvs&m=157500930922882&w=2)

 _For dynamic binaries, we continue to to permit the main program exec segment because "go" (and potentially a few other applications) have embedded system calls in the main program. Hopefully at least go gets fixed soon._

 _We declare the concept of embedded syscalls a bad idea for numerous reasons, as we notice the ecosystem has many of static-syscall-in-base-binary which are dynamically linked against libraries which in turn use libc, which contains another set of syscall stubs. We 've been concerned about adding even one additional syscall entry point... but go's approach tends to double the entry- point attack surface._

[https://marc.info/?l=openbsd- tech&m=157488907117170&w=2](https://marc.info/?l=openbsd- tech&m=157488907117170&w=2)

[edit for convenience of readers - read the above linked thread - I just grabbed the go part]

 _Unfortunately our current go build model hasn 't followed solaris/macos approach yet of calling libc stubs, and uses the inappropriate "embed system calls directly" method, so for now we'll need to authorize the main program text as well. A comment in exec_elf.c explains this._

 _If go is adapted to call library-based system call stubs on OpenBSD as well, this problem will go away. There may be other environments creating raw system calls. I guess we 'll need to find them as time goes by, and hope in time we can repair those also._

[/edit]

<comment><USER3> Related (AFAIU): [https://news.ycombinator.com/item?id=21653119](https://news.ycombinator.com/item?id=21653119)

> We've been concerned about adding even one additional syscall entry point

I don't understand the need for such a severe "only libc syscalls ever" approach.

What would be the security concern with allowing syscalls only from preauthorized (ie msyscall(2)) regions, making initial region authorization opt-in (instead of opt-out), allowing the program to call msyscall(2) itself, and rejecting any statically linked (ie non-ASLR'd) regions for authorization?

<comment><USER4> > I don't understand the need for such a severe "only libc syscalls ever" > approach.

There's nothing severe about it. Most systems are exactly that: _systems_ of which the kernel is only one part, syscalls are rarely if ever intended to be called directly nilly-willy.

The issue is that unlike windows unices have never _enforced_ this.

<comment><USER5> Sorry, that generalization doesn't hold water.

It makes sense for systems where libc is tightly coupled and coversioned with the kernel, e.g. BSDs, but Linux always relied on third-party C libraries and supported static binaries, etc.

You could argue that BSD made the mistake of intending to have a Windows-style C library compat guarantee but not enforcing it, but that was not in scope for Linux. The philosophy has always been syscall-level compat (and there are lots of famous threads with Linus re-enforcing this to others who would presume that things should be "fixed in user space").

So it's hardly reasonable to generalize based on some BSD concerns; Linux is WAI and represents the most common Unix-like system people use today by far.

There's a pretty good argument that this level of compat, while the source of some problems, has also made other things much easier: consider container images that are bundled with their own system libraries. (You could certainly invent schemes to inject these libraries, but dealing with link and library level compatibility seems even more complex to deal with than system call- level compatibility.)

<comment><USER6> Darwin/macOS has the same rules as Windows and the BSDs--syscalls are private API--and it's extremely popular due to iOS. Linux is in fact the odd one out here.

<comment><USER7> There is a difference though: libSystem on Darwin is a very thin wrapper over the kernel syscalls; on the contrary, libc is a library that was designed for C, then standardized in POSIX, and has several layer of abstraction over kernel syscalls including many bad defaults that are universally recognized as wrong today (eg: libc's created file descriptors will all inherit by default).

<comment><USER8> > (eg: libc's created file descriptors will all inherit by default)

Isn't that the _kernel_ default? Even if you use system calls directly, file descriptors still inherit by default.

<comment><USER9> Yeah, libc's syscall wrappers just do what you tell them. If you don't pass O_CLOEXEC to the kernel syscalls, you get the inherit behavior. Libc's syscall wrappers don't change this in any way.

To the extent that Go's default for file descriptors today is !inherit (I'm unfamiliar, but if so, it's a good choice), the Go runtime must already add O_CLOEXEC to bare syscalls. There's no reason to believe it incapable of adding the flag to libc syscalls instead.

<comment><USER7> You can't do that atomically with libc. There's a short window in which the file descriptor will potentially be inherited, if another thread forks.

<comment><USER10> That's incorrect.

You are thinking of the older way, where fcntl(fd, F_SETFD, FD_CLOEXEC) must be used after open(), leaving a short window in which the file descriptor may be inherited.

The newer way passes the O_CLOEXEC to open() and there is no fcntl() call. This is atomic with respect to inheritability: The kernel returns a non- inheritable file descriptor to libc, and libc returns it to the application.

Other syscalls that return a file descriptor have similar flags, so they are atomic too.

These flags and behaviours are exactly the same, whether done by calling through libc as most programs do, or direct kernel syscalls bypassing libc, as Go and a few other programs do.

</comment></comment></comment></comment></comment></comment></comment></comment></comment></comment><comment><USER11> This scheduler is probably the most salient feature of Go, but is only indirectly described in the language specification.

Perhaps it is just me, but it seems all this user space rigamarole to map bits of execution onto cores points to an overall architecture "smell". This should be performed and enabled by the OS.

You can see the seams between the OS and the go runtime tear a little whenever a library acquires an ownership lock where the thread id is recorded. In Go, computation moves freely between threads, so that lock doesn't work (at least without special instructions to the runtime to lock that goroutine to a thread).

The whole POSIX threading model seems broken in this context.

<comment><USER12> POSIX threading is not broken, the Go scheduler just does a bunch of goofy things that aren't really supported. Moving stacks between threads breaks all kinds of things. A more idiomatic approach would be for the compiler to emit properly resumable functions, like most async/await implementations do.

<comment><USER13> The go runtime moves stacks between threads?

Oof that's horrible, any pointers to the logic behind it? I'm curious the rationale.

<comment><USER14> I think to keep Go code directly callable from C, they have to follow the platform's C calling conventions which means the same stack layout. So for cooperative concurrency on a single thread to work, each Goroutine needs its very own stack. On Intel, that means saving stack pointers RSP and RBP (16 bytes) for each. Also, each will need memory allocated for its stack for the stack pointers to point to... another 8-16 bytes (pointer and length).

<comment><USER15> The gc compiler, used by the vast majority of Go developers, does not use the C calling convention.

[https://golang.org/doc/faq#Do_Go_programs_link_with_Cpp_prog...](https://golang.org/doc/faq#Do_Go_programs_link_with_Cpp_programs)

</comment></comment></comment></comment></comment><comment><USER16> I would love to see a compare-and-contrast between the Golang scheduler and the Erlang scheduler, in the way they handle network-IO-heavy workloads. Maybe throw in the JVM scheduler, too (though its JIT would likely complicate things.)

</comment><comment><USER17> Makes me somewhat curious how go deals with a hung NFS mount ("hard mount"). I suspect everything would stop, where a normal OS thread wouldn't hang if it weren't interacting with NFS.

<comment><USER18> This should work fine. The goroutine making the system call that touches the NFS mount will consume an OS thread (an 'M' in Go terminology), but it will release its hold on other resources. Go uses as many OS threads as necessary to cope with running user code and doing OS system calls and so on (and starts new ones on demand).

If you had lots of goroutines do lots of things that stalled on hung NFS mounts, you would build up a lot of OS threads (all sitting in system calls) and might run into limits there. But that's inevitable in any synchronous system call that can stall.

(I'm the author of the linked-to article.)

</comment></comment><comment><USER19> A side effect of this scheme is that a long sequence of slow-but-not-that-slow syscalls becomes _extremely_ slow because the Go scheduler gets invoked each time.

</comment><comment><USER20> Nice read! I am not very familiar with this field of research but, could runtimes of other languages (say, Node.js or Python) benefit from such optimizations? What about libraries like libuv, I guess they must be fairly fine-tuned already? Or is this something that is specific to Go and would be hard in other contexts?

<comment><USER21> Go is one of the only languages that does syscalls itself (mostly because it's extremely high-risk and low-payoff), so some of its syscall-related techniques are not easily adapted to other runtimes.

<comment><USER6> Note that even Go only does syscalls itself on Linux. On macOS and Windows it calls into libSystem and kernel32.dll respectively, as the syscall interface is not stable on those platforms.

<comment><USER4> > Note that even Go only does syscalls itself on Linux.

AFAIK Go does syscalls itself on any platform but Windows and macOS, this includes all BSDs. And even for macOS despite that having never been officially supported it took multiple breakages a few years back.

The first thread here mentions the issues that causes for openbsd.

</comment></comment></comment></comment><comment><USER14> 1\. Does OS thread M get pinned to run only on a particular processor P? (It seems like "yes" when default.)

2\. If M blocks in a syscall too long in the optimistic case:

2.a. is M unpinned from P but continues to block until the syscall returns?

2.b. is another thread from the pool used or new thread created, and pinned to P so that P can be used for other work? (I think this depends on configuration if there are fewer, same or more threads than processors.)

2.c. is there an upper limit on outstanding blocked syscall worker threads or will it simply be the last task any extra created threads beyond the normal limit would ever process?

<comment><USER18> An OS thread M can run on any available P. While there are some caches associated with each P, Ps are fundamentally there to insure that only so many CPUs worth of Go user code is ever running at once, so the important thing is that an M that wants to run user Go code has _some_ P, not a particular P. Ms claim and release Ps as they go in and out of running Go user code, but I believe they don't release and then re-acquire a P as they switch between goroutines.

(I believe the actual implementation treats Ms as a sort of secondary thing. For instance, I think that the local list of runnable goroutines is attached to the P, not to the M. At one level, the M is just a context for running things on Ps.)

In the optimistic case when the system call blocks for too long, the M is unpinned from the P it was using and continues to sit in the system call (the Go runtime doesn't attempt to interrupt the system call itself). If there is another runnable goroutine and there are no free M's, the Go scheduler will create another M to run the goroutine on the now-free P. I think that the runtime directly allocates the free P to the newly created M rather than letting the new M try to contend with other things for the P, but I'm not sure.

I don't think there's any limit on the number of Ms (OS threads) that the Go runtime will create, but I haven't checked the code carefully. Idle Ms are reclaimed under some circumstances.

(I'm the author of the linked-to article.)

</comment></comment><comment><USER22> > For example, on modern systems the 'system call' to get the current time may > not even enter the kernel (see vdso(7) on Linux).

Is there a way to check from the running process whether that is the case or not?

<comment><USER23> Check whether it happened to do that for a given call or a portable way to predict whether it will?

dump_vdso [1] will write the vdso to stdout, you can use binutils like objdump or nm to list the symbols present.

[1] [https://kernel.googlesource.com/pub/scm/linux/kernel/git/lut...](https://kernel.googlesource.com/pub/scm/linux/kernel/git/luto/misc- tests/+/5655bd41ffedc002af69e3a8d1b0a168c22f2549/dump-vdso.c)

<comment><USER24> And if you wanted the same information at runtime, the base address of the VDSO is passed in as an auxv, and then passing that address into libelf would get you everything.</comment></comment></comment>