GTK is written in C, not JS.

The android phone app warns about suspected spam callers, and project fi has a spam filtering feature that has worked pretty well for me.

I switched to Dvorak years ago and it's one of the best decisions I've ever made. It has downsides (awkwardness when typing on others' machines, difficulty typing with one hand while on the phone), but the lack of pain in my hands/wrists is worth it many times over.

Same here, I switched to Dvorak 14 years ago, I was having problems with my wrists and this change fixed most of that. I can get around a qwerty machine pretty well, typing on my phone (qwerty) seems to be fine since I don't seem to use the same muscle memory when typing on a phone (makes sense to me).

The most I had to do was to learn my password (into muscle memory) in both qwerty and dvorak (since corporate windows was qwerty until you login and then user settings take over).

I had pain using non-split/ergo QWERTY keyboard layouts and going ergo solved it for me. Sounds easier than switching to Dvorak.

Same. I've use a Mac for 18 years but I've also use a Microsoft Egro keyboard for almost as long.

A good lightweight alternative is js-joda. I recently switched from moment.js and I've been very happy with it.

https://js-joda.github.io/js-joda/

At 43kb gzipped, it's hardly lightweight - that's 70% of moment.js' size, 4x larger than date-fns

js-joda offers a lot more than lightweight native Date type wrappers like date-fns. It offers separate time and date implementations which allows you to more precisely model your problem. The native Date object always consists of a time, date, and timezone.

For example, a js-joda LocalDate is just a date without a time or timezone. This allows you to cleanly represent things like birthdays, anniversaries or holidays in an unambiguous way.

js-joda is also immutable which in my experience is more predictable and less error prone. With js-joda, "d.plusDays(366);" leaves d unchanged.

js-joda also has very good duration support.

Because it does not use the native Date implementation it is potentially more consistent across platforms. It is also has lots of tests.

If all you are doing is formatting a few dates, date-fns is probably sufficient and it is certainly smaller, but for more intensive manipulations of dates and times I think js-joda is well worth the size.

Just like the OG Joda, I'm assuming it doesn't support nanosecond time resolution?

POWER9 is looking more and more attractive by the day.

What about Spectre and Meltdown? As far as I remember POWER9 was affected at least with one of those.

Only preproduction firmware was affected. Mitigations were implemented in firmware/Linux prior to shipping, and are actually superior to "mitigated" x86.

Before POWER9 shipped (but after the last silicon respin), the processor was vulnerable to both Meltdown and Spectre. IBM determined that this could be mitigated via firmware and kernel changes without another respin.

AIUI, it was determined that for intra-process Spectre mitigation in userspace, recompiling everything to use retpolines and modifying firmware to knacker the branch predictor, etc. in a way that mitigated Spectre had equivalent performance losses. So rather than make people recompile everything with retpolines, the firmware modification option was chosen. This yields a highly conservative Spectre mitigation erring on the side of security rather than performance.

By comparison, Intel/AMD have chosen not to mitigate intraprocess Spectre by default; it has been made the responsibility of application developers to mitigate intraprocess Spectre via retpolines if desired... it essentially shifts the spotlight for performance losses from the vendors to the developers, giving the vendors an escape from having their patches show huge performance losses. But of course, most people aren't shipping software with retpolines, so in practice, the x86 vendors have basically chosen not to mitigate intraprocess Spectre.

POWER9's firmware-based intraprocess mitigations can be disabled at boot if desired (leaving kernel and interprocess Spectre mitigations and Meltdown mitigations in place), providing a level of protection and performance comparable to "mitigated" x86.

Pretty much all high-performance processor designs are affected by some Spectre variant or other, as speculative execution is pretty near universal. IBM is making firmware patches for POWER9 available, with at least some level of mitigation (though not for some older POWER models, which they've desupported).

(Besides, it's not as if Intel is uniquely good at dealing with these sorts of vulnerabilities. The reverse, if anything -- meltdown was a particularly nasty variant which seems to have primarily affected Intel processors, and not even other manufacturers' x86 variants.)

See https://www.ibm.com/blogs/psirt/potential-impact-processors-...

No, it also affects POWER 9 and the ARM A75.

Not that it matters, but it's the other way around (for the most part -- although scepter does affect some non-intel).

Is it possible to match the end of a slice with slice patterns? Something like:

    fn foo(s: &[char]) {
        match s {
            ['a', 'b'] => (),
            [.. 'b', 'c'] => (),
            _ => (),
        }
    }

Not today, but it's coming. This kind of thing does work on nightly.

I was mostly excited about slice patterns because of a pattern I wanted to be able to write:

    some_collection.windows(2).filter(|[a,b]|a==b).map(|[a, _] |a).collect();

Turns out the compiler rejects that with a "refutable pattern" error, because the args part of the filter/map closures do not handle the situation where the slice could be empty, which AFAIK can not occur when using windows/chunks/...

Maybe there has to be some special case handling for this pattern to be valid?

Hm, interesting. I think this isn't possible without integer generics.

Because the pattern in the filter closure would have to be generic over the length or am I mistaken?

From the section on TypeScript:

> enums, which are basically like Java’s enums.

They really aren't. Java enums are somewhat unique in that they are full-fledged classes, not just glorified constants. TS enums are much closer to those of C#.

> Go has more of a focus on simplicity.

But specifically on simplicity of implementation. Which often means pushing the complexity onto the developer.

This line from the article is a pretty good summary of Go in general:

> It looks to me a like a big flaw in the language design to make its implementation easier.

> But specifically on simplicity of implementation

I'd suggest a simple language requires a simpler implementation.

> It wasn't enough to just add features to existing programming languages, because sometimes you can get more in the long run by taking things away. They wanted to start from scratch and rethink everything. ... [But they did not want] to deviate too much from what developers already knew because they wanted to avoid alienating Go's target audience.[1]

Sometimes for simple problems a simple tool is the best fit.

[1]https://arstechnica.com/information-technology/2009/11/go-ne... (via wiki)

I experience something very similar. It turned out to be at least in part from eye strain induced headaches ("computer vision syndrome"). I started paying more attention to ocular health, including following the recommendation of a comment here [0] and lowering screen brightness. It does seem to be helping.

[0] https://news.ycombinator.com/item?id=12582810

IdentityMind | Platform Engineer | Palo Alto, CA | FULLTIME | ONSITE

At IdentityMind Global, we are building a unique platform providing Risk Management services to the financial industry: both traditional payments and emerging cryptocurrencies such as bitcoin. We are experiencing explosive growth and have just deployed our 2nd generation platform which currently scales to hundreds of transactions per second. We are expanding internationally and are also building Big Data analytics and reporting tools to cope with the financial crime prevention requirements of our clients.

This role will extend the existing anti-fraud and anti-money laundering system, and work closely with our data science team to integrate our machine learning models into our real time transaction analysis.

If you are interested in finding out more and explore a possible relationship, we would love to hear back from you to find out more about you and to tell you more about our platform.

Qualifications

* 5+ years industry experience

* Strong full stack Java

* Experience building real time transactional platforms

* Ability to take abstract user requirements and build a product that addresses the underlying use case

* Strong communication skills, both written and verbal

* Ability to work within a small high achieving team, as well as independently

* Self-driven, highly motivated, innovative

Desirable

* Domain expertise in anti-fraud and/or anti-money laundering

* Productizing machine learning models

* Experience integrating with 3rd party services using REST, JSON, XML and/or SOAP

* Cassandra

* Graph Databases such as Titan or Neo4j

* Light Linux administration

* Python or Perl

Apply here: https://www.identitymindglobal.com/company/careers

Feel free to email us at jobs(at)identitymind(dot)com if you have any questions.