Well it looks 99% like Haskell, but compiles to JVM, .NET, and PHP. And otherwise seems very "Haskell at home", with moogle (instead of hoogle), and mogdoc (instead of haddock).

Not to diminish any work you did do, but I do think a Haskell -> JVM/.NET/PHP compiler might have done what you aimed for and easier.

Elm:

-- Import under the name "List"
import List

-- Import aliased under the name "JD"
import Json.Decode as JD

-- Import Html, and put the Html type into the unqualified namespace
import Html exposing (Html)

-- Import Http, and put everything from it in the unqualified namespace
import Http exposing (..)

I play it every week. Not going to be on ProtonDB since it's a Blizzard/Activision title, but the Lutris installation for it/Battle.net works fine for me. Occationally Blizzard will push an update to Battle.net that'll break the ability to play their games, usually fixed by a reinstall, and Blizzard's servers are held together by duct tape some times, but all that aside yea it plays just fine

No he did say in a public update video that he did get Hochul to give NYC more from the state's budget. Not like "this fixed everything" kind of money, but some of it was from the State.

And I mean, sure probably from State taxes and all, yea, but that's just how governments work

To answer the headline: Functional languages are as useful in pretty much any context non-functional ones are, they just need to be handled a little different.

Functional languages' goal tend to lean towards static or predictable typing and reduction of clandestine mutable state changes. State has to change in a program, it's just about how its handled, and this is more about reducing referential update behavior.

Like in Python, you can have a list, pass that to a function that returns None, but deep inside that function appends to the list, and you may be surprised that your list is different as a result. This would (typically) not happen in an FP language, you would have to explicitly return the changed list up the stack of functions, and as a dev you could see from a glance that the list could change as a result of the function, leading to less surprises.

"IO" is of course an outlier, as it's leaving the safety bubble the language provided. I could read the same database row twice in 60 seconds and get a different result, because someone else could make a transaction in that time. But once I have read the row and parsed it into a data-model, I can expect that my model in-code won't change unless I tell it to.

2026 update: we now give you the ability... to right click!

Hard at work, there

I think the shallowness of understanding also stems from the codebase itself, and moreso that than the Ai finding where something is.

A poorly organized codebase, dynamic file imports lsp's can't follow, lack of annotations on unclearly-named arguments, etc. are way worse for understanding a codebase than Ai saying "the thing you need is this method", which Ai could also explain how it got there at least. At that point, Ai is a better than what they would have without it.

Write clean, understandable code. Document it, too. Everyone will thank you

Tbh, I'd love to be able to use this less for games and more for just Android apps.

I'd love to move more to a less-Google-owned mobile platform that still has the apps I use and the power to run things. I think the two frontrunners are like /e/OS or GrapheneOS.

But with Lepton: A) there's a better chance of the idea of a Linux-non-Android phone, since Lepton could allow Android apps run on a Linux phone; or B) make Linux tablets better, again with Android apps.

I also have an idea in my head that next "upgrade" I can afford I'll ditch my phone and go for a smartwatch (with 4G/5G) and a tablet (for apps). The best pairing is probably from Samsung, which unfortunately is both Android/Google and now focused on promoting AI features (ew). I'd go for GrapheneOS if I could put it on a tablet of suitable specs, and if a smartwatch would work well with it (which the watch would probably still be Samsung's, but maybe RePebble can do something great?).

But if I could use a Linux tablet? That's a computer at that point, and I could also benefit from having a laptop since there's also things an Android device couldn't do that a computer could (I'm a software dev, it'd be painful on Android). Waydroid/Lepton then supplements the part where there are things Android can do that computers can't, which is just "apps the developer didn't make a webapp/computer app for". Still would have to figure out the watch part, but it's a start

Not HDMI-out, you need some USB-C <-> HDMI cable. Preferrably a dock since there's only one USB-C on the Deck. But otherwise, yes: plug it into a TV and it'll display on the TV, connect a bluetooth controller and you basically have a console.

I was just hoping Steam Controllers were still around to be that controller

With the Steam Deck's success, I'm surprised the Steam Controller didn't return, as I think it would be an excellent companion controller for couch-mode gaming. I'd buy 4 of 'em.

Functional language developers are obsessed with side effects but I rarely ever see problems with it in real code. Like I can remember once in maybe 10 years setting a developer write a "get" method that also wrote to a file. Caught during code review, rewritten easily.

While, sure, get methods writing files could happen in side-effectful code, the side-effect concern is less about that and more of expectations. With OOP languages, class methods can create a dichotomy of expected returns: Using a list reversal as an example, will a list.reverse(some_list) function reverse the list in-place, or return a copy of the reversed list and leave the original in-tact? To know the answer, you have to check the docs or the type signature (which, yes, is easy, but the answer isn't obvious). Which, the main concern is trying to debug things "magically changing", since nested function calls and inherited function calls can modify something from layers upon layers of abstraction away.

FP languages tend to not have this dichotomy, with very few exceptions like IO in Haskell, ports in Elm and Gren, external functions in Gleam, or FFI in Haskell, to name some ways from languages I know, all of which usually move the control of the program outside the language's "default area", anyway. Outside the exceptions, to reverse a list a reverse function needs to be given that list explicitly, and it also will be returning a copy of the list reversed, only and always

"It's just a prank, bro!"

-them, probably

I'm glad. "Prank" videos are awful. A good prank or joke is enjoyed and laughed about by all parties, without incentive or provokation. This is public disruption that some people somehow find funny.