smt1

Data art is anti-dada.

s/Node.js/perl

Don't worry, we've all been there.

That isn't a bad idea, but keep in mind, there is always a usability aspect (I'll just call it the programmer computer interface problem) of "what makes a programming language popular". For example, consider PL/I: https://en.wikipedia.org/wiki/PL/I#Implementation_issues

When people see for example, * or + (or a, b, c). They may have some preassumptions about some implied associativity from arithmetic (depending on what they are taught and what level of math they are at), that may be hard to break. If you have learned some college (abstract) algebra, it may mean something quite different. How about the = sign? Of course, a, b, c may be meaningless to someone who is not a native latin-1 speaker either. My point I guess is that these are just matters of convention, there is just some implied commutativity or associativity usually implied, but this is all arbitrary.

Now, one intereting "quirk" with with PL/I was that certain things looked similar "to what people were used to" (relative to say other PL/I code, or FORTRAN or COBAL), but worked differently even in some small spatial area on a screen (two blocks of nearby code in some editor). For example, if the programmer's eye saw a block of code, reflexively, depending on their experience they may be able to predict what the result of the computation could do. PL/I was an interesting experiment because of the lack of reserved keywords. This made it very expressive but very hard to understand code in context. For example, in pseudo PL/I: foo = 1; = = 2; bar 2 + foo. You are basically changing the grammatical syntax of the language in 3 lines.

