Jared Forsyth writes about programming languages and tooling, including Unison, Reason/OCaml, local-first databases and generative art.
HN commenters link his Unison post when discussing algebraic effects and new language ideas, and point to his Reason/OCaml cross-platform material.
Here's the steps to become highly informed in whatever technology:
1) Search through university course listings and youtube for introductory lectures on said subject and it's related subjects. Example, these basic design lectures, note all these lectures are open http://www.cs.cmu.edu/~bam/uicourse/05863fall17/schedule.html or these Stanford iOS development lectures https://itunes.apple.com/us/course/developing-ios-11-apps-with-swift/id1309275316 or Github for curated lists of iOS resources https://github.com/search?q=iOS+resources
2) Go on some freelancer site or Craigslist and offer to make prototype iOS apps or just write your own hobby programs and release them as free software to gain experience/feedback.
3) Search Google Scholar for relevant things to your field/interests, like this Mobile Research Practical Guide and if you don't have access to a library or money use sci-hub http://sci-hub.tw/https://doi.org/10.2200/S00763ED1V01Y201703MPC012
4) Find out core things in said technology you should care about and how to work around them, for example iOS: unpredictable variation in network quality, lowered trust and robustness of mobile elements, limitations on local resources imposed by weight and size constraints, and concern for battery power consumption.
5) Find more advanced courses that help with understanding core issues you've identified https://www.cs.cmu.edu/~15-821/ note all the required reading, again get the doi's and look them up at public…
There are definitely individuals exploring the native-compilation story, for instance bsb-native[0] allows BuckleScript to use OCaml's native compilation tools. Jared Forsyth has also been publishing a lot of material[1] about creating cross-platform project using ReasonML.
The ReasonML team seem to be taking a conservative approach towards what they officially release. They want to make sure that they have a really good plan on how and where to move forward with each of these stories - async, native compilation, cross-platform project, optimizations, etc. Right now they seem to be focusing on creating a really high quality platform for building front-end web applications, but all of these things are on their mind.
I'm actually reminded of the fact that Jordan Walke (initial creator of React) is currently working on a native OCaml/Reason package manager called esy[2], which in my mind is kind of the starting point of the native compilation story: unifying the package and build system of the two ecosystems.
[0]: https://github.com/bsansouci/bsb-native
[1]: https://jaredforsyth.com/
[2]: https://github.com/esy/esy
Update: I'm skimming here (https://jaredforsyth.com/posts/whats-cool-about-unison/) and here (https://joshondesign.com/2012/04/09/open-letter-language-designers) and I see Unison is serious about not having raw text source code as the ground truth. I'm intrigued but don't totally understand yet.
I'm sure this analogy is technically incorrect but: This reminds me of Smalltalk and old Lisps on mainframes shared by many researchers where the main thing was the VM image, not an object file. Though the probably kept the source code around? At a gut level getting rid of source code makes me uncomfortable but I'm ready to learn more.
PS sorry for the ugly raw links I'm on my phone
Not sure about the "no one else has", but maybe you can connect with these people and have a look here and contribute your views to the offline-first movement:
https://www.inkandswitch.com/local-first.html
https://jakearchibald.com/2014/offline-cookbook/
https://medium.com/offline-camp/offline-first-resources-2acc5836e9d4
https://jaredforsyth.com/posts/in-search-of-a-local-first-database/
https://rxdb.info/offline-first.html
(Greetings from a guy running an offline-first B2C app with boring CouchDB for 4 years now :))
> Async isn't really the problem - the same issue pops up with error handling, with resource management
There are ways to handle that, though. It's called algebraic effects and they are nicely implemented in Unison language[1] (although there they're called abilities[2]). It's very interesting language; I recommend reading [3] for good overview.
[1] https://www.unisonweb.org/
[2] https://www.unisonweb.org/docs/abilities
[3] https://jaredforsyth.com/posts/whats-cool-about-unison/
I'll stray from the others and mention Unison Lang.
It's a whole new everything but has yet to prove itself useful for production code.
Its promises, if they pan out, could change how we design data-intensive applications. Its idea about code and data as content-addressable can help simplify some distributed workflows.
https://www.unison-lang.org/
Great summary here: https://jaredforsyth.com/posts/whats-cool-about-unison/