> div() .flex() .flex_col() .gap_3() .bg(rgb(0x505050)) .size(px(500.0)) .justify_center() .items_center() .shadow_lg() .border_1() .border_color(rgb(0x0000ff)) .text_xl() .text_color(rgb(0xffffff)) .child(format!("Hello, {}!", &self.text)) .child( div() .flex() .gap_2() .child(div().size_8().bg(gpui::red())) .child(div().size_8().bg(gpui::green())) .child(div().size_8().bg(gpui::blue())) .child(div().size_8().bg(gpui::yellow())) .child(div().size_8().bg(gpui::black())) .child(div().size_8().bg(gpui::white())), )

Your example would look like this:

    export component Hello inherits Rectangle {
        in property <string> text: "World";
        width: 500px; height: 500px;
        background: #505050;
        border-width: 1px; border-color: blue;
        drop-shadow-blur: 15px; drop-shadow-color: #0008;
        VerticalLayout {
            alignment: center; spacing: 12px;
            Text { text: "Hello, \{root.text}!"; font-size: 20px; color: white; horizontal-alignment: center; }
            HorizontalLayout {
                alignment: center; spacing: 8px;
                for c in [#f00, #0f0, #00f, #ff0, #000, #fff]: Rectangle { width: 32px; height: 32px; background: c; }
            }
        }
    }
    

That's is not about just Rust ... Any domain has its own optimal or sub-optimal language describing it. Criteria of optimality is a bit subjective of course. Like: INI, TOML, YAML, etc. are better (YMMV, again) for user facing configs than JSON or XML and so on.

I think that HTML is better for defining hierarchical UI structures and CSS and CSS selectors are (arguably again) better to define UI styling.

My Sciter[1] was initially using .FRM alike inputs (VisualBasic forms, good for IDE but bad for a human) but I quickly discovered that having styles, structure and code-behind-UI in single PL makes non-manageable mess. So Sciter uses HTML, CSS and JS we all familiar with. Not 100% match of course but good enough.

[1] https://sciter.com

They have no shame in deploying a 300 MB hot mess bundle.

Here's a more idiomatic version of the previous example. IME gpui (and iced) is a lot easier to extend than something with a DSL, and if you check out the gpui example you'll see that gpui provides convenient methods to get consistent styles vs the Slint example where you hardcode widths and sizes. Those hex color abbreviations give me a facial tic every single time.

    use gpui::{black,red,green,blue,yellow,white};

    let Self{text,..} = self;
    
    v_flex()
        .gap_3()
        .bg(rgb(0x505050))
        .size(px(500.0))
        .justify_center()
        .items_center()
        .shadow_lg()
        .border_1()
        .border_color(black())
        .text_xl()
        .text_color(white())
        .child(format!("Hello, {text}!"))
        .child(
            h_flex()
                .gap_2()
                .children(
                    [red(), green(), blue(), yellow(), black(), white()].map(|color|
                        div().size_8().bg(color)
                    )))

Btw, a rug pull can happen under even the most permissive licenses. As we've seen in the past with some project changing license or direction. That's more or less already happened with GPUI when Zed refocused development on its own needs rather than other GPUI users resulting in several forks.

It even added ANSI colour support... which I am still on the fence about but it did make the very good point that it means the logging is exactly the same in GUI and CLI mode.

I'd like to know it. I don't think that it can be substantially better. You have to compromise between the amount of customization you are allowed to do and the amount of options you have to pick values for.

I can't vouch for GPUI, I don't know how good its compromise is, but it bears enough similarities to other modern UI-toolkits. I don't think there is a better way, but if you know one, I'd like to know about it.

And, well, don't forget, it is a front-page example, that is not necessarily an example how one should compose their code, it demonstrates what you can do with GPUI. In real life code you'd probably move those children's construction into separate named functions, maybe you'd use some predefined styles to apply to individual elements, instead of picking fg/bg/text-colors, maybe sizes and some other attributes for each one explicitly, and maybe some other tricks.

After 10 or so of those you'll start dreaming of

   border-left: 2px solid rgb(0 0 100%);

┠

or more explicitly

├2

that'd be perfectly paired with a dream-like visual designer that doesn't exist?

Also, this is basically what Tailwind code looks like.

On a more serious note I feel like it's not bad but could be improved if they managed to break it down by styling domain (sort of like SwiftUI).

Something along the lines of .flex(gap: 2).text(size: "xl", color: ...)

It's more efficient now than it used to be - by which I mean the total taken by HFTs is lower than what people used to pay in spreads and commisions. Price discovery is better (you get closer to a fair price if you trade) and spreads are lower. The whole industry that used to prey on spreads and ignorance of retail investors is gone. What not to like about HFT?

Maybe they're both bad?

I’d estimate the total global HFT revenue to be 100 billion dollars a year, which is less than Apple and a tiny percentage of all big tech combined.

Though admittedly the former have turned into pocket attention black holes (and enragement/slot machines) and Apple itself created the scourge of public Facetime calls.

But it would be interesting to see some quantitative data on the effect.

Increasing volatility and enabling fast algorithmic trading may not be good things overall, even if some traders benefit.

And as I noted, if you care about fairness in an online game, usually you try to remove the penalty effects from long ping times (or the bonus effects from short ping.)

Same goes for market making.

If someone is getting rich providing that service - great! Additional bonus is that it's usually very smart people getting the money.

HFT makes the market more efficient, just like the AI eliminating jobs makes business more efficient. It's been numbing watching HN gladly sacrifice it's own to the altar of AI over and over. There is no moral high ground.

Personally as a retail quant, it's really rewarding to build models that extract edge from the market using the very AI tools that have eliminated all hope of ever re-entering the tech-field absent being an entrepreneurial founder.

there is some kind of amnesia that exists with things that used to cost massive amounts but are now close to free. it is just not possible to explain to someone that in the recent past, most people were just unable to own stocks because of costs.

No, it's because people who stand to make money off it want it.

Society is full of examples of things that people want and that would save money and make a lot of sense that are blocked by people rent seeking off the status quo. Free tax filing provided by the government is one particularly obvious example.

No, the problem is that people see rent-seeking behaviour everywhere where it doesn't exist. If you think you can do it better...do it.

Yes, it's a profitable business for HFT. I'm not too bothered by that.

If you want to direct your ire somewhere, direct it at companies like Robinhood that are gamifying financial markets.

Wait till you see what the exchanges make.

Strong disagree. Liquidity at the level of milliseconds means insider trading and other information disparity is more profitable and encourages people to make rash decisions on incomplete information rather than well informed decision.

I'd love go see any information that proves that trades at the millisecond level lead to measurable improvements over, say, trades executing once per hour.

It might be harder for HFT to make money if trades were processed in random order on the hour, though they would probably still have an edge.

Online games that care about fairness try not to turn into a competition for the lowest ping time.

The government abandoning free tax filing software is GREAT for Intuit - they make a lot of money off it. It's awful for the rest of the population and the country as a whole.

They group dozens to hundreds of designs on one chip. The end result is that even hobbyists can afford to have their small ASIC on real silicon. It's still expensive but it's within reach of a serious enthusiast with a steady job.

https://app.tinytapeout.com/calculator The number of "devkits" is the number of chips you'll get, the number of tiles is the size of your design. You can see how many tiles current projects use here: https://app.tinytapeout.com/shuttles/ttsky26d

There is also a FOSSi matrix chat group: https://element.fossi-chat.org/

As this game got more competitive they seem to have branched out into other kinds of business including HFT.

It's the same idea though; one was inbound, the other outbound, and ATC had to distinguish between the two.

[edit: Corrected locations.]

"Hey why did you just tell a flight that's on approach to taxi"

"What do you mean they're right here?"

"No they're on final you twat"

"No this is Patrick"

????????

<issue straightened out>