website VS applin-rails-demo

That’s starting to change now where you have things like Flutter which get you native cross platform apps with excellent documentation https://docs.flutter.dev/

Read all about dart language from documentation. This might take 2 days. You will get most value, videos are too slow. https://dart.dev/language Then read https://docs.flutter.dev/ skim over, try some things, to get familiar with how things work. Finally find out what state management they are using. Learn about it. Depending on how good programmer you are, you could be good to go by Monday.

How the examples on https://docs.flutter.dev work

In Flutter, a widget's "scope" refers to its enclosing widget tree and the context in which it is defined. While a widget can access properties and methods of its immediate parent and itself, accessing widgets higher up (ancestors) or lower down (descendants) in the tree can be challenging.

Official Flutter website: flutter.dev Flutter Documentation: flutter.dev/docs Flutter Widget Catalog: flutter.dev/widgets Flutter API Reference: api.flutter.dev

I would always recommend the really well done official flutter documentation ( https://docs.flutter.dev ) with its tutorials, codelabs, cookbooks and the docs themselves.

- https://docs.flutter.dev/ - generic app development approach with a common code base for all major user platforms. This is NOT just for web3 / blockchain apps but for any app that exposes a UI and works on desktop and mobile as Web or Native

Flutter Documentation: https://docs.flutter.dev/

> We’re currently using boring, synchronous, Python, ... We previously tried Eventlet, an async framework ..., but ran into so many bugs ...

I had a similar experience using async Rust to make a boring HTTP server. Debuggers can't trace across `await`, so debugging was a very slow manual process. Also, I wasted a lot of time dealing with borrow-checker errors.

I finally gave up and tried using Rust HTTP servers that let you write threaded request handlers, but there was only one (Rouille) and it had show-stopping problems. So I wrote a good one:

https://crates.io/crates/servlin

You can use Servlin to make a boring HTTP server in Rust, with threaded request handlers (no async). I use Servlin to serve https://www.applin.dev , running on Render. I'm also using Servlin (and Applin) to build a mobile app.

I'm dealing with this daily as I build Applin.

Shameless plug: Backend engineers can use Applin to build iOS apps, without writing any frontend code and without struggling to understand Apple's poorly-documented buggy APIs. https://www.applin.dev

Hi HN, I'm a backend engineer who made an app and didn’t like the tools. Then I made the thing I needed: a mobile app toolkit for backend engineers. I'm calling it Applin™. :)

https://www.applin.dev/

How it works: You make an HTTP server that returns JSON objects that define page content. Then you make a mobile app that calls the server and renders the pages using native widgets. Applin is the server and client libraries that make this easy.

Server libraries: Currently there's Rails https://rubygems.org/gems/applin-rails and https://github.com/leonhard-llc/applin-rails-demo . Which languages shall I add next?

Client libraries: Currently there's iOS https://github.com/leonhard-llc/applin-ios . Which platform shall I add next?

They say, if you're not embarrassed by the quality, then you're launching too late. Applin is usable and not yet pretty and not yet comprehensive. I need customer feedback on priority and requirements.

To try it out right away, use https://apps.apple.com/us/app/applin-tester/id6464230000 and tap the rails-demo link.

The hardest part of this project was making the client update the page without losing keyboard focus and scrolling to the top. To do that, the code must pick the correct existing widgets for each new version of the widget tree. The current (working) version performs five passes over the widget tree: first picking focused widgets and their ancestors, then focus-able widgets, then other stateful widgets, then widgets with matching attributes (label, URL, etc.), and finally former siblings of the correct type. Then it creates any new widgets. Now that it has widgets for the new tree, the code updates the widget tree without removing any sub-widget that will be added again. This prevents losing keyboard focus and prevents resetting scroll positions. Here's the code:

https://github.com/leonhard-llc/applin-ios/blob/main/Sources/ApplinIos/page/widget_cache.swift

Please try out Applin, use it at your company (buy a license), and let me know what features to build first! Post a comment here, add a GitHub issue, or email me at [email protected] .

To get updates, join https://groups.google.com/g/applin-announce .

Thanks for reading! :) --Michael