Why Online Education Won't Replace College—Yet  - <AUTHOR> http://chronicle.com/article/Why-Online-Education-Wont/133531/?cid=wc&utm_source=wc&utm_medium=en

<comment><USER2> "It's happened before. A college education used to be a rare thing. It was so rare that having one guaranteed you a job. But as incomes rose, more and more people started going to college. A bachelor's degree isn't exceptional anymore; it's expected."

This is a pretty common notion among those who have gone to college or are planning to. It's also definitely not true. While the latter part is, college degrees are often expected, I don't think anyone can frame ~30% of the adult population as any sort of overwhelming majority.

[http://upload.wikimedia.org/wikipedia/commons/0/03/Education...](http://upload.wikimedia.org/wikipedia/commons/0/03/Educational_attainment.jpg)

That said, the relative effects of the consistent increase in supply of college educated adults has clearly had an effect on the job market, and Bachelor's degrees are increasingly used as filters in hiring where they may not have been before, but it's fairly common to take this data point and extrapolate into unwarranted places, like arbitrarily reducing the number of people who go to college to enforce scarcity.</comment>


Are 80% of Harvard Students First Borns? - <AUTHOR> http://larrycheng.com/2010/03/06/why-are-80-of-harvard-students-first-borns/

<comment><USER2> Eh, thats not very good evidence of the claim, and wouldn't over 50% be first born anyway? I dont know the average distribution of child-sizes but I would assume almost half of people in the US are first borns (including only- children).

<comment><USER3> The "average number of own children under 18 per family" for "familes with own children under 18" was 1.86 in 2009 (and has been within 0.1 of that since 1978), which means about 1/1.86=~54% of all children are first-borns...

I don't think we have enough information here to actually verify but I suspect 80% vs 54% is still a statistically significant difference.

But it's pretty obvious that the 80% number is an arbitrary guess, so I'm not sure exactly where I stand here.

source: <http://www.census.gov/population/socdemo/hh-fam/fm3.csv>

<comment><USER4> No, it depends on the distribution. Let's say (as a first guess) that number of children follow a poisson distribution. A poisson distribution with mean of 1.84 has 74% of children being first borns.

There are a lot of reasons why a poisson model probably isn't great, but it's worth pointing out that a model with more density near zero is probably likely and implies that first borns are more popular than the they look.

74% versus 80% isn't anything to write home about.

Moreover, as Mz points out, only-children are a totally different case.

<comment><USER5> A Poisson distribution with a mean of 1.84 results in about 45% of children being first born. In fact, the best you can do with any distribution is 54%. For example, if there are 10k couples, then there will be 18.4k children born, at most 10k of which can be first born; and 10/18.4 = 54%.

In fact, the only thing that matters for the distribution (once you know the mean) is the number of childless families, since they could have had a first born but didn't.

I haven't been able to figure out where 74% comes from. Is there some way to sample on a per-family basis to come up with this?

edit: spelling

<comment><USER4> More like a fundamentally stupid mistake of inverting my parameters when I checked the number, getting a result in tune with the article, and then not thinking it through at all. It'd be possible to have a whole great deal of families with 0.1st children, but that's just the egg on my face.

</comment></comment></comment></comment></comment><comment><USER6> Inferring temperament from birth order is largely pseudoscience. Wikipedia has a good summary: <http://en.wikipedia.org/wiki/Birth_order>

"Birth order is defined as a person's rank by age among his or her siblings. Birth order is often believed to have a profound and lasting effect on psychological development. This assertion has been repeatedly challenged by researchers, yet birth order continues to have a strong presence in pop psychology and popular culture."

</comment><comment><USER7> There are many obvious problems with this argument:

1\. The 80% number seems to be pulled out of the air. It could be a counting error or a statistical aberration of that class, and the real Harvard number could revert to the mean.

2\. The type of parents who could send a child to Harvard is a biased sample of the general population. It will mostly tend towards rich, white (or asian) families, who generally will have less children.

There's definitely not enough information to infer that first-borns are any different.

<comment><USER8> Or maybe if they're not rich, they can't afford to send child #2 there.

</comment></comment><comment><USER9> I figured it was because the second and third born were too busy working their butts off in the military and the clergy to have time to spare.

</comment><comment><USER10> Interesting that although I am the second of two, the "Only Child" description matches me much, much more accurately than the others.

It's always the way that statistics are fine in aggregate, but for the exception, it's 100%. For me, the descriptions of the characteristics of the "child-by-place" are simply all wrong.

</comment><comment><USER11> I hesitate to say it, but maybe a lot of them are 'only' children and it relates (at least in part) to parental ability to afford Harvard? Just like big cities in America tend to have fewer kids because they are expensive to live in, so families move someplace they can afford to raise their kids.

<comment><USER12> This was my first thought as well, but my understanding is that if you are accepted at Harvard they will provide financial aid for 100% of need, which means parents pay what they can afford -- it can actually be cheaper to go to Harvard than a state school that doesn't have the funds to meet 100% need.

Maybe single children have better academic preparation? Should be easy to look at that.

<comment><USER13> Need is a hazy thing. They will meet all of what they define as your need, but what you "can pay" often means a substantial sacrifice when it comes to standard of living. This is especially bad if your parents have been paying what they "can pay" for the last 4 years for an older sibling.

Also, it's gotten a lot better in the last few years, which is after he moved through Harvard.

About 3(?) years ago, they, along with a few other upper-echelon colleges (I know Stanford did) moved to a much more liberal definition of need and totally got rid of loans from financial aid programs. Now, theoretically, if your family makes <$60k, you pay nothing, and <$100k you pay no _tuition_ , but pay room & board and such. There's more variables than just family income, and you always have to add to the "nothing" or the "no tuition" a reasonable figure for the student to make from having a part-time job during the year and full- time over the summer, but it's still substantially more generous than it was.

It would be interesting to see if those policies changed the percentage that are only children.

<comment><USER14> That's quite a liberal definition of "need".

<comment><USER13> Yes, it is. It used to be substantially worse, though, and other than a few top colleges, it still is.

Example of the difference: my "estimated family contribution" according to the FAFSA is about $10k more than what Stanford estimates they'll make me pay (though I haven't seen the final number, yet).

</comment></comment></comment></comment></comment><comment><USER15> These descriptions reminded me of horoscopes... I saw characteristics of myself in each one.

<comment><USER16> Yeah, that's the Forer Effect[1] at work.

[1] <http://en.wikipedia.org/wiki/Forer_effect>

</comment></comment><comment><USER17> Back when I took calculus in high school, the instructor asked for a show of hands for first-borns. All hands but one went up--well above 80%. I've wondered why that was so ever since. Why weren't middle and younger children pushing themselves to get into the "advanced" math classes?

<comment><USER18> Because parents put much more pressure on the first born.

</comment></comment><comment><USER19> Epic fail. All his descriptions do not even remotely describe me and my brother.</comment>


Print.css — only display what's needed - <AUTHOR> http://printstylesheet.com/ <comment><USER2> I was expecting a print stylesheet which hides header, footer, img, nav, menu and object html tags among other. Which reduces margins and paddings, and set the font-size of the text and h{1,6} to something reasonable. Also makes text black on white if it's not already the case, in order to spend as little ink as possible.

Instead, this is a not-that-funny joke, which will actually waste paper because of the sentence that will make the printed sheet not reusable for anything else than draft paper (and that's for people who won't throw it right away... :-/).

Then again, telling people not to print web pages when it's not an absolute necessity is a very good thing. But this print.css thing is not the solution. I don't understand the upvotes.

<comment><USER3> It's a joke (you seem to have noticed that). You are not supposedto use this.

</comment></comment><comment><USER4> The idea is nice, reminds me a little of that WWF idea of non-printable PDFs. [0]

But is something available that actually does the job? I remember this _readability_ thing [1], is there something comparable for printing, too? Like a browser plugin or generic userscript...

[0] <http://en.wikipedia.org/wiki/WWF_(file_format)>

[1] <http://www.readability.com></comment>


Demonstrations of sampling, quantization, bit-depth, and dither [video] - <AUTHOR> http://xiph.org/video/vid2.shtml <comment><USER2> Excellent video, such a pleasure to watch. Even with all the equipment and setup problems, labs are such a good memory...

(Just a minor thing but I thought that the video suggested that the Gibbs phenomenon was a result of the finite decomposition instead of, unless my memory is misleading me, being a sort of fundamental feature of the piecewise smooth square wave function)

<comment><USER3> Most xiph videos are of very high educational quality.

</comment></comment><comment><USER4> There are a lot of basic errors in this. It may impress someone who doesn't know anything about the technology - nice vintage gear collection - but that doesn't keep it from being factually wrong.

Just one example: the true SNR of a professional reel to reel tape master recorder is somewhere around 100dB - e.g. a Studer A series (around 75dB SNR @ 30ips) with Dolby SR noise reduction (about 25dB of noise reduction.)

Anyone who knows so little about recording equipment they think this is equivalent to 13 bits of digital resolution shouldn't be making videos about this subject.

<comment><USER5> Well, it is equivalent. Not in terms of what a played back sound is like, because tape and digital both introduce characteristic artifacts, but in terms of "this signal peak is so many dB above the noise floor."

If you actually code some audio DSP(and I do), you quickly learn that there are a lot of ways to color sound that aren't quantified except in a very broad statistical sense, but are measurable in audition. What digital is very good at is the basics of reproduction with a (statistically) uncolored result. At artistic effect, it is somewhat more limited; a lot of compute time and engineering has to be thrown into reproducing some straightforward analog world things and model accuracy still has room for improvement even now.

If you want to quibble with the video, do so on its terms. It isn't saying that digital is better, it's saying that digital is better at a very specific task.</comment></comment>


Videos from PyCon 2016 - <AUTHOR> https://www.youtube.com/channel/UCwTD5zJbsQGJN75MwbykYNw/videos <comment><USER2> The accompanying slides will be available here soon* alongside most other PyCon 2016 sessions.

