tcard

I think it's fair to say Smalltalk(s) have had in many aspects the most advanced IDE in existence at every moment since its introduction.

Demos for a couple old versions: https://www.youtube.com/watch?v=NqKyHEJe9_w Demo for Pharo: https://www.youtube.com/watch?v=baxtyeFVn3w

Interesting perspective. It reminds me of Eve [1], which was all the rage over here a few years ago.

[1] https://witheve.com/

The earliest version I could find [1] is already written in C.

[1] https://github.com/dspinellis/unix-history-repo/blob/Researc...

> you can get a strong cryptographic identity for (almost) anyone on the service, which you can then sign/encrypt to, verify for, etc.

I made https://sshign.tcardenas.me/ to take advantage of this. For example: [1]

In the end, it isn't that useful. I only routinely sign digitally to deal with the (Spanish) government, and they provide their own certificates and software to do that.

[1] https://sshign.tcardenas.me/?signer=github.com%2Ftcard&messa...

This is definitely not Stallman's take on "this", "this" being _OP's feelings_ or maybe how to deal with regret generally, not whether having children or not is or isn't a good idea.

Sure, but plenty of type systems are Turing complete. What makes this demo impressive is the (unique?) feature of string literal types and template literal types, which lets you operate on text (like, actual text, with no weird type-level encodings).

That's type safety, not memory safety.

... But no, Go isn't memory safe, insofar data races can cause memory corruption.

He's also a prominent contributor to the Go ecosystem.

https://github.com/BurntSushi/toml

https://github.com/BurntSushi/xgb

https://github.com/BurntSushi/wingo

Not for Rust itself, but there's an interpreter for Rust's MIR: https://github.com/rust-lang/miri

Who's "they"?

Surely you don't mean the Go team, which has had this in the language FAQ since 2009 [1]:

Why does Go not have generic types?

Generics may well come at some point. We don't feel an urgency for them, although we understand some programmers do.

Generics are convenient but they come at a cost in complexity in the type system and run-time. We haven't yet found a design that gives value proportionate to the complexity, although we continue to think about it. Meanwhile, Go's built-in maps and slices, plus the ability to use the empty interface to construct containers (with explicit unboxing) mean in many cases it is possible to write code that does what generics would enable, if less smoothly.

[1] https://github.com/golang/go/commit/dd64f86e0874804d0ec5b713...

While that would probably be very valuable, it will probably come with lots of implementation details that won't really matter to you unless you plan to write a database yourself.

I'd suggest this one: https://dataintensive.net/ Its intended for _users_ of databases, that is, developers incorporating databases (and other kinds of data systems) into their applications. It gives just enough explanation on how those systems work and what they can (and can't) provide, and also gives a more general overview of what's available beyond relational SQL databases.

This was also commonplace in Spain, traditionally. Some people, especially old ones, will say "si Dios quiere" literally every time they refer to any event in the future, even if it's just "see you tomorrow". Not doing so would be considered a "challenge" to God, or Fate, more generally.

Curiously, from "inshallah" Spanish got the word "ojalá", a very common term for expressing hope of something happening (and with no religious or any other "deep" connotation anymore; just like you'd use "I hope").

Universidad Politécnica de Madrid, too.

The author is asking for, and actually built, https://honeycomb.io.

Example signature: https://sshign.tcardenas.me/?signer=github.com%2Ftcard&messa...

These are two manifestations of the same feature: function arguments's default values are evaluated when the function is defined.

In one case, the value is a non-mutable int, while in the other it's a mutable list, but in both cases each call to those functions will share the same value for that argument (unless overriden).

Limbo, one of Pike's (et al) predecessor languages to Go, did have sum types, called there "pick adts".

Some people are ridiculously daring at dismissing others's reputations without the most basic of background checks.

Other things equal, if companies need to pay severance, employees get paid less each month, because companies need to take into account expected severance costs in their total labor costs and there's less money left for other benefits.

So all employees effectively pay for layoffs, which goes against you if you're not the one that gets laid off.

(I am very much in favor of mandatory severance and generally other kinds of safety nets.)

`curl X | bash` provides _more_ transparency than most other usual methods of software distribution, as I can always inspect X, which is usually a simple, self-contained script.

In contrast, running code from an unaudited source (GitHub, NPM, etc.), or executing a binary from some random website, all less transparent yet just as dangerous, but for some reason raise way fewer eyebrows.

Svelte.

In mobile code, a builtin runtime means less code to download, which may be preferable to GC performance.

> And around WW2 time, there was an actual civil war.

Not over the Catalonia issue, by any strecht. (Although Catalanists did take sides.)

> why Catalonia wants to separate from Spain?

I won't actually answer the question (it's complex, and others have done so already). I just want to make sure people understand that we don't really know what "Catalonia" wants because no real referendum has taken place.

Catalonia is a heterogeneous society that has attracted lots of immigration from poorer regions of Spain over the last decades, and claiming that "Catalans" want independence without doubt can only be done by adopting a dangerously ethnocentric meaning of "Catalan".

If you look at regional elections, separatist parties have consistently achieved less than 50% of the votes, even when posed as "plesbicitary" [1] on the issue. They've only managed to form governments because, as it's often the case, the electoral system over-represents rural areas.

[1] https://en.wikipedia.org/wiki/2015_Catalan_regional_election

Yes, you do, in countries with universal healthcare, such as Spain. Even to undocumented immigrants.

Right, but that's no longer "just" jump tables, you need additional JIT logic for those tables to be correct.

Plus, in a JIT you can go even further and just do direct calls, no need for the indirection of tables.

You can't use jump tables in Objective-C because methods can be added to objects at runtime.

It seems it's generated by the protoc compiler. E. g. https://github.com/weaveworks/common/blob/80ff0769bb38e575cd...