grumblingdev

My job would be so easy as long as I can debug and trace things.

But modern software engineering doesn't give a shit about debugging.

There are just endless layers of abstraction, and glueing together 100s of packages of compiled or transpiled code. To debug anything properly I have compile all the intermediary packages and setup the full toolchains they need.

I'm just watching it for 20 years and its getting worse and worse.

New programming languages every few years and the debugging experience starts from scratch.

I just want to be able to easily trace code in a debugger with minimal abstraction.

Everything is so cobbled together and no one seems to get it.z

This obsession with the "stack" of things named like: bloop, blip, blaz...oh we're moving to blap now its really great, I have to rewrite everything in it and now they have an annual conference and I found a job that let's me write blap, and its venture funded.

The problem is no one has the right principles. It's a fashion show and there is just so much money to cover all the inefficiencies of developers fetishizing over the latest crap.

Just let me debug things anywhere in the stack with ease!

I think the idea of one programming language everywhere has sailed, for a while at least.

It looked like JavaScript was going to be able to do it. React and React Native were very promising.

But since we now have Swift/SwiftUI and Kotlin/Jetpack, each platform has a language and framework specifically tailored for it. Except for Windows which is still a shit show.

Attempts to abstract this in a cross-platform layer are becoming more and more difficult, and offering less marginal value (e.g. we now have declarative frameworks natively whereas before we only had React).

Each platform has a recommended way to do everything, and we should follow the conventions of each platform.

I would be interested to hear if anyone has actually had successful though with frontend code sharing...

Each platform has it's own webview control available as a shared library installed with the OS.

MacOS has WKWebKit based on WebKit.

Windows has WebView2 based on Edge/Chromium.

Linux has webkit2gtk based on WebKit.

Tools like Tauri use a simple cross-platform single-header abstraction called webview.h[1].

Electron no longer allows Node.js to be called from renderer processes, all communication with Node.js is done via IPC.

In this case, why do we still need Electron? Why does it have to be tied to V8/Node.js?

The fact that Chromium Embedded Framework exists and is third-party makes me think that Chromium wasn't designed for being embedded, and Electron is filling that gap.

This is elucidated here further here https://trac.webkit.org/wiki/WebKit2:

> it's difficult to reuse their work...if another WebKit-based application or another port wanted to do multiprocess based on Chromium WebKit, it would be necessary to reinvent or cut & paste a great deal of code.

It makes me think that perhaps WebKit was the better choice for embedding. The fact that Node used V8 made Chromium the choice, and that Node being called from the renderer was the original way of working. Maybe because WebKit didn't have a build for Windows was an issue too...

But now that we have Bun, perhaps it's time that WebKit becomes that browser target of choice for desktop apps on macOS.

Unless WebView2 for macOS arrives, which would have a more sane cross-platform story. WebView2 has a very large feature-set though which make take a while to implement for macOS.

[1]: https://github.com/webview/webview/blob/master/webview.h

I’m talking the most native look and feel for the Windows platform.

Is it XAML and C#?

Things like Electron and React Native / Expo always seem really cool. Write once, run anywhere.

When you see how large and well-resourced the companies are who use these frameworks, it really makes you feel as a solo dev, how could you possibly go a different direction. If they have all the money and man-power, and they can't build for each platform specifically, what chance do you have.

For example: VSCode/Discord/Slack use Electron, Facebook Messenger Desktop uses React Native Desktop.

I've finally concluded that it's not worth it. I'm sick to death of battling against some abstraction and build process, to try and do something that I KNOW how I would do it natively. Like when you are trying to get an ORM to do something that you know exactly how you would write yourself in SQL.

We now have declarative UI APIs for each platform (SwiftUI for macOS/iOS and Jetpack for Android), and building on native tech allows better performance, less ram usage, faster startup, smoother animations, more integrated feel.

I really feel like the dream of write once, run anywhere has sailed. Instead of creating abstraction layers in a single language, we should embrace each platform, and use smart code/project generation if we must, allowing the user to fallback to the native language and technology. It just doesn't feel that difficult to learn Swift and Kotlin.

Uses UIKit.

How to tell if its React Native, SwiftUI or just Cocoa?