haskman

In India we use QR codes for payments. NFC in general does work (for example, I use a yubikey for 2FA).

Been running GrapheneOS for a while on a Pixel 9, and extremely happy with it! Apart from the usual perks of the FOSS ecosystem, there are a few things specific to GrapheneOS that are not immediately apparent but have turned out to work very well -

1. The Pixel camera app works, including all modes and settings. A camera that takes good photos was absolutely a requirement for me, and the FOSS camera apps are not quite as good yet.

2. I don't have Google Photos and the pixel camera app tries to launch google photos when you want to review the picture you just took. But there is a FOSS app called GPhotosShim that uses the same namespace as google photos and thus fools the camera into launching that app instead. Once launched, it just launches whatever media management app you actually have configured, so it's seamless.

3. Android Auto works!

4. Android QuickShare works!

5. NFC tags / Yubikey integration works!

6. Screencasting works!

7. Sensor access and internet access can be disabled for apps by default (and I do).

YMMV. I run sandboxed Google Play Services on GrapheneOS so almost every app works. My digital payments app works, and the same with most government apps I have tried. My private bank's app doesn't work, but I just use their website for the handful of times a year I need to access it.

Probably the reason why Garmin watches are well supported by GadgetBridge

Setting up GadgetBridge is very easy since it's just an android app. No flashing firmware etc. However, not all gadgets are equally supported, and you should check the support status of your device - https://gadgetbridge.org/gadgets/ (I bought my watch only after checking that page for compatibility).

