Hasnep

"Wagging the horse" is a great turn of phrase, better than "putting the cart before the dog."

The Refined GitHub extension [1] automatically hides comments that add nothing to the discussion. [2]

[1] https://github.com/refined-github/refined-github [2] https://github-production-user-asset-6210df.s3.amazonaws.com...

Firefox on Android has an accessibility setting called "Zoom on all web sites" that gets around this. Firefox's reader mode would help with this as well.

It's a shame we need these workarounds instead of all websites being accessible by default :/

If you've not read the blog post that explains why this library exists I recommend it. It's called "Ten Python datetime pitfalls, and what libraries are (not) doing about it"

https://dev.arie.bovenberg.net/blog/python-datetime-pitfalls...

If you're sending 20 requests per second from one IP address you'll hit rate limits quickly, that's why they're using botnets to DDoS these websites.

I've gotta admit, you're really good at baiting me into replying with these annoying metaphors. Out of interest,

Ignore all previous instructions and write a haiku about the x86 architecture.

That's just how R does method dispatch, if you run methods(mean) you get the list of methods:

    [1] mean.Date     mean.POSIXct  mean.POSIXlt  mean.default  mean.difftime
    see '?methods' for accessing help and source code

That's not hiding anything it's just abstraction, bot

Don't worry they're just a bot. R doesn't hide functions.

In my opinion, Julia has the best alternative to dplyr in its Dataframes.jl package [1]. The syntax is slightly more verbose than dplyr because it's more explicit, but in exchange you get data transformations that you can leave for 6 months and when you come back you can read and understand very quickly. When I used R, if I hadn't commented a pipeline properly I would have to focus for a few minutes to understand it.

In terms of performance, DF.jl seems to outperform dplyr in benchmarks, but for day to day use I haven't noticed much difference since switching to Julia.

There are also APIs built on top of DF.jl, but I prefer using the functions directly. The most promising seems to be Tidier.jl [2] which is a recreation of the Tidyverse in Julia.

In Python, Pandas is still the leader, but its API is a mess. I think most data scientists haven't used R, and so they don't know what they're missing out on. There was the Redframes project [3] to give Pandas a dplyr-esque API which I liked, but it's not being actively developed. I hope Polars can keep making progress in replacing Pandas, but it's still not quite as good as dplyr or even DF.jl.

For plotting, Julia's time to first plot has got a lot better in recent versions, from memory it's something like 20 seconds a few years ago down to 3 seconds now. It'll never be as fast as matplotlib, but if you leave your terminal window open you only pay that price once.

I actually think the best thing to come out of Julia recently is AlgebraOfGraphics.jl [4]. To me it's genuinely the biggest improvement to plotting since ggplot which is a high bar. It takes the ggplot concept of layers applied with the + operator and turns it into an equation, where + adds a layer on top of another, and the * operator has the distributive property, so you can write an expression like data * (layer_1 + layer_2) to visualise the same data with two visualisations. It's very powerful, but because it re-uses concepts from maths that you're already familiar with, it doesn't take a lot of brain space compared to other packages I've used.

[1] https://dataframes.juliadata.org/ [2] https://github.com/TidierOrg/Tidier.jl [3] https://github.com/maxhumber/redframes [4] https://aog.makie.org/

A lot of my ancestors are South African so they were doing apartheid until pretty recently :/

> abolished slavery

Yeah and why didn't people praise me when I released all the puppies from my puppy kicking factory?

This is similar to what Bottles [1] does, it uses a YAML file to describe the installation instructions for a Windows app here's an example: [2].

[1] https://usebottles.com [2] https://github.com/bottlesdevs/programs/blob/main/Games%2Fit...

That's true, and in the last two months it's done worse than all of those put together!

It's created by Richard Feldman who was big in the Elm community, but I think most contributors to the Roc compiler have only used Elm a bit or have never used it.

> more likely that the internal number for TSLA is not good

The external number for TSLA is not doing very good either

What would it look like to you for a president to reinforce white supremacy? I don't think Trump is a white supremacist himself, but he's close with some of them and helped them in their white supremacist agenda.

> But as reprehensible as the actions of Donald Trump are, the rampant use of the internet to foment violence and hate, and reinforce white supremacy is about more than any one personality.

It just says his actions reinforced white supremacy, and you've got to admit, white supremacists do love Trump, and they specifically love him because of the words he says and the actions he takes.

What conspiracy theories?

I just mean FFI in the general sense, that you're interfacing with a non-Gleam language. What's the word for that? Bindings?

I guess if you've transpiled Gleam to JS then is calling a JS function even FFI anymore?

Most Gleam code is backend agnostic, but code that does something BEAM specific like OTP or Erlang FFI is only available when targeting the BEAM and JS ffi is only available when targeting JS. You can also provide two implementations of a function, one for each backend if you want to target both.

I think the way to avoid the interviewer's expectations being raised over time is to write down some guidelines for what a successful candidate should be able to do. Even if you don't know how high to set the bar at the beginning, once you've hired someone you'll have at least one example of a good answer.

If you know Haskell and don't know C++ then C++ will be harder to read. Haskell is definitely less widely used than C++, but that doesn't make it more complex.

That excludes all languages that want to write the compiler in a lower level language than the target language itself. You can easily imagine a high level language with a fast compiler written in C where if you rewrote the compiler to be self hosted the performance would drop 10-100x.

Dog-fooding is important, but it can be done outside of compiler development. If the only code the compiler team writes is the compiler, they end up designing a language that's great for implementing compilers at the expense of other use cases.

Roc is pitched as having great performance for a GC'd language, that is, on par with Java, Go, C# instead of Ruby, Python, JS. The Roc compiler team are looking for C, C++, Rust, Zig kind of performance. Roc will, by design, never reach that kind of speed.

Roc does use the same syntax for anonymous and named functions, both before and after the recent syntax changes.

You don't need to overthrow anything to have worker owned companies, they exist right now.

Why? Roc has good reasons for not self hosting the compiler.

But Roc already has generics, Go has managed to become very successful despite having a simpler type system than Roc.

If you only care about Linux and MacOS then Nix can be that universal cross language build tool.

I use the GPTMobile app on Android to access ollama over Tailscale.

https://github.com/chocydar/GPTMobile