I'm keeping an eye on Croquet: https://www.croquet.io
1,507 karma · joined March 9, 2014
@ariaminaei
I'm keeping an eye on Croquet: https://www.croquet.io
Virtual worlds (a model of the real world) could also be useful. Like, let the side effect run in the virtual world and let me inspect that virtual world. Here, "me" could be a programmer figuring out how to code against your API, or some ML thing trying to figure out how to make two APIs talk to one another.
Immutability is a different beast, but it appears that decentralization/p2p is working on it through necessity.
Like this: https://gist.github.com/AriaMinaei/69e1a9166e7ffbd61e7f6709d...
Here is a scribble: https://gist.github.com/AriaMinaei/69e1a9166e7ffbd61e7f6709d...
Edit: Just wrote some pseudo code: https://gist.github.com/AriaMinaei/69e1a9166e7ffbd61e7f6709d...
1. Emphasize synchronization over imperative API calls. Imperative APIs encourage data silos. They are the underlying technical part of the problem that Zapier and ITTT try to solve. See [0] and [1] for some ideas.
2. Allow users to submit "agents" rather than "requests." An agent is a small program given extremely limited resources (limited process/memory/runtime budget) that you can safely run on your server. It is a possible answer to many of the standards/protocols that wouldn't exist if frontends were running on the same machines as backends. [2]
3. Emphasize composition over integration. Functions compose (nest, recurse). Event emitters don't. As long as APIs are built to be integrated rather than composed, making them work together is a full-time or full-company job (eg. Zapier).
4. Make things immutable. Immutability allows APIs to "play" with one another without fear of setting off the nukes (ie. side effects). It's possible that this approach would make it so that integrating two APIs becomes a job for ML/AI rather than humans.
[0] https://github.com/braid-work/braid-spec
[1] https://writings.quilt.org/2014/05/12/distributed-systems-an...
The syntax was again "ugly" but some people were so excited about the language that I had to look into it, which is when I learned why the syntax looks the way it does, and how powerful it is because it looks that way.
Needless to say, I felt monumentally stupid, not just for having done myself the disservice of not looking into lisps earlier, but for having the audacity to write things off out of "ewww" feelings. A perfect exhibit of programming being a pop culture and me being a mindless consumer.
Thankfully I learned my lesson, which came in handy when I came across Smalltalk. The syntax is powerful [0], and good luck getting that kind of power out of any conventional syntax language.
[0] among many other aspects.
Also see Glamorous Toolkit [0] where visualization is a core part of the development process.
The Github thread starts with making the spec and adblockers compatible [0]. You seem to be of the opinion that they are, or that their incompatibility is better solved on a different layer. If so, your input would be appreciated at that thread, which is still active.
[0] And in response to the push back, explains the incompatibility.
That's actually a good example of choosing the right tradeoff in demanding right to repair. Again, people are asking for replaceable batteries, not interchangeable RAMs (which would effectively disallow SoCs). This seems to limit the downsides of regulation to pretty much nothing.
A common worry about regulation is that it'll snowball [0] and stifle innovation. But R2R isn't asking for generic regulation. It is asking for specific and imo sane things like replaceable batteries. That is not too much to ask.
[0] As in: "If we give them batteries, pretty soon they'll ask for generic SoCs on phones" or something like that.
By "obfuscate," I meant obfuscate the URL, which has been mentioned multiple times in this discussion, so I thought it wouldn't be confused with code mangling.
This comment illustrates the point very well imo: https://github.com/WICG/webpackage/issues/551#issuecomment-6...
I'm happy to explain more if you frame your question (for which you seem to already have an answer) less combatively.
Apple is in fact uniquely positioned to introduce a better sandboxing model. They control most of the stack, crucially the CPU and the build toolchain, not to mention the PL. They could, were they not so reliant on the App Store auditing process, make it less likely for people to develop malware and privacy-invasive software, by building better abstractions around processes and IPC, through eg. virtualization and capabilities [0].
That, of course, would take away the main raison d'être of App Store, which is a significant money-maker for Apple.
[0] https://fuchsia.dev/fuchsia-src/concepts#fuchsia_is_designed...
If your point is that there is a trade-off to modularity, I'm not sure who it is in response to. It's obvious that modularity has a tradeoff. And I don't see any significant group in this conversation contending that. Nobody is asking for a user-replaceable RAM on an iPhone.
My own point (and R2R's I think) is that Apple, in most cases makes hard to repair products not as a tradeoff in favor of simplicity/compactness/robustness, but to increase profit.
Speaking specifically of my MBP Retina, and looking inside, I fail to see how eg. a soldered NVME would make the laptop any thinner. There is plenty of space created by the much thicker heat sink, leaving room for a bunch of components to be modular.
The reason all these components are soldered in is to make it hard for users or small shops to do quick repairs and cheap upgrades.
You must buy a new laptop for a RAM upgrade.
Apple negotiates with component suppliers as a single buyer, drives the price of components down, keeps all the savings to itself, and re-sells the components at an exorbitant markup.
It is ridiculous for anyone to think this has got anything to do with quality.
But this particular use-case would still play well with DRM as it's implemented today. Netflix on the browser still has DRM, but since the <video> element is standard, it can still be hooked into and decorated.
This is my use-case:
Kindle has a feature called "Audible Narration." You buy a Kindle book, and the Audible audio book, which allows you to play the audio book while it highlights the words on the Kindle book as you're listening. This effortless switching between audio and text enables some interesting reading behavior. Certain books become easier to read. Note taking also gets much easier (Highlighting text is much easier than bookmarking timestamps on an audio book).
The problem is, getting your annotations and highlights and other data out of Kindle is very difficult, because Kindle does not have a public API. Same with Audible.
So I'm thinking of emulating Audible narration with a hybrid ebook/audiobook reader app. The ebook would be a simple HTML page (converted from epub, formatting be damned) and a simple audio player. As the audio plays, the HTML page would scroll and words would be highlighted.
Challenge is to timestamp tag the HTML with the audio track. I'd guess I could TTS the audio track and then somehow diff the generated text with the epub content. Given that some audiobooks are abridged, some read the footnotes on each mention, and some explain the visuals, I would assume diffing would not be very straightforward.
Do you know of any solutions I could look into?
Also check out LanguageLearningWithNetflix [0] which lets you watch videos with two subs in different languages, displays the subs as HTML so select/copy/define will work (and it has a built-in dictionary too). It also allows you to quickly jump to the beginning of each sentence so you can hear it multiple times, which helps improve your listening skills. For me, it has been a fun way to improve my German.
On a side-note, please notice how none of these great features are available to mobile users. iOS for example, is technically perfectly capable of supporting this kind of extensibility, but the App Store model limits it to a few narrow and specific use-cases.
In case you can get in touch with the operators of the website, it could be helpful to let them know that it's common in Germany (and likely elsewhere) for people to avoid entering their credit card information on most websites due to security/privacy concerns. Being able to pay through trusted intermediaries (like PayPal) would make it more likely for people to make a donation.
Other than aesthetics, what are the advantages of the point cloud? Higher bandwidth?
Also, if you were to transfer 100s of megabytes of data from device A to B, using A's display and B's camera, what tech would you look into?
I feel that way when I'm writing text and code.
But when doing visual design, or playing with a demoscene setup, I tend to feel limited by the number of variables I can simultaneously control. I have tried using MIDI nobs and sliders, but the bottleneck is how many fingers I have, rather than the number of input devices in front of me.
You are asking for a solution before agreeing that there exists a problem.
This is the "I'll listen to your problem if the solution is convenient" mentality. It's inside-the-box thinking. It holds you back.
Plus, the value of the cloud app is not just your data, but the network effects. Like, if you've emailed links to a GDocs document, and 5 years later you decide to move to another service, those GDocs links will 404, regardless of whether you've transferred all of your data to the new service.
With local-first apps, the URL starts with you, not some some-sass-provider.com.