And once you are on GrapheneOS, break free from your proprietary watch ecosystem and switch to GadgetBridge (https://gadgetbridge.org/)

I run a Thinkpad with NixOS and KDE, a Pixel 9 with GrapheneOS, and an Amazfit watch paired with GadgetBridge on my phone.

It's a testament to the hard work of the FOSS maintainers of these projects, and the spirit of open source, that everything works flawlessly together without any cloud service sucking up my data. For example, I can control youtube and music playback on my laptop with my watch because KDE Connect syncs my laptop and my phone, and gadgetbridge syncs the phone and the watch. The breezy weather app on my phone can automatically push its data to gadgetbridge which in turn pushes the data to the watch. And so on. So many little things, developed independently, working like a single well oiled machine.

I use this to generate a yearly calendar PDF for my eink device - https://recalendar.me/. It generates beautiful pages with internal linking, has support configuring the format, adding/removing sections, and also for uploading ICS files for holidays and such. And it runs entirely within your browser.

> Because it's not for the developers I know – they either want a Macbook or an infinitely configurable (hardware and software) workstation

I know lots of developers (me included) who want something solid and stable and Linux, i.e. definitely not a macbook

The name lens came from the property of their letting you "focus" onto parts of a larger data structure. The prism nomenclature is more tenuous - prisms evoke the imagery of a beam of light splitting into its constituent parts, and with a prism you can see a particular facet of the whole (sum types).

Yes, I use to throw all my random experiments on github. Now I host my own code repos, block bots as much as possible, and keep most repositories private. Those repos that I do open source (because I want to share with people I know), I release under AGPL

If you are looking for a more accessible introduction to lenses, this guide to optics in PureScript is great (and PureScript is basically Haskell). https://thomashoneyman.com/articles/practical-profunctor-len...

On the contrary, GUIs are basically event driven systems that benefit a lot from concurrency

The reasons are going to vary depending on who you ask. I personally don't agree with any of your reasons. In my opinion, as a long time user of Haskell, the practical reasons are the following -

1. Tooling has historically been a mess, though it's rapidly getting better.

2. Error messages are opaque. They make sense to someone familiar with Haskell, but others cannot make the leap from an error message to the fix easily.

3. It's a jack of all trades. The resulting binaries are not small. Performance can be very good but can be unpredictable. It doesn't compile nicely to the web. Doesn't embed well. There is basically no compelling reason to get into it.

4. The ecosystem is aging. You can find a library for almost any obscure usecase, but it would be many years old, and possibly require tweaking before it even compiles.

Accessibility is not an issue. It takes only a little bit of effort to get productive with a Haskell codebase. I think it's more of a mental block because the language is different from what one might be used to. What Haskell needs, and doesn't have, is a compelling reason for people to make that small effort (i.e. the killer usecase).

I gave a talk that goes more into what makes imperative programming better with Haskell compared to traditional imperative languages. https://speakerdeck.com/ajnsit/supercharged-imperative-progr...

In a nutshell, first class effects and built in set of patterns for composing them get rid of boilerplate code. Combine that with type safety and you can churn out relatively bug free code very fast.

That's true, but also true is the fact that a large part of the reason for using alternatives is to avoid this kind of data collection. So it's reasonable to expect to lose users with a decision like this.

Great work! As a nitpick, I noticed that there is some contrived indirection going on inside `Coreutils.Util`. Instead of the Utility class they could have just used an datatype. The current way could be confusing to newcomers looking to learn from this repo (if that was the goal).

Now that I'm looking more carefully at the answer, it is probably correct but just formatted badly with overlapping text - https://imgur.com/a/F7awsTY

Tried "what is (x-2-1)/(x-1)?" and got absolute gibberish in return

I have a P14s Gen4 AMD that works like a dream with Linux

For sure, but they are also much cheaper

Try a Lenovo (thinkpad or ideapad), or a System76, or Tuxedo. Those are generally the most Linux friendly devices.

Look into "Row types" and how PureScript, Haskell, and Elm (to a limited extent) do it.

'{foo :: Int | bar} is a record with a known property 'foo' and some unspecified properties 'bar'. You cannot pass a `{foo :: Int, bar :: Int}` into a function that expects `{foo :: Int}`.

A function that accepts any record with a field foo, changes foo, keeping other properties intact has the type

    {foo :: Int | bar} -> {foo :: Int | bar}

And Filelight from KDE - https://apps.kde.org/filelight/

LazyGit is extremely good, especially when invoked from within NeoVim. I use it as a part of the LazyVim setup.

Yes I see what you mean. I have tmux mouse mode enabled which makes this possible. This works in nvim as well because it also has mouse support. Presumably iTerm supports selecting text in a single pane even when you have mouse mode turned off.

IMO this setting belongs with the application, and especially with tmux and nvim supporting this natively, you don't really need the terminal itself to implement some potentially fallible heuristic. For example with iTerm if you accidentally drag outside the pane boundary, the selection immediately expands to include both the panes, which is not ideal.

> "God did it"

Which god? There are billions of them if you lump all the religions together.

And what did they do exactly? And what are they likely to do in the future? How is this position any different from "we know nothing and can deduce nothing"? I don't know about you but I find that a very sad way to live a life.

I just tried with kitty, and konsole, on linux and selecting text within a tmux split works perfectly. So does copy-paste (use Ctrl-Shift-C instead of Ctrl-C).

1. The scientific method is a way to rank all the available theories that has proven remarkably useful in practice. There is no presumption in the scientific method. It's the right way only because any other way is chaotic and doesn't lead to a single answer (shooting arrows in the dark).

2. To unseat the scientific method would require a method with even more usefulness and consistent and proven track record. There is no other such method.

3. Courts are responsible for application of human law (which is completely different from an exploration of what is true). Would you be able to determine the laws of gravity in a court of law? Does that even make sense?

What's true is determined by the scientific method. You can make as many theories as you want but if you can't make predictions based on that theory and devise experiments to verify those predictions, and perhaps most importantly, be open to abandoning your theory when even a single one of those experiments doesn't pan out, all you have done is shot an arrow in the dark and claimed it could have hit the target. Yes, but that information is nearly useless, and definitely can't be put on the same pedestal as someone providing actual evidence that the arrow missed the target.