Uncommon Web Languages?

Haxe Lang has some really nice UI frameworks including HaxeUI[1] and CoconutUI[2] which can both compile for the web using the javascript target. You get AOT type checking + compile-time macros. Haxe, I think, had the poor luck of coming about in the same general time as TypeScript which had a mega corporation propelling its hype and adoption.

[1]: https://github.com/haxeui/haxeui-core

[2]: https://github.com/MVCoconut/coconut.ui

Smalltalk and it’s Seaside server were really something in the early days. Basically broke out of the response/request model by doing your interactions with saved continuations. So if your server function requests a text to be entered, it would be “frozen” there and once the date makes it’s way back, it’ll pick up right there. Obviously that takes some RAM, and coupled with the unusual language, that made it a rare beast. Of course, later we’d escape this interaction model in much worse and wasteful ways, but now it’s the client paying for the RAM.

Tons of them, but I am most interested in the following for various reasons:

PureScript[1] — been around a long time. Looks a lot like Haskell to me.

Derw[2] — Elm-like, interesting integration with Typescript

Amber[3] — smalltalk for js

Rescript[4] — its been awhile since i last looked at this project (during a catastrophic rebrand) so I'm not sure where this project is at, but it did seem very promising to me at one point.

[1]: https://www.purescript.org/

[2]: https://github.com/eeue56/derw

[3]: https://amber-lang.net/

[4]: https://rescript-lang.org/

Also a very big Mint fan. Discovered it thanks to a long post from the Elm founder.

Conceptually very nice. It is like you take React practicality, Ruby on Rails joy and a decent (but not full!) dose of Elm purity and correctness. I am porting a hobby project over to it right now, and then hopefully build more with it, and then eventually maybe contribute.

I also really like Elm, but the problem I have with it is needing all state updates to be centralized, and the kind of coding patterns that leads to. Some people like this, but I prefer the more React-like looseness where objects can have their own private state and so on. Even if that means I give up time travel debugging and so on.

Another uncommonish one is Elixir/Phoenix. I was going to learn this but it felt like 'work' to learn, whereas Mint didn't. And that is mostly to do with how my brain works. I think also Mint optimizes for joy for small projects, whereas Phoenix will come into it's own when you need to scale up, and it is easy to do so, in my opinion.

Since Firebase (or it's competition) can give me live updates, I don't feel I really "need" to learn Phoenix for any use case I will get into.

I'm making a VDOM framework in Ruby. It runs on the server and streams DOM patches to the browser. Components are written in Haml and stylesheets are scoped to components. There is hot reloading too.

I haven't made any public releases yet and I'm not sure if the project is mature enough to receive any attention so I'm not posting a link at this point

Example of a simple component:

    %div Hello

State and callbacks:

    :ruby
      Button = import("./Button")

      def self.get_initial_state(initial_count: 0, **props) = {
        count: 0
      }

      def handle_click(event)
        update do |state|
          { count: state[:count] + 1 }
        end
      end
    %div
      %p
        Count: #{state[:count]}
      %Button(onclick=handle_click)
        Increment

And it's async so if you want to make a component that shows the current time:

    :ruby
      def mount
        loop do
          update(time: Time.now.to_s)
          sleep 0.5
        end
      end
    %p Current time: #{state[:time]}

Clojurescript

UrWeb: https://github.com/urweb/urweb

P-star https://www.p-star.org/

CGI.pm

Do people still use Morfik anymore?

C++ the O.G.

Scala.js

WebScript? ColdFusion?

Hacklang

Already mentioned in original post... but because I love it +1 on Elm

These days... Angular