[https://speakerdeck.com/pycon2016](https://speakerdeck.com/pycon2016)

*Currently blocked by a bug in Speaker Deck [ticket filed]

As a workaround in the meantime, you can access several decks from Google's cache by copying a URL from here, then searching it prefaced by "cache:".

[http://webcache.googleusercontent.com/search?client=safari&r...](http://webcache.googleusercontent.com/search?client=safari&rls=en&q=cache:https://speakerdeck.com/pycon2016&ie=UTF-8&oe=UTF-8)

</comment><comment><USER3> Awesome keynote today by NumFOCUS ([http://numfocus.org](http://numfocus.org)) board member Dr Lorena Barba ([http://lorenabarba.com](http://lorenabarba.com)):

"Beyond 'Learning to Program' — Education, Open-Source Culture, and Structured Collaboration in Language"

[https://www.youtube.com/watch?v=ckW1xuGVpug&t=32m30s](https://www.youtube.com/watch?v=ckW1xuGVpug&t=32m30s)

</comment><comment><USER4> User-friendly view:

[https://www.youtube.com/channel/UCwTD5zJbsQGJN75MwbykYNw/vid...](https://www.youtube.com/channel/UCwTD5zJbsQGJN75MwbykYNw/videos?sort=dd&view=0&live_view=500&flow=list)

</comment><comment><USER5> Great stuff.

I wish they had a longer summary. The best titles have such a huge advantage even though poor titles can have great content.

<comment><USER2> The full description & abstract for each talk are available on the PyCon site.

[https://us.pycon.org/2016/schedule/talks/list/](https://us.pycon.org/2016/schedule/talks/list/)

</comment></comment><comment><USER6> Holy moly, same-day videos.

Pycon does so many things right.

<comment><USER7> Except get the audio working. I've tried to watch 5 different videos and only one had working audio. This is on an Android phone via the YouTube app</comment></comment>


Compose.com (old MongoHQ) kidnapping data? - <AUTHOR> Well, without previous warnings, in one month they stopped their free service and archived the data of the users.
Now, if you want your data back, you have to pay.
Is it a blackmail strategy?
It is terrifying to know we trust our data in a company that do this. Well, not anymore. <comment><USER2> Do you have an email to prove those claims?

I worked with MongoHQ before they became Compose (not the free version) and they were really nice people.

Usually when a company does something like this (canceling free or something) they let you know in advance so you can take measures, didn't they let you know in advance?

<comment><USER3> Here's the email I got Nov/3rd, a 20 day warning. I haven't used it actively so I wasn't affected.

Subject line: Important: Your Compose/MongoHQ Sandbox Database

Sandbox Retirement

Since 2011, we've provided free access to our platform under the "Sandbox" plan. Thousands of individuals and businesses have had the ability to experiment, learn, and grow their use of MongoDB.

As the saying goes, "all good things must come to an end". The server "lennon.mongohq.com", where you currently have a database, will soon be sunset.

Data stored within Sandbox databases on lennon.mongohq.com will be permanently deleted on November 23, 2016.

We would love for you to migrate your data to our rock-solid paid plan, where you can access a trove of new features, enjoy super-fast speed, high- availability fault tolerance, and more.

        If you no longer need your Sandbox database, we'll automatically and securely remove it from your account on November 23, 2016.

        If you need your Sandbox database, you'll want to migrate to a paid plan or otherwise archive your data. You can perform all these tasks within the Compose dashboard.

        Heroku user? You'll need to follow these instructions to migrate your Heroku add-on.

Any questions? Just reply to this message to open a support ticket and we'll help you out!

This is a one-time email sent because you have a database with Compose. You will not be emailed again.

<comment><USER2> That's what I imagined it is. Not quite what OP described... Proper notice, enough time to migrate away. Looks fair

<comment><AUTHOR> Maybe I used to better companies like Google and Facebook, that alert you many times, using distinct communication ways, to avoid spam issues etc.

Parse.com (from Facebook) for example, give us 1 year and lots of warnings..

Google Reader also give us 1 year and lots of warnings..

Well, I am very disappointed the way the company treats this very serious subject. I almost lose very important data. So, I had to alert other people about this.

<comment><USER4> Your expectations are unreasonable. Few orgs have Google or Facebook resources.

Any notice is better than just closing down without notice, which would entirely be within their right. Keep a copy of your data at all times if it's valuable.

<comment><AUTHOR> This is not about rights. Blackmail is a legal and completely honest strategy if the user agree with that. A good example is the Ashley Madison deal.

This is not about resources either. The company should handle their resources with responsibility.

This is about ethics and responsibility. Ethics because the user did not agree with the blackmail strategy when he start to use the system.

<comment><USER4> They have no legal obligation to their users to continue their service for a period of time. Do not rely on a cloud provider for your data if you're not prepared for it to disappear at any time.

<comment><AUTHOR> wow!</comment></comment></comment></comment></comment></comment></comment></comment>


Wasmer: A Python library for executing WebAssembly binaries - <AUTHOR> https://github.com/wasmerio/python-ext-wasm <comment><USER2> Looks good! Just for my understanding, what would be the advantage of working with wasm binaries instead of, let's say, C external libraries or DLLs via ctypes?

I can think of: 1\. Portability of the wasm binaries

Is easier interoperability between data types an advantage as well? Ctypes can be a nightmare when passing around structs and pointers (and pointers of pointers, etc.)

<comment><USER3> I have an actual real-world use case for this :)

Shader-cross-compilation for 3D frameworks:

[https://floooh.github.io/2017/05/15/oryol- spirv.html](https://floooh.github.io/2017/05/15/oryol-spirv.html)

I'm hooking python scripts as custom-build-jobs into C/C++ projects which (for instance) takes care of compiling GLSL shader code into HLSL (D3D), MSL (Metal) and various GLSL versions (for GLES2, GLES3 and desktop GL).

Khronos provides C++ projects which help with this stuff:

[https://github.com/KhronosGroup/glslang](https://github.com/KhronosGroup/glslang)

[https://github.com/KhronosGroup/SPIRV- Cross](https://github.com/KhronosGroup/SPIRV-Cross)

So I'm using Python to hook my custom build jobs into the C/C++ build system (via cmake), _but_ I still need to invoke native command line tools (or DLLs) which wrap around those Khronos libraries. Currently this means building (at least) 3 executables for Windows, macOS and Linux, and "distribute" those precompiled exes with my python code.

It looks like with this python+wasmer solution, I can instead compile the Khronos libraries into WASM modules, and the result runs "anywhere" where wasmer runs (e.g. also Raspberry Pi, BSDs etc...).

That's really cool stuff :)

</comment></comment><comment><USER4> This looks great, I like the simple examples which show how to get a string out from the web assembly module. One thing I didn't see in the readme or examples, however, is a way to import python functions to the web assembly modules. Is it possible, and just missing from the documentation atm?

<comment><USER5> We don't support that yet, but we are working on it. It's not that easy even if the theory is kind of simple to explain. The implementation in the different backends is mostly the challenge. The Python extension uses the Wasmer runtime ([https://github.com/wasmerio/wasmer](https://github.com/wasmerio/wasmer)) which supports 3 backends to generate executable code: Singlepass, Cranelift, and LLVM.

Cranelift is the easiest one to embed, and it brings a great balance between compilation time and execution time. That's the one used in the Python extension right now.

The "import functions" feature is also missing in the PHP extension ([https://github.com/wasmerio/php-ext-wasm](https://github.com/wasmerio/php- ext-wasm)), but yeah, as I said, we are working on it. It's coming soon!

<comment><USER6> Once you allow to call Python, keeping things sandboxed becomes pretty hard, doesn't it?

<comment><USER7> It's often for code that is asynchronous that will not return an answer immediately... the function passing is most often used to send a callback for these situations.

<comment><USER6> A state-machine, generator or coroutine can be used instead of callbacks.

I mostly prefer only having one direction of who-calls-who when combining multiple languages. Though I understand that for a general purpose system like Wasmer it makes sense to support everything, so that users can choose the architecture.

</comment></comment></comment></comment></comment><comment><USER8> This looks really fun to use for algorithmic trading (we have to deal with and sandbox client code not written by us here at KloudTrader). Wonder how hard it is to integrate with numpy etc.

<comment><USER9> I'm sure there are better ways to do this, but if you really want Python client code -> WASM -> Python host, I'd imagine you could probably run [https://github.com/iodide-project/pyodide](https://github.com/iodide- project/pyodide) within Wasmer. But you'd likely lose a lot of the performance benefits of numpy etc. being compiled for the exact intrinsics supported by your host CPU. Container-level sandboxing still sounds like a superior bet.

<comment><USER10> Container level sandboxing is pretty difficult to do well without hypervisor/VM support.

</comment></comment></comment><comment><USER11> This is awesome! I wanted this so much. Need to play with this asap.

</comment><comment><USER12> "Safe: All calls to WebAssembly will be fast, but more importantly, completely safe and sandboxed."

That's a very bold statement, I see no backup of this in the readme.

<comment><USER13> It's a side effect of the design of WebAssembly, as long as wasmer itself has a conformant implementation (the WASM spec itself is already formally verified).</comment></comment>


Simple, Fast and Safe Manual Memory Management (2017) [pdf] - <AUTHOR> https://www.microsoft.com/en-us/research/wp-content/uploads/2017/03/kedia2017mem.pdf <comment><USER2> > we just add a delete operator to free memory explicitly and an exception > which is thrown if the program dereferences a pointer to freed memory.

Is there any sensible thing to do when this exception is caught, appart from halting the program? If the answer is "no", why have an exception at all?

<comment><USER3> Long ago I worked on a 3D scene exporter for 3DS MAX. It was complicated, unreliable code built on top of a complicated, unreliable interface. I put a big structured exception handler around the entire Export() process so that when random stuff went horribly wrong, I could pop up a dialog saying "The export failed. But, at least MAX didn't crash. An error has been logged. You should back up your work and restart MAX now."

<comment><USER4> this alone is the main selling point of exceptions

</comment></comment></comment><comment><USER5> Here's a video by one of the team members:

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

<comment><USER6> Thanks, that's very helpful.

</comment></comment><comment><USER6> Access to deleted objects is detected by marking objects deleted and not reclaiming their memory until the containing pages are mostly full of deleted objects, then they relocate still-live objects and unmap the pages. That is, they use MMU tricks but they amortize the MMU cost (otherwise performance would be absolutely abysmal).

Note that they still need to rewrite object references, which is a lot like a GC. EDIT: No, sorry, they lazy patch references, though this requires some overhead.

Also, this does nothing to protect against leaks.

Interesting idea, but too-little-too-late. I think Rust is the better answer for now.

EDIT: Great question from the Q&A of the video, "why are you not getting killed by TLB misses?", and the presenter did not know. This is a really important question.

</comment><comment><USER7> I just skimmed the paper since I should really get to bed, but:

> We do not guarantee that all dereferences to deleted objects will throw an > exception.

What happens in the case where the dereference doesn't throw an exception? Execution proceeds as if the dangling pointer pointed to the "zombie" object?

<comment> v-yadli the paper says that if the referenced object is not yet destroyed, the access is valid and the execution will proceed.

</comment></comment><comment><USER8> I wonder what would happen if you just keep on allocating and never free anything. The system would eventually swap out everything that should be freed. A 64-bit process has plenty of address space, and hard disks are huge.

Of course, there is probably some huge painfull punishment in store if you try this in real life. I just wonder which. Your average GUI process that shuts down every day or so maybe wouldn't suffer too much.

<comment><USER6> Fragmentation will mean that a very much larger number of pages than is needed to store the heap will be frequently referenced, thus thrashing. Even with SSDs thrashing would be too painful.

</comment></comment><comment><USER9> I really like this paper. There's a large class of problems where tracing GC is very suboptimal from a performance/efficiency perspective but classic manual memory management is unacceptable from a security/correctness perspective.</comment>


Emacs and TLS - <AUTHOR> https://lwn.net/Articles/759370/ <comment><USER3> > It isn't the Emacs way to second-guess our users' needs, definitely not to > decide for them what is and what isn't a matter of life and death for them. > We provide options with some reasonable defaults, and then let users make > informed decisions which defaults are not good enough for them.

> It is IMO unreasonable to make our defaults match what happens in > dictatorships that you describe, because that would unnecessarily > inconvenience the majority of the users. Let's not follow the bad example of > the TSA (whose rationale is, unsurprisingly, also matters of life and > death).

Here's that same response in an alternate Gnuniverse where software development is... different...:

"Thanks, Jimmy. Security is outside my wheelhouse, so let me run your ideas by a security researcher I already know and trust. Then we'll figure out the most effective way to improve TLS in Emacs without creating a maintenance burden for the project.

Best, A sensible developer who knows what they don't know"

<comment><USER4> LOL, if only. It'll certainly save me a lot of work.

//edit BTW, those aren't my words, those are Eli's responding to Perry

<comment><USER3> It is funny, but I didn't mean it as a joke.

It should generally be possible to predict the range of responses when submitting a patch to a free software project, or when posting to a free software list. If the input is "TLS" and the output is "TSA," it puts a strain on _everyone_ and free software development suffers as a result.

</comment></comment></comment><comment><USER5> Why is a tradeoff between convenience-and-security being considered? It's a false dichotomy - Firefox and Chrome are secure-by-default and I do not find them inconvenient at all.

Can emacs adopt their settings wholesale?

<comment><USER4> I agree. Many of the checks in my "netsec" branch does take inspirations from Firefox and Chrome. However, there's a fundamental distinction - <USER2> currently has 4 security levels (hopefully soon reduced to 3), whereas browsers only have one. There are also a few RFCs that demand terminating your connection say when you've negotiated SSLv3. Emacs doesn't terminate and won't terminate before asking the user first (with caveats). Another difference is Emacs is used for all kinds of comms including email and Jabber, so browser practices may present compatibility problems with protocols other than HTTP. This is something that needs to be tested when my branch is merged into master, but this is difficult, as the current strategy seems to be just wait for a while and see if anybody complains. There's also a tendency for some people to avoid the emacs mailing lists, so the signal, or lack there of, may not be representative.

<comment><USER6> > There are also a few RFCs that demand terminating your connection say when > you've negotiated SSLv3. Emacs doesn't terminate and won't terminate before > asking the user first (with caveats).

That seems bad. There's plenty of evidence that if you ask the user "hey, do you want to continue but be insecure?" they'll blindly click "yes".

While non-browser focused protocols may still rely on clients not forbidding insecure protocols, we should absolutely be trying to move away from blindly allowing insecure protocols (or effectively allowing them, given users typically click "yes").

I'd _strongly_ suggest failing hard, and allowing per (host, port) exceptions in the config file, rather than asking every time.

<comment><USER4> A number of people on emacs-devel, and IIRC, RMS too, suggests that we should not be over-protective parents of Emacs users, and on most levels, I agree. While this might seem like a strange philosophical position to take when it comes to security, I don't think it is (or will be) the case for Emacs. An Emacs user can override pretty much everything Emacs does, and there are well- defined options where you can force a cipher suite or bypass NSM completely. This might sound dangerous, but it's necessary in the event of a new TLS attack was discovered, and that Emacs' default is vulnerable, the user can easily override Emacs' and GnuTLS' default outside of both of these project's release cycles. Given how infrequent Emacs releases, I think this is the right approach.

<comment><USER7> > _A number of people on emacs-devel, and IIRC, RMS too, suggests that we > should not be over-protective parents of Emacs users, and on most levels, I > agree. While this might seem like a strange philosophical position to take > when it comes to security, I don 't think it is (or will be) the case for > Emacs._

I've been a heavy Emacs user since 1997, using it as my primary editor on all platforms. (In the last year or so, I've been mixing Emacs and Visual Studio Code, because of the latter's solid support for particular language servers.)

I am completely horrified at the suggestion that it might be OK for Emacs to have have insecure TLS defaults. This would be an absolute deal-breaker for me (and would almost certainly result in Emacs being banned at work, with no objection from me).

I do not have the time to fix every Emacs install on every server to be secure with the latest TLS standards. I need to be able to trust the developers of the software I use to get this right. I do not want to worry about whether `package-install` has been affected by a MITM attack.

<comment><USER4> I love Emacs, but if I'm to be honest, if network security is of concern per a company's policy, Emacs, any version of it past and present, should be immediately banned.

</comment></comment></comment></comment></comment></comment><comment> move-on-by > Pinning is what is done by sites like gmail to prevent third world > dictatorships from using stolen certificate credentials to spy on their > citizens. People who have been victims of this have had their email read, > been arrested by state security forces for dissent, and have been tortured > to death for lack of certificate pinning working in their browsers.

Well, this is awkward - Chrome has deprecated HPKP in favor of a new header: 'Expect-CT' [1]. The new header requires any cert to have a valid certificate transparency log entry and has reporting features as well [2]. This is slightly different - the scenario above would be allowed to happen and would be be valid, but that it would be logged publicly. Whatever CA (dictatorships) had issued the cert would lose their trusted status. But then again, if you have a dictatorship, then you can require that your CA remains trusted and the burden of removing trust to your dictatorship CA would be on individual users.

[1]: [https://www.zdnet.com/article/google-chrome-is-backing- away-...](https://www.zdnet.com/article/google-chrome-is-backing-away-from- public-key-pinning-and-heres-why/) [2]: [https://scotthelme.co.uk/a-new- security-header-expect-ct/](https://scotthelme.co.uk/a-new-security-header- expect-ct/)

<comment><USER8> > if you have a dictatorship, you can require that your CA remains trusted

How?

I mean, I suppose you could mandate that all computers sold in your country come preinstalled with state-approved monitoring software. But barring that, what's going to stop users from downloading the latest version of Firefox which includes code marking your CA as untrusted?

<comment><USER9> A police baton

<comment><USER8> Used against whom? The Firefox/Chrome/Microsoft/Linux developers don't live under your dictatorship.

<comment><USER10> The people who sell the computers in your country.

</comment></comment></comment></comment></comment><comment><USER4> I'm the new guy mentioned in the article. This article is a bit late to the party and misses a lot of details that I've discovered since June.

One of the reasons prompted this giant thread on the emacs-devel mailing list is when I was updating my Emacs config to try out Gnus for email and newsgroup, I discovered that no one seems to know exactly what a good TLS Emacs config should look like and that Emacs comes with horrible defaults. In addition, I was shocked that I've been exposed to a dozen TLS vulns that might cause arbitrary code execution the whole time since package.el became a part of Emacs back in circa-2013. After stuffing myself with about a dozen RFCs and many dozen more papers and Chrome and Firefox blog posts, here's what I found very concerning:

1\. The initial "a bit concerning" and "very concerning" qualifiers I originally posted aren't as clear cut anymore, most of the 2 dozen failing badssl tests are actually quite bad.

2\. NSM has got half a foot in the 2010s and half a foot in the 2000s. The latest stable version of Emacs (26.1) only checks for SHA1 end-certificate, usage of SSL, DH < 1024 bits and a noop RC4 cipher check (GnuTLS actually calls it ARCFOUR).

3\. The half-done pinning mechanism does Trust on First Use while the user can't even see the entire cert chain or the end cert.

4\. Only one fingerprint per host for TOFU, where Google low balances at least between 2 end-certs AFAIK.

5\. Excessive and theatrical prompts for any URL that has not been visited on a security level called 'paranoid.

6\. Multiple prompts for different problems found for the same TLS handshake.

7\. Setting one option in a configuration group called GnuTLS to true bypasses NSM entirely. i.e. no cipher suite checks and happily accepts any 256-bit DH key exchange attempts.

8\. No attempt to do any OCSP or Certificate Transparency revocation checking.

9\. 4 packages intermingled with each other all securing some network connections badly with no documented relationships between them.

10\. Virtually no one who has commit access to the Emacs repo understands TLS.

11\. RMS prefixes every one of his email with:

      [[[ To any NSA and FBI agents reading my email: please consider    ]]]
      [[[ whether defending the US Constitution against all enemies,     ]]]
      [[[ foreign or domestic, requires you to follow Snowden's example. ]]]

while Emacs's network security settings is basically saying please come fuck me.

The good news is, a few of these problems are already fixed on master and I've pushed a branch called "netsec" to the Emacs repo last week that fixes most of the rest. OCSP is coming this weekend. CT is going to wait quite a bit longer as GnuTLS has no plan to support it anytime soon. I have hope to make at least some of these security fixes to Emacs 26.2 or 26.3 in the short term. Medium term plan is to lobby for requiring TLS for all email protocols because RFC 8314. The long plan is obviously support TLS 1.3 for Emacs 27, and possibly HTTP2.

<comment><USER11> Question: Wouldn't it just be easier for Emacs to link to libcurl which has pretty much reasonable defaults (afaik, correct me if I'm wrong). The result would be that Emacs wouldn't need to link to a specific TLS library or have to maintain this. libcurl's API has a good reputation for not breaking :-)

Also big thanks for putting this work into Emacs. I use Emacs for hours at least every work day and many non-workdays as well.

<comment><USER12> Emacs uses TLS for more than just HTTP. SMTP+STARTLS for instance…

<comment><USER13> You were saying: [https://stackoverflow.com/questions/14722556/using-curl- to-s...](https://stackoverflow.com/questions/14722556/using-curl-to-send- email)? :D

<comment><USER12> Fair enough, but does it do nntp, irc, pop, imap, jabber, etc? Emacs (for better or worse) has a complete network API so people can implement all of these things, and it doesn't want to be limited by a high-level library that only supports some small subset (however large that subset is).

<comment><USER13> If you push hard enough...: [https://curl.haxx.se/mail/lib-2012-02/0234.html](https://curl.haxx.se/mail/lib-2012-02/0234.html) :)

</comment></comment></comment></comment></comment></comment><comment><USER14> I am missing something here. Emacs is a text/programmer's editor (I know you browse the web, read email, talk to eliza, etc...), but where is TLS being used exactly? (BTW, I have been using emacs since at least the early 90's, but never did anything requiring TLS).

<comment><USER15> Do you ever install packages from Emacs? If so, you _definitely_ want that to be at least TLS protected.

[https://glyph.twistedmatrix.com/2015/11/editor- malware.html](https://glyph.twistedmatrix.com/2015/11/editor-malware.html) is a post describing the problem and some solutions. I haven't checked to see how many of the steps are still necessary on Emacs 26, but I bet it's still non- zero.

<comment><USER16> >Do you ever install packages from Emacs? If so, you definitely want that to be at least TLS protected.

Wouldn't it make more sense to sign individual packages so that it doesn't matter if an attacker can mess with them "in flight"? That's generally how package managers work in my experience. It also means that you can let third parties create mirrors without trusting them fully. TLS doesn't really seem like the right solution for something like that.

<comment><USER17> This feels like enough, doesn't it? But it's not.

You will also need to sign and timestamp all repository metadata. Otherwise when you learn of bug X and fix it with patch P to produce new package package-V+1 I also learn of bug X, but I ensure my victims don't get told about new package-V+1, they will be told package-V is the latest version and they're now safely up-to-date - but I can exploit them.

If you use TLS I can't meddle with the packages, or the metadata, or anything.

You absolutely can secure everything in your package management system, but it will be a bit trickier than just signing individual packages. Whereas using TLS is enough.

Back in 1995 when anonymous FTP distribution was commonplace, signing packages made a whole lot more sense than trying to get all your mirrors to update to HTTPS. In 2018 this is not so true.

<comment><USER18> They should be doing all of that anyhow. Servers get hacked. TLS doesn't fix the metadata replay problem.

</comment></comment></comment></comment></comment><comment><USER19> I know that from a technical point of view, Emacs is not just a text editor; I think it is a complete lisp virtual machine with a text-based interface that happens to be prepared for editing text by default, and thus it should be treated as such, instead of running it over as a userland program maybe one day it works as a standalone operating system, with its own kernel and JIT compiled lisp dialect. I'm saying this, because when I first started using Unix-like operating systems Emacs was one of the things that attracted me the most, but after actively using it for almost a year I saw how it moved away from the expected operation mode of a typical Unix environment, and I didn't like that. I came to appreciate the phylosophy of "One program to do one thing and do it well... make programs that work together", I consider it an elegant way to design and implement software, thus I don't see where Emacs fits on a Unix-like system. In the end, I ditched it in favor of something much more simple, fast and adecuate, this is where vis does an outstanding job, having the unique plus of using a structural regular expressions engine, and extensible using Lua. vis is small (source code and binary) and I don't have to think about what SSL implementation it should use, because there is a system library that does it for me, since vis is just a text editor, and succeeds at it.

<comment><USER20> Emacs is a wide family of text editors. GNU Emacs is just one. Originally Emacs was implemented as a set of TECO macros. The second Emacs was then EINE (Eine is not Emacs). EINE was implemented in Lisp Machine Lisp on top of the Lisp Machine OS. One of the next Emacs editors was Multics Emacs, an Emacs implemented in Maclisp for the Multics mainframe computer. Both Maclisp and Lisp Machine Lisp were full-featured Lisp implementations and thus their Emacs was a Lisp-only implementation. From then on zillions of Emacs variants were implemented. This provides a list of Emacs implementations: [http://www.finseth.com/emacs.html](http://www.finseth.com/emacs.html)

GNU Emacs was developed as a text editor. Its implementation language are C and Elisp - not only the VM is coded in C, but there are other parts written in C. See for example: [https://github.com/emacs- mirror/emacs/blob/master/src/frame....](https://github.com/emacs- mirror/emacs/blob/master/src/frame.c)

Then Elisp is the extension language for writing extensions (like minor or major modes) and applications using a text-editor user interface. These applications are using the programmable editor buffer as their user interface building block.

General enhanced Lisp implementations which run as a standalone operating system, but which are not special purpose for editor implementation and which are not providing an editor-based user interface exist(ed) several: MIT Lisp Machine OS (and derived), Interlisp-D, ... Mezzano ( [https://github.com/froggey/Mezzano](https://github.com/froggey/Mezzano) ).

Since Elisp was an uncomplete and smaller Lisp - and not a systems programming dialect like Lisp Machine Lisp - its code base is mostly like that: no lexical binding, no real multithreading, no really scalable language constructs, ... moving this language forward is a) not easy and b) not really in the core interest (the core task is being a language for editor extensions).

Also it is questionable whether its editor user interface is a good model for a general UI...

<comment><USER19> Thank you for this explanation, it gives me a better idea about Emacs' design.

</comment></comment></comment><comment><USER21> Kinda on-topic, I still don't know how to setup Emacs 26 (which is a relatively recent release) on macOS - as opposed to all prior versions.

Installation of packages will fail due to the TLS changes.

This seems the best-informed solution but it's not working for me: [https://blog.vifortech.com/posts/emacs-tls- fix/](https://blog.vifortech.com/posts/emacs-tls-fix/)

<comment><USER4> I don't know exactly why this solution won't work for you, there could be a number of issues at play here.

In short, try this:

1\. Reset all your 'tls 'nsm and 'gnutls customize options to their defaults.

2\. $ rm -rf ~/.emacs.d/network-security.data

3\. Install [https://github.com/antifuchs/safe-tls-defaults- mode/blob/mas...](https://github.com/antifuchs/safe-tls-defaults- mode/blob/master/safe-tls-defaults.el)

This nice gentlement packaged up the settings I suggested on a Reddit thread. It should work most of the time, if not, you can adjust the CLI string.

<comment><USER21> Tried out, no luck unfortunately. With that setup, both E25 and E26 get stuck forever while trying to fill the `~/.emacs/d/elpa` directory (with an actual freeze and no feedback)

<comment><USER4> What about emacs -q ? Does the same issue still happen? If it doesn't, that sounds like a different package is locking up your emacs.

<comment><USER21> Finally identified the issue - I was adding Marmalade as a repo, which cert is legitimately wrong (Chrome will warn over [https://marmalade- repo.org/](https://marmalade-repo.org/)).

I just removed the repo - I'd say that Melpa won in recent years?

<comment><USER4> Oh it's won many years ago :)

</comment></comment></comment></comment></comment></comment><comment><USER22> I haven't been able to load a Melpa library with https for many months. I had assumed it was just because MacOS is weird about TLS since it doesn't use OpenSSL (getting freaking _curl_ to work for https in MacOS sometimes takes hours of futzing around with libraries).

But maybe it's Emacs' fault?</comment>


Marko – An isomorphic UI framework similar to Vue - <AUTHOR> http://markojs.com <comment><USER2> I've focused on backend for the last 7 years or so, so I've been kind of out of contact with the frontend world. Recently I started working on a personal project, and I thought it would be a good time to learn some of the modern tools people have been using for frontend dev.

I was completely baffled by the myriad of options out there, how complex they look (note I've been working on very high performance, distributed backend applications, so complexity on itself is not an issue), and how it's very unclear when to use any one of them or what each one is good for. I tried Angular and React, and both feel like almost a different language. You have to learn their internals to work effectively with them, and it often looks like they create more complexity then the original complexity they were trying to reduce. I have no problem learning new things, in fact, I love it! It just feels like there are other things to learn that will stick around for longer - JS frameworks/libraries seem to be very hype-driven these days. What are your thoughts on this?

<comment><USER3> Just learn vue.js, and use the associated vue libraries, vue-router, vuex, etc.

Start with: [https://nuxtjs.org/](https://nuxtjs.org/)

And go from there, I wouldn't waste my time with Angular, and React is much more complicated than Vue.

<comment><USER4> This is very subjective. I feel React is conceptually simpler (no custom templating language) and less opinionated (no official state management system like Vuex for example).

<comment><USER5> Your response is a bit disingenuous.

> no custom templating language

JSX may not be a templating language but you still need to consider it when comparing with other framework's languages

> less opinionated

The community is though, if you don't do things with redux, react-router, etc then you're considered odd. Any job you pick up with react is sure to use those.

<comment><USER6> I've used neither of those libraries in any of the production React apps I've made.

<comment><USER7> Me neither, thank god.

</comment></comment></comment></comment></comment></comment><comment><USER8> Nowadays I only consider switching front-end frameworks if there is a substantial conceptual improvement. React did this for me due to its uni- directional dataflow and component-based architecture. There is nothing new here conceptually.

<comment><USER9> I find that this is the most sane tactic as well. If you just limit yourself to frameworks with conceptual improvements (that _also_ show at least signs of substantial adoption, and preferably already are widely adopted), then the churn really is not that high. It used to be jQuery, then Angular around 2012, and now React. That's perfectly doable in terms of keeping up, at least as long as you're an actual front-end developer rather than someone who also has to do the front-end. (And perhaps it's less so when you're older and I'm one of those darned millenials now, but I wouldn't know.)

</comment></comment><comment><USER10> I've discovered Marko in one of the various react-alternative topic that emerged yesterday and it looks like something sane, which is rare in the js ecosystem. I'm wondering if anyone on hn used in in a real world project and how it was.

<comment><USER11> Yes we've started using it a couple of months ago. What attracted us is how easy it is to build an isomorphic app with Marko.

I would not recommend it to anyone though. There is a world of difference between what they advertise on their website and the reality of using it as your framework.

Some key take-away for us so far:

Pros: \- the idea and principles behind marko are brilliant. \- it does render relatively fast

Cons: \- it is bug ridden with inexplicable error messages. Not beta version bug ridden, not alpha version bug ridden but pre-alpha version bug ridden... \- top level elements can't have a state, which made templates impossible to use (still need to make sure that's completely true, we haven't tried everything we could). \- when doing back-end rendering, the browser still waits for the JS bundle before rendering. Almost completely defeating the purpose of an isomorphic app... \- Marko does not come with a state manager. We had to build our own. \- We haven't started using their router yet but having a quick look at it it seems to have an utterly bad API. They could have gone all the way and embed the path definition into the marko files but no, we get some awful JSON to work with...

My guess is that some very talented engineers at eBay rightly decided that the current state of UI frameworks is terrible and started remedying it. Then, deadline and other commitments made it hard for them to support the framework enough for it to be usable by third parties. It is still a great achievement and I find marko interesting but cannot possibly recommend it against React (haven't used enough of Vue.js to have a valuable opinion on it).

<comment><USER12> Hi nherment,

I appreciate your feeedback. To follow up on some of your concerns:

Top-level UI components can have state now:

        class {
          onCreate () {
            this.state = {
              count: 0
            }
          }
          increment () {
            this.state.count++;
          }
        }

Count: ${state.count}

If Marko's built-in component state management is not sufficient, you can of course use Redux with Marko. Here's a sample app: [https://github.com/marko- js-samples/marko-redux](https://github.com/marko-js-samples/marko-redux).

Marko does not have an "officially" supported router yet, but this is the one we've been pointing people to: [https://github.com/charlieduong94/marko-path- router](https://github.com/charlieduong94/marko-path-router). If I understand your statement correctly, you mean that you would prefer to export the path directly from the component? I agree that this should be supported. Currently, Marko does not support exports, but it's actually on our issues board [https://github.com/marko-js/marko/issues/538](https://github.com/marko- js/marko/issues/538). We'd like to support the following:

        export var route = '/about';

        class {
          ...
        }

About!

This actually would be fairly easy to implement, but we've been focusing on other things. I think that we should reprioritize this issue though.

It's definitely true that we have a lot of features that we'd love to focus on and a very small team of engineers working on Marko/Lasso. I welcome you and anyone else to jump in and help if you'd like! Any contributions are extremely appreciated. Additionally, feel free to drop into the Marko Gitter chat with any concerns and we'll try to help [https://gitter.im/marko- js/marko](https://gitter.im/marko-js/marko).

<comment><USER11> I have just been using the state for a top level component.

While it is true that this is now working, updating the state in the component that contains the <lasso-head/> and <lasso-body/> tags will cause the dependencies (defined in browser.json) to be lost. Unfortunately, the stylesheets are included in the dependencies... This means that playing with state at the top level removes any styling on the page.

This is EXACTLY the type of insanity that makes me recommend _AGAINST_ using marko...

Example code here: [https://github.com/nherment/marko-css- error](https://github.com/nherment/marko-css-error)

</comment></comment></comment></comment><comment><USER13> Meanwhile in real reactive environments:

        import QtQuick 2.7
        import QtQuick.Controls 1.1

        Rectangle {
          property real count: 0

          Column {
            Text {
              text: count
              color: "#09c"
              font.pointSize: 24
            }
            Button {
              text: "Click me!"
              onClicked: count++
            }
          }
        }

Also the so-called "60fps smooth" animation has noticeable stutters on Firefox on linux.

<comment><USER14> It works entirely fine on Firefox on macOS and Windows though. It seems more likely that has something to do with how Firefox interacts with the graphics stack on Linux than Marko.

Have you tried it in a different browser, like Chrome or Midori?

<comment><USER9> Works fine for me on Firefox on Linux. Not a weak laptop though.

<comment><USER13> Me neither. Intel 6900k and GTX 1080. Works fine in Chrome though.

</comment></comment></comment></comment><comment><USER15> So many new UI frameworks, yet no one really mentioned SmartClient.com (LGPL licensed).

I've been using it for almost 10 years and some of the concepts they pioneered have only recently been discovered by the new kids.

I still use it, though some of the 'fixes' they had to put in place to support old browsers are often polluting the DOM unnecessarily in modern browsers (this is something I hope they fixed).

My favourite aspects of it are that I can declare components declaratively, it has a technique called autoChildren that allows managing a tree of components as a flat set (useful for complex components like tabsets), and the data binding layer. The documentation is top notch (which it needs to be given the depth of stuff in there).

Again, all of this was around in 2009 since when I started using it - and not sure how many years before I found it they'd been going.

</comment><comment><USER16> I just skimmed the page and seen that sort coloured of sine wave... Then read «The above animation is 128
 tags. No SVG, no CSS transitions/animations. It's all powered by Marko which does a full re-render every frame.».

Well, as soon as my browser renders that thing, the browser process reaches 122% cpu usage (according to htop). And i'm using a 4th gen core i7 processor. I can literally (literally in the literal sense of the word) hear my fan spin up. That __hurts __battery so much.

<comment><USER17> Ouch. I had a look and according to the Chrome task manager that page is sitting at 12-18% cpu usage while looking at the animation.

For reference, a 5000Kb (720p) twitch stream I had open was sitting at 3-4%.

</comment></comment><comment><USER18> Don't abuse the term "isomorphics". To prove 2 groups are isomorphic mathematically you have to show there exists a product preserving map between the groups.

Just kidding.

</comment><comment><USER19> [https://dayssincelastjavascriptframework.com](https://dayssincelastjavascriptframework.com)

</comment><comment><USER20> Quick question, is there anything conceptually interesting about Marko thats different in ideology and structure from Angular and React or Vue?

For background to why I'm asking: I'm an IOS mobile dev and was a web dev before and I often use web dev structures and ideas as there is less structure, frameworks (unless you count RxSwift) and general philosophies I find in IOS mobile dev aside from best practices and tips like avoid Massive View controllers, etc.

<comment><USER21> Async and streaming rendering is probably the biggest conceptual difference since it changes how you think about providing data to your view (in a good way). The paradigms of how you build UI components is very similar across all of the major UI libraries, but Marko aims to reduce boilerplate and offers what I think to be a superior syntax. --Marko author

</comment></comment><comment><USER22> Ecosystem is so important these days, there might be technical reasons for choosing this but considering the support (knowing stack overflow answers will be available) and pre-existing component ecosystems for Vue & React, I can't see a reason anyone would pick this.

<comment><USER23> Same reason someone picked up vue in first place?

</comment></comment><comment><USER24> Here's a great introduction to Marko by its main dev:

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

<comment> vladimir-y You can see on the 21-24 minutes the bad idea of implicit imports which is being presented as a great idea:

\- Explicit import is a much better idea than the Marko's folder structure based implicit import thing. Explicit import makes the code base more maintainable, reduces the side effects probability and "magic" stuff.

\- "Counter" there is not a "word" as author says, but the component's file name. So it's not the word that you can misspell, but the file/module, that will not be imported in case of file name misspelling. Import by file name is not repeating, it's the explicit module importing by the file name, not by a some word - no DRY ideas violation here.

\- Author says on 21:51 that "imports is kind of terrible" due to the relative path. There is no issue with the relative path - use Webpack's aliases. He says imports (explicit relative imports in that case) makes code more fragile...

\- I like Vue's idea of separation computed/methods/data blocks more than mixing all together. It for example helps the green devs to better understand the framework's lifecycle/internals and separation of concern ideas.

I stopped watching the video after the 24 minute.

<comment><USER24> > use Webpack's aliases

You are contradicting yourself there. There is really no difference in clarity between an automatic path resolver and using aliases.

> I like Vue's idea of separation computed/methods/data blocks more than > mixing all together

It's really a matter of taste.

<comment> vladimir-y > You are contradicting yourself there. There is really no difference in > clarity between an automatic path resolver and using aliases.

No difference? In case of explicit importing you get the "import" thing in the sources code and it's a huge difference in comparison of not having it there.

> It's really a matter of taste.

Not really, but a matter of separation of concern and good design. Besides Vue is a reactive thing, and such structure I guess makes it easy to apply reactivity observers where they are needed in a more explicit way.

<comment><USER24> > No difference?

If you are using aliases you are not using explicit imports.

        import something from 'something';

Where does 'something' come from? No idea unless you peek at the webpack configuration file.

You don't even know if the module is actually called 'something'.

> Not really, but a matter of separation of concern and good design.

Then I'm guessing you consider all OOP languages badly designed since none of them have properties for 'methods', 'getters' (computed), etc. Yes?

<comment> vladimir-y > If you are using aliases you are not using explicit imports.

You are as you have the "import" code line in the code sources. If you get rid of that code line, you make it happen implicitly and this is the case of undesirable "magic" happening.

> No idea unless you peek at the webpack configuration file.

Some IDEs do support automatic Webpack's aliases resolving, so you can navigate to the module by ctrl+click.

> Then I'm guessing you consider all OOP languages badly designed since none > of them have properties for 'methods', 'getters' (computed), etc. Yes?

Don't be silly, we are talking about JS that has a room for adding some structure as it's being too flexible by default.

Anyway thanks for the Youtube link, it helped me to realize that I'm not going to use this Marko thing.

</comment></comment></comment></comment></comment></comment><comment><USER25> Isomorphic UI? WTF??

What's next, homotopic web frameworks and commutative app diagrams???

</comment><comment><USER26> For those interested in spreading this on PH: [https://www.producthunt.com/posts/marko- js](https://www.producthunt.com/posts/marko-js)

</comment><comment><USER27> I don't believe the marketing when it says that working with something is "fun". Working is maybe enjoyable sometimes, but it will stay hard work if you're doing it right.

<comment><USER21> Building web apps is definitely hard work, but it can be fun if you are instantly rewarded with working components/pages that didn't require a ton of code :)

</comment></comment><comment><USER28> You had me at isomorphic.

</comment><comment><USER29> This looks pretty decent.

</comment><comment><USER30> Yay, another front end framework! /s

</comment><comment><USER31> Oh hi there, yet another awkward not-really-html-not-really-js templating language

        class {
            onCreate() {
                this.state = {
                    count:0
                };
            }
            increment() {
                this.state.count++;
            }
        }

The current count is ${state.count}

        <button on-click('increment')>Click me!</button>

<comment> atom-morgan Given how little boilerplate there is for the actual code, I'll take the templating language.</comment></comment>


Ask HN: Would it be possible to reimplement flash in rust/web assembly? - <AUTHOR> Curious whether you could emulate flash or somehow resurrect flash based apps and games. <comment><USER2> You mean like [https://github.com/ruffle-rs/ruffle](https://github.com/ruffle- rs/ruffle) ?

<comment><AUTHOR> Thanks!</comment></comment>


Straightforward Answers to Basic Questions About Syria's War - <AUTHOR> http://mobile.nytimes.com/2016/09/19/world/middleeast/syria-civil-war-bashar-al-assad-refugees-islamic-state.html <comment><AUTHOR> I found this a particularly straightforward explanation to the complex situation in Syria.</comment>


Show HN: A pretty toy I made with canvas - <AUTHOR> http://johncs.xyz <comment><USER2> Collected them all in one dot, amazing

</comment><comment><USER3> This is nice! :)

How do I learn "this" kind of JavaScript? Does it have a special name or something?

<comment><USER4> All you really need to know is canvas and canvas animation. You can find a Mozilla tutorial here[0]

[0] [https://developer.mozilla.org/en- US/docs/Web/API/Canvas_API/...](https://developer.mozilla.org/en- US/docs/Web/API/Canvas_API/Tutorial)

</comment></comment><comment><USER5> I like it. :) Simple, and quite pretty once I understood what it was doing.</comment>


Samsung phones with graphene battery tech would charge in 12 minutes - <AUTHOR> https://www.businessinsider.com/samsung-graphene-battery-tech-super-fast-charging-2019-8 <comment><USER2> Yeah, nah. This is not going to happen in 24 months. My cynical side tells me this is a panicky grab for positive press after their recent Note 10 smartphone was poorly received by reviewers.

</comment><comment><USER3> hah samsung is working on this tech for something like 10 years with korean academics and others. it would be interesting if that obvious educated guess was followed with some serious patent fillings or smthn</comment>


Voice and video with non-technical friends and family - <AUTHOR> I'd like to get friends and family off Facebook, but one of the things they use it for is calling people, both voice and video.
So I'm looking for a replacement.  Ideally whatever we use would run on both phones and laptops/desktops, preferably with a light-weight client.  We would need audio, video, and screen-sharing would be useful.  Ideally it would be P2P, and not controlled by a single entity.
Privacy is a concern as a general principle, and I'd like to be able to avoid joining another "community".
My betting is that such a thing doesn't exist, but I'd be interested to know what trade-offs people think are available and accessible for non-technical people.  Matrix was one option, but I've heard that some people find it difficult to impossible to get audio and video working.  Another option might be Tox, so I'd be interested in hearing of people's experience with that.
But all comments, suggestions, and thoughts welcome.  Thanks. <comment><USER2> FaceTime? That's probably the closest to what you're looking for. It's end-to- end encrypted, runs on (Apple) phones and computers (which is its biggest weakness for this use-case), does not require joining a "community", and is dead-easy to use. Signal is also great and doesn't require an iPhone, although you have to convince everyone to install the app.

Everything in this space is a trade-off, unfortunately. To my knowledge, there's no open-source, end-to-end encrypted, decentralized, peer-to-peer, mobile-friendly, and easy-to-use audio/video calling platform.

Assuming that the solution is end-to-end encrypted, I'm not too worried about it being OSS or P2P. For non-technical friends and family, the mobile-friendly part is far more important. Even mobile-only is probably fine for this particular purpose.

</comment><comment><USER3> I personally prefer Telegram. It's voice call quality (as well as everything else it offers) feels perfect (your mileage may vary - obviously this depends on your location, your ISP etc) and the bandwidth consumption is shockingly humble. It can also let you send voice messages and _video messages_ easily. Video calling is not there, however - it's a feature planned to be shipped later this year.

</comment><comment><USER3> Let me mention there is an entire StackExchange site for this kind of questions: [https://softwarerecs.stackexchange.com/](https://softwarerecs.stackexchange.com/)

You should have posted the question there and submitted a link to it here on HN.

</comment><comment><USER4> Thank you for making my question more palatable for HN readers! Really very much appreciated. You just made me realise I need to practice my HN question asking skills :)

<comment><AUTHOR> Thank you.

It's not worked, though, since no one is replying. A lot depends on luck as to whether something gets noticed, up-voted, and replies.

I might try re-posting tomorrow morning (my time) in an attempt to catch a different audience. Then if there are still no replies, I've found a good time to ask these sorts of questions is on a Saturday at about 10:00 UTC.

And good luck, I hope you get the information you're looking for. The answer[0] from maverick74[1] might also be useful for you, but you've probably seen that.

Cheers.

[0] [https://news.ycombinator.com/item?id=23526270](https://news.ycombinator.com/item?id=23526270)

[1] [https://news.ycombinator.com/user?id=maverick74](https://news.ycombinator.com/user?id=maverick74)

</comment></comment><comment><USER5> Jitsi is open source, easy to use (click shared link) and secure.

<comment><USER3> I once used Jitsi (the browser-based version) and my CPU usage went above the roof (even after I've disabled HD). It felt like my MacBook Air was going to blow up. Obviously not a battery-friendly app. I still feel like I'm going to use it again when I need a video conference - just for sake of using self- hosted free software.

</comment></comment><comment><USER6> Not a perfect match, but we use zoom.</comment>


Intermediate Projects for C++ learner - <AUTHOR> I have just finished reading "The C++ programming Language" by Stroustrup. Now, I really want to develop one or two good projects to enhance my skills, before delving deeper into advanced template meta programming. I am not looking for small projects (like a calculator), but looking for some challenging projects to learn further. <comment><USER2> since you got no response:

\- scrapers, spider/crawler and content extractor for NLP analysis

\- analyze your hard drive for old, duplicate etc files

\- Arduino/raspberry pi (challenging, very little RAM, can't use c++11, stdlib, etc

\- CUDA

_____________

also you want to look at VC++, clang and gnu toolsets, e.g. "#pragma once" and the C++14 refinements. Meyers Modern Effective and Effective 3rd ed books are great for that. Also Lippman et al's primer

_________________

compiler blogs: [http://blogs.msdn.com/b/vcblog/](http://blogs.msdn.com/b/vcblog/)

[http://blog.llvm.org/](http://blog.llvm.org/)

[http://developerblog.redhat.com/tag/c/](http://developerblog.redhat.com/tag/c/)</comment>


U.S. coronavirus toll tops 50k - sahin-boydas https://www.washingtonpost.com/world/2020/04/25/coronavirus-latest-news/ <comment><AUTHOR> The healthcare system and the neccesity for liberty (as seen in the protests for quarantine to be lifted) is a deadly combo may be the reason for this happening

<comment><USER2> Deaths lag infections by weeks. If anyone got sick from those protests they haven't been sick long enough to make it to this statistic.</comment></comment>


DDOS on City AM - <AUTHOR> Looks like City AM is down for everyone - is this a response to their stance on adblockers? <comment><USER2> I'm getting a 503 error.

[http://www.theguardian.com/media/2015/oct/20/city-am-ban- ad-...](http://www.theguardian.com/media/2015/oct/20/city-am-ban-ad-blocker- users)</comment>


The Healthiest People in the World Don't Go to the Gym - <AUTHOR> https://medium.com/s/story/the-healthiest-people-in-the-world-dont-go-to-the-gym-d3eb6bb1e7d0 <comment><USER2> I would argue that all cause mortality decrease isn't the only measure of health. There are people who eat trash, are overweight, and smoke a pack a day that live to be 100. By no means other than fortunate genetics is that person more healthy than a casual athlete who exercises regularly and eats well.

Take blood tests from both individuals and I challenge you to find a doctor who says the former is healthier than the latter. Beyond that, there has to be some observation of the quality of life. Weight training has been shown to increase your resilience to injury and increase balance, two issues that commonly impair the elderly (falling and breaking a hip, for example). Exercise also has been shown to decrease stress, which has been linked to increases in all cause mortality.

While it looks like moving more may help you live a longer life, this article seems to belittle any value from resistance training, which is the exact opposite of what the research has shown we should do.

</comment><comment><USER3> You apparently need:

\- Active lifestyle

\- Good mental health

\- Low stress

\- Healthy diet

\- Social circle & sense of community

\- Stable home/family

And of course this program will help you with all of these, for a low, low monthly fee!

</comment><comment><USER4> To be fair, the least healthy people in the world also don't go to the gym.

I have a sedentary coding job. Bike commuting and circuit training is necessary for me to stay at the level of fitness I need to prevent injuries in my hobbies, not to mention stay at a healthy place metabolically.</comment>


Command-line Twitter with Bash - <AUTHOR> http://solutious.com/blog/2009/07/13/bash-twitter/

<comment><USER2> And then you can set PROMPT_COMMAND to send everything you type at the shell to twitter. "What are you doing?" indeed!

<http://www.shell-fu.org/lister.php?id=768></comment>


PG Uses an Image Map, Gif Bullets, and Tables for Everything - <AUTHOR>

view-source:http://www.paulgraham.com/articles.html
The menu is a single image mapped to urls.
He generates bullets by stretching out a gif and uses a plethora of tds for absurd purposes.
This makes me smile. And then shudder. And then smile. <comment><USER2> That's because he hosts his site on Yahoo Store, and if I recall correctly all the old-school RTML templates generated image maps for the left-hand navigation. Shudder, RTML has brought my life a lot of pain over the years.</comment>


Chinese Clone Company Will Sue Apple Over iPhone 5 Design - <AUTHOR> http://gizmodo.com/5940253/chinese-clone-company-will-sue-apple-over-iphone-5-design

<comment><USER2> That'd be like gizmodo suing the source of this article!

[http://www.gizchina.com/2012/09/04/chinese-phone-maker- gooph...](http://www.gizchina.com/2012/09/04/chinese-phone-maker- goophone-i5-might-have-blocked-iphone-5-sales-in-china/)</comment>


End-to-end implementation of a machine learning pipeline (2017) - spandan-madan https://spandan-madan.github.io/DeepLearningProject/docs/Deep_Learning_Project-Pytorch.html <comment><AUTHOR> Great explanation and I love the fact that the entire presentation _is_ a Jupyter Notebook!

A non-academic observation - the 'real-world' challenge of ML pipelines is what I call the 'last-mile' problem of ML - operationalizing your model. You begin to run into problems of:

1\. How often do you 'score' live data? How will this affect latency, data ingestion etc?

2\. How often do you have to update your weights, if you want your model's performance to be consistent?

3\. Integration with source systems

4\. If you build your final scoring model on library-dependent languages like Python, how do you ensure no breakages? (Docker solves this to a large extent though)

<comment><USER2> That's it, really. Any good reference to keep up to date with the last-mile best practices for the average ML practitioner? Thanks!

<comment><USER3> I link these resources often, but they are often relevant! See "The ML Test Score: A Rubric for ML Production Readiness and Technical Debt Reduction" [1] and the Rules of Machine Learning [2]. Another classic: "Machine Learning: The High Interest Credit Card of Technical Debt" [3], and recently added: Responsible AI Practices [4].

[1] [https://ai.google/research/pubs/pub46555](https://ai.google/research/pubs/pub46555)

[2] [https://developers.google.com/machine-learning/rules-of- ml/](https://developers.google.com/machine-learning/rules-of-ml/)

[3] [https://ai.google/research/pubs/pub43146](https://ai.google/research/pubs/pub43146)

[4] [https://ai.google/education/responsible-ai- practices](https://ai.google/education/responsible-ai-practices)

</comment></comment></comment><comment> spandan-madan For feature requests on this, please create an issue on the github Repo!

For future tutorial suggestions, mail me at email@example.com. A new one on NLP is coming soon!

<comment><USER4> Is your code intentionally verbose (for the sake of being explicit)? It seems like it could be condensed a lot by using Pythonic structures. For example you could replace block 39 with a one-liner:

Genre_ID_to_name=dict([(g['id'], g['name']) for g in list_of_genres])

In other places, you would benefit a lot from the enumerate(..) function, which returns (index, item) tuples when called on a list.

<comment> spandan-madan Precisely. I strongly believe that the purpose of tutorials is to be inclusive of all people. That's something I realized as a TA, making things explicit never hurts. There's always someone who can gain from more detail :)

<comment><USER5> I'm going to throw out a plug for that mindset going beyond tutorials.

It is a suspect proposition that anything is gained by turning 3 lines of code into one line of code. Unless it is javascript for the Google homepage or somesuch where the bytes matter. Moving code from a bad data model to a good one usually correlates with a big reduction in line count, but the gain is in choosing more appropriate data structures and not in the number of lines removed.

Every reader of code, including the author after 3 months, is going to have to read and understand the code from scratch. One line doing a multidimensional transform of the data is going to scan for a small fraction of people. That one liner would take about 3 times as long to understand as any one line of the tutorial code. The data model hasn't changed either. If anything, I'd argue that the nature of the transform being done is clearer in 3 lines.

<comment><USER6> Readability of the code is always relative to the reader. In any language that I've mastered, I've always preferred more verbose options at first, but with experience I found out that I find condensed versions to be more elegant and time-saving.

In the end, choose code style that matches level of your audience. If you write a one-off python script that automizes some build process in mostly non- python codebase, it should probably be very verbose and easy to understand. If, on the other hand, you're writing code in a decently advanced codebase and most of your colleagues are fluent in the language (or at least, supposed to be), it makes sense to use as much condensed syntax sugar as possible.

</comment></comment></comment></comment></comment><comment><USER7> This is a very good way to get started building ML pipelines. When you do it at scale, you often need to use a broader range of tools. Here's how we do it in Hopsworks with Python the whole way (using Airflow to orchestrate the different steps):

[https://hops.readthedocs.io/en/latest/hopsml/hopsML.html](https://hops.readthedocs.io/en/latest/hopsml/hopsML.html)

<comment><USER8> Your pipeline design looks pretty sweet!

</comment></comment><comment><USER9> Note: at the beginning, you speak about learning a function "g" that approximates a function "f", then later, you swap them and learn a function "f" that approximates "g". That could be confusing;

</comment><comment><USER10> This is great, most tutorials out there assume the dataset already exists. Nice move covering the entire pipeline!

Also, looks like that notebook needs an update.

[https://github.com/ContinuumIO/anaconda- issues/issues/6678](https://github.com/ContinuumIO/anaconda- issues/issues/6678)

</comment><comment><USER11> Did they have to put a big "Harvard University" banner at the top of the GitHub repo: [https://github.com/Spandan- Madan/DeepLearningProject](https://github.com/Spandan- Madan/DeepLearningProject) ? This is a private repository, right? Is the code owned by Harvard?

For me personally, I find this off-putting. Let your content speak for itself. No added credibility when the affiliation is advertised like this.

Content looks good, though! :)

<comment><USER12> Yes, this confused me too. Especially considering Spandan Madan is an MIT researcher, I don't understand the overt branding of a different school

</comment></comment><comment><USER13> An earlier discussion: [https://news.ycombinator.com/item?id=14781888](https://news.ycombinator.com/item?id=14781888)

<comment> spandan-madan Yup! That version was in Keras. It's now been re-written in PyTorch as well! Thanks to [https://github.com/AnshulBasia](https://github.com/AnshulBasia).

<comment><USER14> Any update on the NLP tutorial? I keep checking this repo [0] but seems it hasn't been updated lately. I hope you didn't abandon this project

[0] - [https://github.com/Spandan-Madan/NLP-Intuition-and- Applicati...](https://github.com/Spandan-Madan/NLP-Intuition-and-Applications- of-word-embeddings)

<comment><USER15> [https://news.ycombinator.com/item?id=18298670](https://news.ycombinator.com/item?id=18298670)

</comment></comment></comment></comment><comment><USER16> As a beginner and a self-tought. This style of tutorial is practically good and persuasive for practitioners. Thank you very much for investing time to do this.

</comment><comment><USER17> The link seems dead, is there another url ?

<comment><USER18> [https://spandan- madan.github.io/DeepLearningProject/PyTorch_...](https://spandan- madan.github.io/DeepLearningProject/PyTorch_version/Deep_Learning_Project- Pytorch.html)

</comment></comment><comment><USER19> It's interesting, however the webpage seems broken on Firefox Android (latest, Android 8.1) :

\- some values in the command outputs dont match the author's comments (or maybe I misunderstood some?)

\- there are some big red blocks of errors in the outputs

\- the outputs of the trainings are way too verbose for mobile reading

I guess they are issues on Jupyter's framework side. It would be nice if mobile were treated as first-class viewer.

</comment><comment><USER20> thank you guys</comment>


Designing an end-to-end encrypted CI/CD pipeline with Keybase.io - <AUTHOR> https://zemanel.eu/posts/end-to-end-encrypted-ci-cd-pipeline-with-keybase-io/ <comment><USER4> Thanks for this a lot, I was just asking about possibility of corporate secret management with keybase. First time I hear about encrypted repos but I was considering using team storage just to keep corporate secretes in a file system.

Currently I use Gitlab on premise and I put secrets on the repository in a pass format. GitLab runner has single secret, to access the password store. This is clearly different then OP's context in which he wants to utilize everything in cloud.

While this works great and devs can read secrets on any OS, I was considering alternatives for easier on-boarding and additional features. I looked into all kind of secret sharing stuff for teams, both commercial and FOSS, but for some reason I don't "feel it". Vault feels like designed more for machines then humans. Commercial ones seem prohibitively expensive plus not feeling great using cloud for secret management (or anything non-trivial for that matter - <USER2> could go with status page maybe). So far Psono looks most promising in FOSS world.

In this case, one could use 2 job servers - one that is used only for sensitive things like deployments, and another one for other stuff, in this case build. This could be 2 Gitlab runners (the ci yaml file itself doesnt require changes) for example so build happens on Gitlab.com infrastructure and the deployment happens on the runner tagged something like self-destruct. If you think about it, is it enough that this is PI in your kitchen ? - <USER3> accessible from outside it can be hacked, so this probably needs to be _deploy and terminate myself_ scenario to minimize exposure even further - perhaps one day also in cloud, lets call it _proton-runner_ (it would still require leap of faith to some measure).

<comment><AUTHOR> the "Pi" wouldn't need to be (publicly) reachable. It would just need to be able to connect to Keybase and other private services. For remote management and talking to private services over internet, i guess SSH, VPN or Zerotier <3 ?

Edit: for secrets in Keybase i think repos are better since its not as easy to mistakenly delete the files ? Plus one has change history. But other people might know better than me.

<comment><USER4> You think PI could use polling to determine when to deploy ?

SSH/VPN all have the same problem - you need to give secret to remote infrastructure

> for secrets in Keybase i think repos are better since its not as easy to > mistakenly delete the files ?

Good observation, having historic secrets could also be used as a feature.

<comment><AUTHOR> to determine when to deploy i mention its possible to listen to team chat messages for commits, so event based. There might be more efficient solutions, think i came across somewhere that its possible to listen to other types of events. need to dig deeper

</comment></comment></comment></comment><comment><USER5> This is trying to solve a problem which root cause is people handing their source code to a remote 3rd party (here gitlab).

<comment><AUTHOR> well, erhmm yes :-) so i was exploring if it was possible to do that in the same way we can give our (encrypted) data to Keybase. Or at least, utilise as much as cloud services as possible.

</comment></comment><comment><USER6> The job server could run in cloud with remote attestation.

<comment><USER7> Is there any?</comment></comment>


The IT Productivity Paradox - <AUTHOR> http://www-cs-faculty.stanford.edu/~eroberts/cs181/projects/productivity-paradox/background.html

<comment><USER2> Maybe it's just me, but this article makes no sense. It defines "IT," but that's about it. Nothing about how the value is calculated, productivity is measured, what changed over the decades, nothing.

Joe Bob says "skip it."</comment>


Google's clever plan to stop Daesh recruits - <AUTHOR> https://www.wired.com/2016/09/googles-clever-plan-stop-aspiring-isis-recruits/ <comment><USER2> This is such a horrible idea, and not the role I want google playing in society at all.</comment>


Reversing aging using young blood plasma [pdf] - <AUTHOR> https://www.biorxiv.org/content/10.1101/2020.05.07.082917v1.full.pdf <comment><AUTHOR> This is a remarkable new paper on aging that lots of researchers are getting excited about. Basically, they give blood plasma from young rats to old rats, and then measure the effective biological age of the treated old rats against a group of untreated old rats. They use an innovative way of measuring age by developing 6 new "epigenetic clocks" that allow them to quantify the aging process in a rigorous way that can work across species. The results of the treatment are absolutely phenomenal, with the old treated rats looking mostly like young rats 155 days later! The treated old rats can escape from a maze much faster than regular old rats, and their tissue (liver, brain, heart) looks much younger when stained to reveal signs of aging (senescent cells). Not only does it stop aging, it actually reverses it! Amazingly the converse is also true— if you put old blood in young rats, it causes them to age much faster. If this works in humans as well, which I'm guessing it does, it seems like a huge deal. Rich people will start replacing their blood plasma with blood from young people and stay young for decades longer, amassing even more wealth and influence. Society will probably pass laws preventing parents from selling their kids' blood (or using it themselves!). Aside from these dystopian fears, I find it funny that something so ludicrously simple and silly sounding actually works and might in fact be the "fountain of youth" long sought for.

<comment><USER2> Wow. That was an exciting rollercoaster post you made there. Was not expecting the twist towards the bottom of it, but it was very informative!

I`m fortunate to be a slow ager (other than a few greys) and attribute limiting stress, choosing coffee w/ cream, maintaining good diet/exercise routines and getting quality sleep the past 3 decades for making approaching my 50`s a pleasure. Had I chose the wrong beverage, I don`t think any of my other habits would have prevented a health decline by now.

This almost sounds like getting on the same gerbil wheel as hbp and diabetes. Unless they change their lifestyle, they`ll be getting mislabeled blood from China, India and Africa`s (just like the seafood debacle) youth until they die or all gains will be lost.

That level of commitment is well outside of my range.

</comment></comment><comment><AUTHOR> Here is a review of the article from another academic: [https://threadreaderapp.com/thread/1259912928695857152.html](https://threadreaderapp.com/thread/1259912928695857152.html)</comment>


Some Boeing 737s can't land on some runways with true heading 270 [pdf] - <AUTHOR> http://rgl.faa.gov/Regulatory_and_Guidance_Library/rgad.nsf/0/3948342a978cc27b862584dd005c1a60/$FILE/2019-25-17.pdf <comment><USER2> Isn't this a duplicate of a post within the past few weeks? I remember this.

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

<comment><USER2> Thank you!

</comment></comment></comment><comment><USER4> This makes me wonder how long it would take for a competent technical leader to course-correct the culture and product issues that have crept in at Boeing. It seems to me it would be on the order of years to get their house in order to get quality to where it should have been.

<comment><USER5> > competent technical leader to course-correct the culture and product issues > that have crept in at Boeing.

This issue looks to be a pretty run-of-the-mill bug in their software. It's likewise scoped down pretty far--there only exist a few runways (in US, Colombia, and Guayana) that make this relevant. ADs like this come out all the time.

<comment><USER6> I get the gist of what you are saying about it being par for the course, but can you explain why a heading of 270 (West if 0 is North)would affect air worthiness? Is it something to due with true North vs. magnetic north deviations? Grasping here. I am truly curious about this one. Thanks!

<comment><USER7> It affects airworthiness because the displays went blank when certain ILS approaches with heading 270 were selected. This is unexpected and would require the flight crew to fall back on other instruments.

The FAA routinely issues airworthiness directives for all sorts of safety issues. Here are a few others published in the past week or so:

[https://rgl.faa.gov/Regulatory_and_Guidance_Library/rgad.nsf...](https://rgl.faa.gov/Regulatory_and_Guidance_Library/rgad.nsf/0/f0ddb5e68a9223aa862584ff00566373/$FILE/2020-01-17.pdf)

[https://rgl.faa.gov/Regulatory_and_Guidance_Library/rgad.nsf...](https://rgl.faa.gov/Regulatory_and_Guidance_Library/rgad.nsf/0/f44c3d2f513d5268862584f900515e04/$FILE/2020-01-14.pdf)

[https://rgl.faa.gov/Regulatory_and_Guidance_Library/rgad.nsf...](https://rgl.faa.gov/Regulatory_and_Guidance_Library/rgad.nsf/0/4aea68db57652880862584f900515ce0/$FILE/2019-26-01.pdf)

[https://rgl.faa.gov/Regulatory_and_Guidance_Library/rgad.nsf...](https://rgl.faa.gov/Regulatory_and_Guidance_Library/rgad.nsf/0/85e929ccd96d5695862584f900515b4c/$FILE/2019-25-20.pdf)

</comment></comment></comment></comment><comment><USER8> F-22 had similar weird bug. Instead of degrees it was dates.

In 2007 squadron (12) of F-22's were flying from Hawaii to Japan. When they crossed when they crossed international date line every plane had systems crash. They lost communication-, fuel-, and navigation subsystems and restart did not solve the problem. Apparently only basic aviation systems worked. They could still fly.

They would have been completely lost, but luckily tanker escorting them was still nearby. They were able to follow it back to the base.

</comment><comment><USER9> It's a software bug that affects 7 runways worldwide due to a combination of heading and lat/long.

<comment><USER10> That does bring up an interesting point. There's only so many airports in the world (especially ones that can support a 737). You'd think that'd be easy to exhaustively test if you wanted to.

</comment></comment><comment><USER11> Would a viable workaround be to tell it the heading is 269 or 271? You'd land at a slight angle which would have you moving about 17 m toward an edge of the runway for every km down the runway you go. That seems mild enough for the pilots to correct once they are on the ground.

</comment><comment><USER12> FTA: "All six display units (DUs) blanked with a selected instrument approach to a runway with a 270-degree true heading, and all six DUs stayed blank until a different runway was selected."

Holy f-cking f-ck.

</comment><comment><USER13> Do any languages (like Rust, maybe) force you to guard against the possibility of a variable being zero if it sees you're dividing by that variable?

And if not the compiler, are there popular static analyzers for any languages that do so?

<comment><USER14> Rust doesn't by default, though you could certainly make a wrapper type that does. You could do the same in any language that has algebraic data types (rust enum's), or another sensible way of forcing you to check certain kinds of errors.

<comment><USER13> I'll have to experiment with implementing that as well as how Rust divides by zero. Thanks for sharing.

My probably wrong understanding is that the philosophy behind Rust is that code without IO/unsafe shall not panic. It might provide useless results but it won't panic. But dividing an integer by zero causes a panic (if I recall).

Edit: derp. Of course they can panic. You really can't guard against overflow or OOM and such. gpm helped correct my thinking: it's not about avoiding panics, it's about avoiding undefined behaviour, forcing you to define all possible branching paths.

<comment><USER14> Safe rust code is allowed to panic, the standard library does in many places, and the language does if you overflow normal arithmetic while debug assertions are on (if debug assertions are off, overflows result in wrapping instead).

What safe code isn't allowed to result in is undefined behavior. Panics are defined, they just happen to be defined to print an error message and abort the program (by default, slightly simplified version of how they work).

By the way: If you want to handle overflows you can use methods like `checked_add`, or you could do something like the suggestion for division by zero and create a wrapper type that always does `CheckedI32 + CheckedI32 -> Option<CheckedI32>` (or something). I might implement `Option<CheckedI32> \+ Option<CheckedI32> -> Option<CheckedI32>` as well so you can delay checking for overflow/division by zero until you want to use the result of the arithmetic.

<comment><USER15> > ...does if you overflow normal arithmetic while debug assertions are on (if > debug assertions are off, overflows result in wrapping instead).

What I am reading from this is that in Rust, debug assertions cause a different semantics. That does not sound right at all.

<comment><USER16> The debug assertions can panic on code which has defined behavior in production, but behavior that's probably wrong, and probably would be asserted in production if it weren't too expensive.

For example, if you do "u32::INTEGER_MAX + 3" in debug, it will panic, but in production code it will not (and will use the underlying CPU's result of "2")

In most scenarios, this is not actually what you want. If your program has the possibility of doing arithmetic near or past the bounds, _you_ should define the semantics you need.

I.e., you can use one of saturating_add, wrapping_add, checked_add, or overflowing_add, depending on the semantics that are correct for your application. All of these behave the same between dev and prod.</comment></comment></comment></comment></comment></comment>