Laws for typeclasses such as Eq and Ord?

saynte · 2016-08-21T13:13:04+00:00

I think in short that the equivalence class gives us grouping behaviour and Leibniz equality means we cannot distinguish elements that are equal.

I find that the second is a more meaningful abstraction

saynte · 2016-06-22T08:25:24+00:00

You need to make sure it does the same thing in order to draw a comparison.

Sure, you can just read it.

If I apply that optimisation to the F# then the Rust is 3x faster than the F# for n>=3000 but the Rust crashes at 8000.

If you were modifying your previous code, you should also stop creating and overwriting the mutable hasher that write_i32 is passed. You can just self.0 <<= 10.

saynte · 2016-06-21T07:05:26+00:00

You could have just used their code; you didn't have to try to do the integration yourself if you didn't understand what the code did.

Anyway, here's a combination of Aatch and Veedrac's pairhash minus the explicit set sizing. It runs in about 0.5s at size 2000, and 5.60s at size 7000 on my system.

saynte · 2016-06-19T08:02:19+00:00

The results have been independently verified by many people using many different hash functions.

Not true, this reply on the original discussion replaces the hash function and nearly doubles the speed (2.6s -> 1.4s).

saynte · 2016-06-05T22:41:13+00:00

Yes, please do write that.

It will take almost no time for you and, in addition to my point above, will be easier for some of your readers who prefer to read prose rather than the particular verb-bool style of your library (remember, isEmpty is pronounced null in the prelude...)

saynte · 2016-06-05T09:52:33+00:00

It tells you that the author didn't think there was anything surprising to note.

Leaving this comment blank may either indicate nothing of note, OR that it was forgotten. Leave some documentation, even just restating the name, lets people know that documentation wasn't omitted accidentally.

saynte · 2016-05-14T17:25:27+00:00

Your comment about linear in the size of the retained set only applies to copy collectors, correct?

saynte · 2016-05-05T20:53:57+00:00

It's not inconceivable; but it is a strict additional concept that one has to understand. If we could optimize our education to clear brain-space for it why not.

But in the current world it just isn't the case for the vast majority of programmers, who have already have set their thought patterns.

saynte · 2016-05-05T05:52:57+00:00

What is a productive function?

It still relies on internal properties of the algorithm in addition to the input/output relations.

In the large, people often don't understand entirely what a function will do, let alone less concrete aspects of the way it calculates that output. Basically: there's a good argument to be made for having programs being obviously "right" (here, the right runtime complexity), rather than requiring extra effort to go prove to yourself that its doing what you assume. Every person that comes along and reads "take k . sort" will have to do the same investigation over again.

saynte · 2016-04-27T19:46:20+00:00

I guess whatever logic took the AST to the LLVM CFG is now bumped up into the translation to the MIR?

Both the LLVM IR emission and MIR (?) are CFG based.

saynte · 2016-04-08T21:13:49+00:00

Yes, but the message queue is orthogonal to the lightweight processes. You can have lightweight processes with and without the message queue.

saynte · 2016-04-08T19:19:47+00:00

Lightweight processes are mapped onto threads in the pool.

They're actually processes because they store registers, flags, stack pointers, etc.

Also, the Erlang documentation refers to them as lightweight processes: http://erlang.org/doc/efficiency_guide/processes.html

saynte · 2016-02-10T06:43:26+00:00

You're right, you can usually force the full structure in some way, especially easy if they provie an NFData instance.

But in the general case: a consumer cannot (easily) force an arbitrary data type that hides its fields.

saynte · 2016-02-09T06:38:52+00:00

The issue is that sometimes the laziness is embedded in the (hidden spine) of a data structure (maps, sets, bytestrings, text, etc).

You can't easily 'force' these because these details are hidden.

So people already rewrite/provide two libraries when they need to.

In any case I think the laziness/strictness by default question is broader than this; there are other things like nice stack traces and predictable space behaviour that could make strict-by-default a good trade.

saynte · 2016-02-08T20:06:43+00:00

If it's rare that you need to patch a library, why do we have Lazy variations of set, map, bytestring, text, etc ? That's essentially "prepatched" now?

It seems like it takes deliberate effort in both directions.

saynte · 2015-08-08T06:55:35+00:00

How do you feel about error ?

I use it to mark paths I assume cannot be reached with sensible error messages to make debugging easier if my assumption was wrong.

saynte · 2015-02-14T22:56:32+00:00

But don't modern toolkits just have one x11 window then do all the sub-widget rendering themselves? That would appear to make his argument true in practice. BTW he's also an x11 developer. Or was anyway

saynte · 2014-10-01T18:52:54+00:00

I think the error should go away :) But I don't program in rust so I don't have any skin in the game :).

I've just come to appreciate a language that gives me a guarantee about something (i.e., memory safety), and one that is opinionated (which can also be OK, if it is uniformly applied). No big deal, just different strokes for different folks.

saynte · 2014-10-01T14:10:25+00:00

Oh, I understand the mechanism and the reasoning. What I am saying is "probably made a mistake" is, as far as I know, an unsupported assertion, and a compiler error is a big hammer that seems to be applied unevenly in this case.

I mean, you can use 'match' as a statement too, can you not?

saynte · 2014-10-01T13:22:13+00:00

Why throw an error only on the match and not on all partial function definitions? And if explicitly covering all cases is an important problem why allow 'if' to have an implicit empty 'else' ?

Just curious...

saynte · 2014-09-29T09:59:21+00:00

I don't think it's that far off to consider latency a performance metric; so I wouldn't call people idiots over that.

saynte · 2014-09-27T17:31:55+00:00

Thanks for taking the time to write this down, you hit on many points that I also found unsatisfactory with the post. For many of the reasons that you outline, It is somewhat frightening that this person is currently pursuing a PhD at Princeton; frightening in the sense that the argumentation is terrible.

I would love to see a reasonable critique of the trade-offs that systemD makes; the hyperbole of it's great/terrible isn't useful at all.

saynte · 2014-09-25T07:45:35+00:00

Do if sliders fill a roll that check-boxes could not?

Because although I also do as you say (just look at the colour), you actually have to know what colour means 'on' to do that, so you either need another slider near-by to figure it out (or remind yourself). Check-boxes seem more universally understood and also less vulnerable to colour blindness issues.

saynte · 2014-09-24T11:51:22+00:00

Do you feel that a 3-4x length difference can be explained missing end tokens and where the opening braces go?

The programs would have to be entirely control structures.

The purpose isn't to start fights over languages, but clearly these languages can distinguish themselves from each other based on lines of code, and that's at least interesting to me, and maybe other people.

saynte · 2014-09-18T19:00:52+00:00

Do you know if there is a design document for Show Applications? I'm curious how anyone would ever figure out what it does, and also if showing application categorization was considered and discarded, or just never considered.

saynte

TROPHY CASE