Phlogistique

It's relevant:

* For projects where one of the main purposes is for the author of the project to learn said language

* For projects which expose an API in their implementation language. In the case of an implementation of a programming language, they might offer embeddability in the host language, or a foreign function interface with the host language.

Hi,

Your post is insightful, but it could really do without the inflammatory death-wishing in 2a.

I do agree with you, but in the specific case of free book sharing - I hear that most of the time, the problems is too many books rather than too few, so you should really not worry about taking a book even if you are not sure you're going to put another one for other people.

Well, same issue and same solution (see other answers), except that in Rust, instead of `RuntimeException` it's named `panic`.

Well, what this API's implementer could have done, is to catch the IOException and throw RuntimeException. That makes sense, because there is no reason during normal program operation for this API to throw IOException, so if it does it must be an internal bug in the library.

This pattern is equivalent to Rust's `unwrap` and `expect`, than can be called to transform a recoverable error into a panic.

I did this back in high school. Turns out at some point I was able to wake up, walk to the computer (which I used as an alarm clock), stop the alarm, get back to sleep, and forget everything.

This is a list of known unknowns. Those are usually not a problem - the problems come with unknown unknowns.

I did this very long ago. It's possible but the documentation was nearly non-existant, it took me a long time to figure it out.

Technically, Gimp too[1].

[1]: https://en.wikipedia.org/wiki/GTK#History

For some reason this announcement gets displayed to me in a unholy mix of French and English:

> Electron 11.0.0 est disponible ! It includes upgrades to Chromium 87, V8 8.7, and Node.js 12.18.3. We've added support for Apple silicon, and general improvements. Lisez la suite ci-dessous pour plus de détails !

> La team Electron est excitée d'annoncer la sortie de Electron 11.0.0 ! Vous pouvez l'installer avec npm via npm install electron@latest ou le télécharger sur notre site web. The release is packed with upgrades, fixes, and new support for Apple's M1 hardware.

Poe's law in action: I'm unsure whether you are mocking people who do not read the article, or if you actually failed to read the article and thought that Ubuntu Mate was some kind of Ubuntu-branded yerba mate.

Actually, both notations are described by an international standard, according to Wikipedia [1]

[1]: https://en.wikipedia.org/wiki/Interval_(mathematics)

Yes, it's standard in France at least.

I use this extension for Firefox, which does the job pretty well: https://addons.mozilla.org/en-US/firefox/addon/remove-youtub...

Just being curious - if your parents are stuck with 10% interest rates while current interest rates are closer to 3%, why are they not borrowing a 3% to reimburse their 10% loan?

The point remains. The Linux branching workflow is vastly more complicated than what GP advocates.

Hi,

This flow works under some conditions only:

* You have working CI/CD that you can trust

* You do not have to support old versions of the software

Example of some situations where these conditions are not met:

* Installs of your software are not reachable over the Internet

* Your software needs manual testing or qualification before deployment

* You do not handle your software's deployment; your client does.

In those situations, you may need to maintain release branches, and backport fixes, etc.

No. The Linux Kernel uses release branches. This thread is specifically about rejecting the use of release branches.

> The IDIOT. Usually a cretin, morphodite, or old COBOL programmer

https://www.lexico.com/definition/morphodite

> Originally: a hermaphrodite; a person having both male and female sex characteristics. In later use also: a homosexual man or woman, especially one overtly manifesting features or attributes regarded as characteristic of the opposite sex; a transvestite.

Oh wow, TIL a new homophobic slur :-(

I don't think that's what the parent comment is pointing at.

What's throwing him off is static method dispatch based on type inference on the return value.

Haskell, for example, does this too:

    class Foo a where foo :: a
    instance Foo Integer where foo = 3
    instance Foo Char where foo = '*'
    
    foo1 :: Integer
    foo1 = foo
    
    foo2 :: Char
    foo2 = foo
    
    main = do
        print foo1 -- prints: 3
        print foo2 -- prints: '*'

That's my favourite explanation so far. That's how I would put it to the student:

Yes, that's a perfectly correct operation. When you take 1/3 of the first table and you put them toghether with 1/3 of the second table, you get 2/6 of both tables. However, that's not what mathematicians mean when they use the sign "+". Let's explain the difference with examples:

* At your table, Bob is 1/3 of the table, and Sandra is 1/3 of the table. Bob PLUS Sandra equals 2/3 of the table.

* Sandra is 1/3 of the table. Alice is 1/3 of the other table. When you put the two tables together, Alice and Sandra are 2/6 of both tables.

The first operation is what mathematicians call "+". They write "1/3 + 1/3 = 2/3"

The mathematicians do not have a good name for the second one, so let's invent one: "1/3 1/3 = 2/6"

What's better with this explanation, compared to the "ratios vs. fractions" thing, or the units thing, is that you do not have to introduce a separate category of numbers that sound very similar but act differently.

I think the idea underlying this post is this:

Sometimes you are creating an application and building its underlying datastore at the same time. Hasura is great for this.

But sometimes you already have a disparate ecosystem of services and datastores and you want to provide a GraphQL API for that. This use case is better-served by other approaches.

Is it the same issue as the infamous "monads tutorials" problem, where the understanding takes a lot of time to infuse but looks obvious in retrospect when it finally clicks?

One thing that I like about the ".txt.vbs" trick is that: Ok, Windows was hiding the file extension, so users where not seeing the ".vbs". But users that were still seeing the ".txt" and thought that was a text file, even though a real text file would have had its extension hidden!

In other words, the "social engineering" trick only worked because users had been previously trained to look at the file extension to identify file type, and then Windows took away the file extensions.

HN is frequently talking about how harmful the impact of UX changes that we push onto users can be. Here's a 20-years-old example!

This is blogspam.

One thing that did bother me:

> Since the Julia-creators also wanted it to be easy to learn, Julia fully supports dynamical typing. But in contrast to Python, you can introduce static types if you like — in the way they are present in C or Fortran, for example.

That's misleading. As Julia co-creator Stefan Karpinski puts it in this great Stack Overflow answer [1],

> This is not the way Julia works – code with type annotations is still dynamic and has the same semantics as code without type annotations.

> ...

> For the most part in Julia, type inference is just an optimization – your code will work the same way with or without it – but with successful type inference, it will run a lot faster.

[1]: https://stackoverflow.com/questions/28078089/is-julia-dynami...

If you are going to a bike shop once a year for maintenance, then you are doing the maintenance you should be doing.

But many people have old bikes with rusty brakes, non-working gearing, and just go on using them until they fall apart.

Also, different bikes require different levels of maintenance. And your riding style and frequency of use affects the speed of wear.

This sounds great! I have often felt the lack of a common language to specify for each review comment if an action is expected. This looks like this convention solves the problem with a nice Schelling point.

nitpick (non-blocking): I won't use the "praise:" keyword as it feels robotic. Praise should feel spontaneous and authentic. But I love the general advice of trying to have at least one praise comment per code review.

I find this comment and the one above way too harsh. The author of the article does not make any strong claim at "science"; it is written as a deliberately subjective series of musings.

They link to the `P` language, which I did not know about.

https://github.com/p-org/P

I found the link interesting because I have at times wondered what it would look likes if FSM were first class control flow features, akin to `if` and `while`.

Though it is probably not practical today, there exists a research field for this kind of problems. The keyword is "homomorphic encryption".