gdotdesign

Same experience for me, it's been great!

I never needed to visit since I could use Wise for banking.

The only thing is that surprised me was the tax rate, when I created my Company the advertised rate was 20/80 but in reality it was ~25/75 and it increased since.

Initially I didn't see the value in React. I thought that the whole virtual DOM compiling on every change was a waste of resources instead of just doing the change itself directly.

But as it turns out it's a great abstraction worth using for the right things (not every part of the web) and one of those are Single Page Applications.

A lot of comments here are about people linking JSX instead of React and that's a good abstraction too. In Mint (https://mint-lang.com/) I'm trying to create a language for SPAs and having HTML syntax helps.

Check out Mint (https://mint-lang.com), it's s language where everything is built in: small to mid size projects can be built without any third party dependencies and JS interop is easy.

Thank you for building this.

The pessimistic one is that most of what needed building gets built, and the remaining work fits in fewer hands.

I don't think that's true, mainly because if it were true it would have happened a long time ago. We will never settle on one version of a thing (let it be messaging, recipes, notes, image galleries, etc...). New variants emerge over time, the only thing AI does is accelerate this.

*weren't

Yes! I'm very close to releasing 1.0 and I'm planning on doing it then.

Thanks :)

I didn't make those threads, so the title choices were mine. I'll do a proper Show HN with 1.0 sometime, maybe with can switch it with that then.

It's perfectly fine to allow if in tags (the compiler can figure it out). In Mint you can do that no problem: https://mint-lang.com/sandbox/6lnZHiG8LVRJqA

    component Main {
      fun render : Html {
        <div>
          if true {
            <div>"Hello World!"</div>
          } else {
            <div>"False"</div>
          }
        </div>
      }
    }

It's nice to see that we are converging on the same syntax I came up for Mint (https://mint-lang.com) 8 years ago (feels strange to write it down). I saw Ripple some time ago its syntax has the same structure more or less (component, style, render, state, etc...)

Thanks for putting these lists together. When Mint reaches 1.0 I'll use the same format to present it here.

I think so, yes.

It's very similar to Mint (https://mint-lang.com/) which I'm building for some time now.

Looking at the samples, it seems Ripple is going the same direction as Mint:

- explicit component definitions

- inlined control flow in HTML tags

- component based styling

- explicit white space handling for element content

- syntax for setting references

I'm not sure why they based it on TypeScript instead of creating a new language completely, since there are a lot of new syntax added (and they have their own extension as well).

If you are looking for something similar, give Mint a try, it has a lot more features, and I'm looking to release 1.0 in the near future.

I'm still waiting to evaluate Zed because I work with/on my programming language which has LSP Semantic Highlighting, but Zed doesn't https://github.com/zed-industries/zed/pull/39539 once it's merged I'll give it a go because it looks like a modern Sublime Text (which I still use). I just wish they would focus on basic editor features instead of adding AI and other non-related features.

Happy New Year from Budapest!

IMHO, Marko and Mint target different things. Mint was specifically made to create Single Page Applications, whereas Marko seems like more for general all things web.

I'll try to add Marko to the feature comparison page soon: https://mint-lang.com/feature-matrix

Still working on the Mint programming language (https://mint-lang.com/) with a 1.0 release in January :). I'm happy with the current feature set, so I'm just polishing and optimizing where I can and giving the documentation a throughout look.

- There is a single root dependency somewhere which gets overtaken

- A new version of this dependency is published

- A CI somewhere of another NPM package uses this new version dependency in a build, which trigger propagation by creating a new modified version of this dependency?

- And so on...

Am I getting this right?

No it's nor supported currently.

1. Inside style blocks it's pretty much regular CSS except for interpolation and if/case expressions, so you can create a style for the root element and then use ids and classes if you desire, but it won't be optimized.

2. CSS definitions without interpolation compile down to static CSS while the ones with interpolation compile down to CSS variables which are set on the element where the style is assigned. This also allows for passig arguments to styles [0].

CSS nesting is supported and the interpolation doesn't conflict with the id selectors because interpolation is not supported in selectors.

[0] https://mint-lang.com/reference/styling/arguments

I think I managed to combine three languages in one with Mint (https://mint-lang.com/):

1. There is HTML (tags) with, but without interpolation {...} you can put string literals, variables and everything that type checks as HTML children.

2. There is CSS but only in style blocks where you can interpolate any expression you need and put in if and case expressions too.

3. There is the normal Mint code you write the logic in (this would be the JavaScript in other languages).

Here is an example which have all three: https://mint-lang.com/examples/7guis/flight-booker

The challenge was to make it seamless enough that so it doesn't look like that we tried to mash languages up, but to make them form a different language that is consistent and simple at the same time.

Lovin' this! Though I'm not a fan of the design but like the spirit of it.

I can't fathom why we can't have a modern car with analog displays and switches in the cockpit.

I own a 25 years old car which only has a digital radio (removeable!) and that's it, perfectly enough.

Thank you!

I'm still working on the Mint programming language (https://mint-lang.com/) and DevBox (https://www.dev-box.app/) which is a desktop application/browser extension/web application with a bunch of small tools.

DevToys (https://github.com/DevToys-app/DevToys) has a CLI version like this.

Also, DevBox (https://www.dev-box.app/) which is a collection of small tools for multiple platforms which I've been building since 2021.

Just a few days ago the apartment above ours burned down alledegly because of an explosion of an ebike battery. They left it charging overnight and exploded in the morning. Fortunately nobody got hurt, but it was really scary experience.

I've done something similar for the Mint, and it's try page: https://mint-lang.com/sandbox/try (and all interactive snippets).

The client (CodeMirror) connects to the language server though WebSocket to offer semantic highlighting and some custom LSP actions related to compiling and serving the project.

have you thought about including Form Validation to the core lib?

There is a module for that in the standard library (https://mint-lang.com/api/Validation). Moving the functionality into the language level is intriguing.

Thank you! And it's written in Mint :D