But on the other hand, everything is just a symbol and this may not be completely unusual. Consider the diversity of the world's languages and how they are written and how meaning is derived. Natural language grammars may connotate very different representations and transformations, but people learn because they see enough examples. Consider for the differences between Han, Brahmic scripts, Arabic BiDi, various African scripts, Cuneiform, Emoji, whatever. Perhaps all computer languages are "overfit" due to for example, Chomsky's ideas and BNF (keep in mind Chomsky's ideas about morphology were quite different).

Now, let's consider mathematical notation. Depending on how much pure math (or say, mathematical physics or other sciences) you consider, there may be more and more semantic overhead with the conventions of mathematical notation, and people often historically just "cartesianize" and "euclidized" things for convenience because of lack of tooling (think of a sheet of paper metaphor, we've simply moved it over to a computer. it's a skewmorph). Clearly we have better computer graphics, so why haven't developer tools and languages changed along with it? Maybe with more immersive manipulation they will.

There is Oracle risk to be sure, but people using the greater java ecosystem are far less tied to the JVM itself than they used to be because of cross compilation to targets that help with ffi boundaries, JIT, IO, memory concerns, etc. That's true with both Kotlin and Scala.

Meanwhile the Oracle vs Google case is still going on.

Here is some nuance with Rust's OOP relative to java/go/c++: https://stevedonovan.github.io/rust-gentle-intro/object-orie...

If you know haskell, Rust's traits are very similar to type classes, except it also has c++-like generics (templates) and is primarily expression-based like ocaml.

traits vs haskell type classes:

trait -> class struct -> data instance -> impl

Simula(67) definitely was the original concept/implementation of OO. Smalltalk, C++, Java, etc all derived different aspects of it.

- Main abstraction are classes (of objects).

- Concept of self-initializing data/procedure objects Internal ("concrete") view of an object vs an external ("abstract")

- Differentiated between object instances and the class

- Class/subclass facility made it possible to define generalized object classes, which could be specialized by defining subclasses containing additional declared properties

- Different subclasses could contain different virtual procedure declarations

- Domain specific language dialects

Code converted from C to Rust seems much more voluminous.

I haven't seen that in practice. A good point of reference are implementations of things like ruby, python, or the erlang vm in rust compared to the C alternatives. This might be because Rust is also more expressive (probably by borrowing certain syntax/semantics from ocaml/haskell), though the borrow checker does add back some verbosity.

Fuzzing is ROI efficient (especially for time invested) even if you don't intend to find a segfault, but just want to see how a program works or performs across different input states either in or out of its usual domain (and you can direct the fuzzing many ways derandomizing it or constraining the search space, or using virtualizer like qemu). I like to think of it as "semantics engineering" with spare CPU cycles.

I use fuzzers with a Redex driver usually, which is unusually great at intelligently driving fuzzers: https://docs.racket-lang.org/redex/index.html

I think there were some (related, I think!) proposals here: https://github.com/rust-lang/lang-team/issues/23 https://github.com/rust-lang/rfcs/issues/3000

I think you can assume all sorts of analog/physical/digital/information theoretic fingerprinting probably has been used to capture huge volumes of data and microtarget people w/o them knowing (especially in any web browsers or phones).

Though until the CCPA/GDPR, it was probably fairly legally nebulus. Still waiting for a privacy act in the US. Since it was a wide variety of actors, we may never know who captured what how.

I think companies like Apple who tend to make margin on the hardware and not the information probably are to be commended by pushing a lot of privacy/extra scrutiny requirements through the platforms they control (iOS, mac, webkit, etc).

I'd say Rust is much more like Ocaml (with very different memory management) than anything related to C++ (in fact, if you unlearn C++, or know any ML-ish language, idiomatic Rust becomes significantly easier). Ownership types are probably Rust's main difference relative to any systems language, I think the first attempt to bring it to a C-ish language is probably Verona: https://microsoft.github.io/verona/explore.html (though it's very immature)

The problem is that all of these languages are at least partially derived from C or C++, where memory layout is inverted relative to something like Fortran (which seemed to get this right from the 1960s) when you consider most cache lines on most processors. Therefore you must either go through hoops yourself tinkering with layout in languages not built for it or add much more complexity to a optimizing compiler (like gcc or llvm). I feel Fortran got this right, and Pascal and C was where languages flipped the norm. I kind of get why they did this, because in the 80s and 90s there were so many varying architectures, the memory wall was a very real thing. Actually Simula60 (a monte carlo language), probably had the right abstraction level (everything is just a block), but this was before things like stacks, heaps, trees, and other data structures were permanently etched into people's brains.

I like how Julia implemented this (but they use Fortran-like defaults, with clear inspiration from matlab, numpy, etc), with a relatively compact set of functions to do any sort of "index ordering": https://julialang.org/blog/2016/02/iteration/

Rust is very much a child of Ocaml (with a lot of idioms form haskell) with much more control of memory than pretty much any other language (which probably makes it better for implementing complex or safety critical things like optimizing compilers or an operating system). Actually, learning any ML language is probably easier than Rust, but you'll get more fluent at a ML-like (expression based) language like Rust. For me, I felt like I understood Rust way more after looking at how rustc works and started unlearned everything I knew about C/C++.

Take a look at F#'s type solver code especially wrt to Extension Typing: https://github.com/dotnet/fsharp/blob/main/src/fsharp/Extens...

You can do similar things with other Ocaml or Lispy Langs, depending on how you want to do it. All you need is a function that returns possibleTypeTransitions for givenType(type, enclosedLexeme, type.validTransitions). A gradually typed lang sitting in top of a prototype-based blob also makes this easy to do (see typescript) in-codo.

See also MacKay (RIP)'s classic book: http://www.inference.org.uk/itprnn/book.pdf

Another Ocaml-ish option is of course, Rust. One thing it has additionally going for it is a complete node.js JS reimplementation (with deno.js, the runtime is mostly go inspired), a client side web browser JS/Webstack impl with bleeding edge webgpu, webasm, CSS support (servo, which was hoisted up to the Linux Foundation - https://servo.org). I think the ethos of servo is interesting since it should allow the web to more interesting dynamic web pages tailored for bandwidth, internationalization, and localization issues, thanks to the (years) of hardwork by IETF and w3c.

I used Netscape 0.99 on a Mac. It was on a BMUG CD from 1994 that I would get a lot of freeware/shareware. Used it download SPRY Mosaic, which Microsoft licensed to create IE on Win95 soon after (I had already seen Mosaic running on CDE on HP/UX at my mom's scanning electron lab. she was getting a physics ph.d). Then I got a Mac clone from Metroworks. It had a pretty innovative C++ engine for its' time (PowerPlant), but I ended up booting into mkLinux (a mach-based linux) just in time for linux 2.0.0, discovering kde, then spending a while trying to emulate hacking at khtml/konqueror just to reverse engineer IE behavior "quirks" (5+ was a disaster) just to get websites to behave. Eventually both Apple and Chromium adopted khtml (webkit) instead of Gecko, before Firefox itself revived via Netscape and Mozilla (after it escaped the AOL/Time Warner fiasco). The funny thing is I use Firefox, chrome (on my android), and safari (on my Mac) much more than I use linux anymore. I'm pretty luckily to not have been just slightly too young (I'm mid 30s) to go after the original .com boom.

I enjoy Rust the days. Modern C++ certainly ain't bad, but nostdlib Rust is also the first serious threat to full spectrum C in a long time.

It's too bad JVM happened. Solaris was innovative before Java, which became monetized primarily by the fees. They released Self, SmallTalk, and Squeak before that. I think the latter is still very innovative today, because of it's Morphic interface (it's category theoretic). I think you could teach kids the computational equivalent of pretty high level mathematical physics, which is pretty interesting relative to other standard CS101 intros (like python, etc). TeleScript, which was basically inverse JVM was also made around this time, it would have been interesting if the Newton hadn't been discontinued:

https://en.wikipedia.org/wiki/Telescript_(programming_langua...

These days, ironically, Telescript is a model for how distributed computation works in the 3rd world, and even in the first world. But Telescript basically would have made the lattice structures more hybridizable to project information and jobs within the context of already existent social networks and maybe provided a better nexus for useful work done vs power given up (it was made on a very astute observation about the energy, work, power, time, information, transmission nexus) before anyone named a "peer to peer network", a distributed consensus protocol, or introduced money into the picture.

People do need to write UIs in C++ though (sometimes as frontends for some of the purposes you mentioned), and Qt is probably the most used UI toolkit for C++.

Wt is basically Qt for the web. I've used a lot of UI toolkits across many languages, and Qt with modern-ish C++ is fairly productive, doubly so if you're slapping something together for an existing C++ codebase you have.

I agree, although anecdotally, there seems to be an increasing amount of courses teaching Sage. Sometimes free books/lecture notes are published here: https://www.sagemath.org/library-publications.html#books

Sage is a lot larger than Sympy (it's more than 1 million LOC AFAIK), but it still delegates to other libraries to do most types of underlying symbolic and numerical computations.

I usually use sympy (or rather some wrapper of symengine these days) when I'm writing a pure python script, sage otherwise.

For a lot of math and CS courses, I think having some knowledge of some sort of computer-assisted theorem proving. I think the most promising is maybe Lean these days (Coq still might take too long to learn): https://github.com/leanprover-community/mathlib

Depending on the country, chloroquine (or hydroxychloroquine) are over the counter. At least it is in both the UK and India. The UK has banned export of it, and in India it's less prevalent than it used to be because of the spread of chloroquine-resistant malaria. It used to be used /extremely/ widely in places where malaria is a common occurrence.

Personally, I just use this to print stuff from whatever app and send it to the remarkable: https://github.com/juruen/rmapi/blob/master/docs/tutorial-pr...

Works well, I'm guessing for other platforms, similar things exist using remarkable's api.

I looked over some of the amazon reviews, and they seem to be talking mostly about issues in older versions (2018) of the software, which I don't have direct experience with, but the software has gotten better, even in the time I've owned it (they just released version 2.x of the SW).

That being said, there is still room for improvement, particularly with reading (vs writing, which this device is very good at).

I mostly use it this to replace stacks of notebooks (my brain thinks better with pen and paper in hand, but with all the digital conveniences in hand. This device is the best that I've tried for writing (and I've tried many, including an ipad pro)

Cons: historically, the price. No blacklight. Clearly the device has been optimized for writing, not reading, although supposedly 3rd party ebook readers like Apollo are good (the device is not locked down and has a hacker community).

I have an ipad pro and a remarkable, and I use the remarkable a lot more. I mostly note take/doodle though. The writing experience is way better.

I've had a Remarkable1 for about three months. It's one of the best investments I've made in a long time. Going to preorder this.

Only caveats - I like aftermarket cases more than Remarkable's. I bought one one from Amazon for about 30$.

Also I've been using staedtler's digital pencils, works great!

Well, that reflects inflated American prices. In India, it is about 270 INR for 90x 200mg, or about $3.65. Non-generic hydroxychloroquine (Plaquenil) is about 3 times the price.

From How the 2009 H1N1 Pandemic Compares with COVID-19:

https://www.bloomberg.com/opinion/articles/2020-03-10/how-co...

For example: Why was H1N1 allowed to spread around the world more or less unchecked, while countries are going to far greater lengths to try to halt Covid-19? Why did the WHO call H1N1 a pandemic but not Covid-19? Isn’t 12,469 deaths a lot worse than the 26 that have been attributed to Covid-19 in the U.S. so far?

That last one is the simplest to answer: Covid-19 is near the beginning of its spread in the U.S., and thus cannot be compared with H1N1’s effect over a full year. If the U.S. death toll from Covid-19 is only 12,469 a year from now, that will likely be counted as a great success. The legitimate worry is that it could be many, many times higher, because Covid-19 is so much deadlier for those who get it than the 2009 H1N1 influenza was.

How much deadlier is still unknown, but of the cases reported to the WHO so far 3.4% have resulted in fatalities. That’s probably misleadingly high because there are so many unreported cases, and in South Korea, which has done the best job of keeping up with the spread of the virus through testing, the fatality rate so far is about 0.7%. But even that is 35 times worse than H1N1 in 2009 and 2010. Multiply 12,469 by 35 and you get 436,415 — which would amount to the biggest U.S. infectious-disease death toll since the 1918 flu. Hospitalization rates are also many times higher for Covid-19, meaning that if it spread as widely as H1N1 it would overwhelm the U.S. health-care system.

That’s one very important reason governments (and stock markets) around the world have reacted so much more strongly to Covid-19 than to the 2009 H1N1 pandemic. Another reason is somewhat more hope-inspiring. It’s that public health experts generally don’t think influenza can be controlled once it starts spreading, other than with a vaccine, whereas several Asian countries seem to have successfully turned back the coronavirus tide, for now at least.

Influenza can’t be controlled because as much as half the transmission of the disease occurs before symptoms appear. With Covid-19 that proportion seems to be lower, meaning that even though it’s more contagious than influenza once symptoms appear, it may be possible to control by testing widely and quickly isolating those who have the disease.

The S&P futures dropped by 5% so far.

Oil and other commodities also took a dump.

https://m.investing.com/indices/indices-futures

https://m.investing.com/commodities/

A lot of individual differences in terms of cognitive decline.

ruth bader ginsburg is 86 years old, and still seems sharp as a tack.

I think it's 33% distrust in governmental institutions, especially the liberal elite fake news CDC, 33% the fact that it's mostly hit large cities so far, and 33% the direct actions of the administration and the right wing media machine.

I think the fact that it's an election year, more people are susceptible to thinking the pandemic is overblown and thus a conspiracy to defeat Trump.

Although MERS is more deadly than SARS-CoV-2, it looks it's less transmissible between people than SARS-CoV-2. I heard an epidemiologist theorize that it might be because people infected with SARS-CoV-2 shed the virus before they show any signs of COVID.

Maybe that's why MERS never spread widely outside of areas where camels don't exist widely.

There is a poll that said that Democrats are taking it much more seriously than Republicans:

https://www.reuters.com/article/us-health-coronavirus-usa-po...

Irony.