What does HackerNews think of share-file-systems?
Use a Windows/OSX like GUI in the browser to share files cross OS privately. No cloud, no server, no third party.
The window and state management can be demoed on my personal site at https://prettydiff.com
I have a Node.js app written specifically for this scenario. You can try my app to see if it solves for your use case. It is designed right now to support file system streaming, text messaging, status messaging, and so forth. It can be supported to messaging anything you need. Remote instruction execution will require more effort for security reasons.
Remote: Yes, Hybrid
Willing to Relocate: No
Technologies: TypeScript, Node.js, CSS, HTML, XML, WCAG, Test Automation, SQL
Resume: https://github.com/prettydiff
Email: [email protected]
15 years experience with JavaScript, 6 years experience with TypeScript. I am currently writing a Node based OS in TypeScript to solve for decentralization (not Web3): https://github.com/prettydiff/share-file-systems
I understand performance aggressively enough far beyond the comfort of most developers: https://github.com/prettydiff/wisdom/blob/master/performance...
https://github.com/prettydiff/share-file-systems
Some architectural decisions I made:
* Micro-service based
* I am now using WebSockets for all services and communication. That has proven in the application to be 7x faster than HTTP.
* I have a universal format wrapping all service messaging, kind of like sending a letter in an envelope. This allows me to using a single service end point for all services and a single means of service monitoring.
* I did not like the existing test automation solutions based upon CDP, because they are too slow and fragile. Also, they do not provide support for a peer-to-peer experience. So I wrote my own test automation solution for testing in the browser and its much faster and predictable.
* I am using an identity based authentication mechanism to restrict access to known users/devices.
* I just write to the file system instead of using a database for data storage. This allows for much faster application start up times and lowers complexity. The performance difference is insignificant after accounting for that in most cases opening a file is more costly than arbitrarily writing to the file system.
* I figured out how to install certificates using automation in both Windows and Linux which allows me to run the application using encrypted transmission protocols (https/wss) on localhost.
This is almost purely functional but makes no attempt to look like anything other than JavaScript and just about everything is identifiable to profilers and covered by some form of test automation.
https://github.com/prettydiff/share-file-systems
Selling points:
* No frameworks and minimal dependencies
* The GUI loads in the browser with full state restoration in about 260ms in Chrome.
* Full peer to peer file system access
* Original WebSocket service support faster than the popular NPM packages (ws, socket.io)
* Peer-to-peer end-to-end test automation in the browser that is faster and easier than the big browser test automation applications (puppeteer, playwrite)
* I am currently working on a streaming command terminal for the browser for support for for things like vim and irssi. The current experimental terminal only supports basic command input/output
https://github.com/prettydiff/wisdom/blob/master/state_manag...
I use it for an OS GUI here which fully loads in 200ms in Chrome (300ms Edge):
https://github.com/prettydiff/share-file-systems
When simple things, like state management, become complicated they are either over engineered or poorly planned.
You can try out how I do it if your are interested. The application is at:
https://github.com/prettydiff/share-file-systems
The test command is:
share test_browserhttps://github.com/prettydiff/share-file-systems
I am trying to think of where to take it next. Possibly integrate something like VLC for media playback or allowing users to install applications. I don’t really know what users would want from something like this.
https://github.com/prettydiff/share-file-systems
The application concept is difficult to explain so I have started calling it an operating system as the application is getting larger.
I will look at using that as a means to bring my Node based OS to IPhone and then problem solved.
https://github.com/prettydiff/wisdom/blob/master/state_manag...
With that approach I can have full state restoration on a full OS GUI running in the browser that loads in 0.3 seconds with state fully restored:
The hate for large frameworks is warranted by their poor performance and bloat while struggling to achieve simple objectives in the most challenging ways.
* Vanilla JS (TypeScript) with tiny HTML and CSS. No frameworks and no unnecessary abstractions.
* A full OS like GUI
* Solves for decentralization
* Provides a script to toggle between support for Node’s CommonJS and standard ECMA module systems
* Easy state management that works better than anything from a large framework
* Super fast. Written for extreme performance. For example the file system search is faster than file system search from the native OS. Page loads with full state restoration in less than 0.3 seconds.
* Fast build and language compile. The full build task takes less than 3 seconds.
* Original WebSocket implementation for better performance and safety with a smart message queue
* Automated documentation management
* Fast test automation with an original test automation solution. Most of the end to end tests executing in the browser executes in about 6.5 seconds for about 280 assertions.
* The node side of the application is command driven from the terminal with interactive command documentation
Feel free to open a GitHub issue if you have any questions or would like to learn more about how I try to solve any kinds of technical challenges.
That is my application that creates an OS GUI in the browser. Plenty of features with o framework.
* Code size (on the front-end) 2mb unminified.
* Load time in the browser (including state restoration) about 120ms.
* The first version took 15 days to write from scratch.
When people claim there MUST be a framework its clear they have no idea what they are talking about. It is clearly a case of Dunning-Kruger effect where they can compare their experience with frameworks on one hand... and they have nothing to compare it to, because its all they know.
I am passionate about this, because decentralization is the most liberating online experience. Share anything, in any way, to anybody of your choosing without third party restrictions, their privacy violations, and no weaponizing of your data/content for any purpose.
https://en.m.wikipedia.org/wiki/9P_(protocol)
Here is the approach I am taking: https://github.com/prettydiff/share-file-systems
https://github.com/prettydiff/share-file-systems
The application inverts the web.
The application is written in TypeScript/Node but that’s not what’s most important. Most important is an understanding of services and distribution cross OS. My current hurdle is isolating service processing from network handling such that the service become protocol/scheme independent.
I started with the file system then I built a text messaging component and now I am working on video calls. Next I want to work on application distribution such that you can execute applications on your remote devices from the local GUI that the stdin from the callbacks allows for distributed task orchestration that non technical people can arrange.
Solved: File system in the browser plus network distribution - https://github.com/prettydiff/share-file-systems
https://github.com/prettydiff/share-file-systems
No frameworks, dependencies, or other bullshit. The primary content is file system output but there are a bunch of different window types each supporting different content.
Documentation https://github.com/prettydiff/share-file-systems/blob/master...
https://github.com/prettydiff/share-file-systems
I am thinking about adding screen capture/video sharing and file system synchronization
This application has already done wonders for automation across my home network, but it seems there is no interest in the idea.
It seems like synchronization is the next logic step and I could really use feedback and testing from interested users. The application is available at https://github.com/prettydiff/share-file-systems
I would love for syncing to occur upon changes in real time as opposed to timed intervals like a cron job.
40k loc. I wrote an ESLint rule to error on this in both statements and expressions.
I am also working on a networked file system solution. My approach is likely fundamentally different. Instead of a single file system to represent file system artifacts across various devices I am using a single simplified data model as an abstraction for all file systems and pairing that with a new security/identity scheme. The idea is to solving for file asset distribution using point-to-point solutions that don't compromise security or privacy.
https://github.com/prettydiff/share-file-systems
I suspect your approach is likely far more stable as I am still working out the kinks in my models, but I supply a complete GUI in the browser that works the same in all browsers on all modern OSs.
I just proved out the application’s security model yesterday in my test automation. Once I finish the messaging subapp I will bump it to version 0.1 for public beta, but you can play with it now on your home network.
I am working on a Node/browser app that solves for this. The idea is to invert the web, which is inherently public, and you get an experience that’s inherently private. With privacy you can do things that aren’t possible or healthy on the public web.
It works out of the box if both end points are IPv6 but IPv4 will require some additional service support to work outside of private networks, due to NAT.
The application is currently just a file sharing tool but soon it will have a text message component. It’s about to achieve fully distributed test automation in the browser, which is a necessary maintenance tool to test the application using user events and DOM navigation across multiple computers for distributed end-to-end tests. If I modify the architecture of the application to support loading and unloading of external components then the application becomes a micro operating system, but this requires many security considerations I have not explored.
https://github.com/prettydiff/share-file-systems
Please keep in mind this application is highly experimental.
* Code: https://github.com/prettydiff/share-file-systems
* Demo: http://mailmarkup.org/sharefile/demo1.mp4
The video demo is a few months old now, but in the current code I have broken network sharing during a refactor. The GUI and local file system still work well though.
My recommendation for learning this language is to forget all the books and helpful guides. Just build something. Here is a good reference of the standard methods: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Refe...
Of that reference list the most immediately important areas are: Array and String.
My personal recommendation for really embracing this language are to learn and master scope in the language. Don't mess around with class, prototypes, inheritance, new, or this until after you have built at least one tool in the language. Most people coming into this language jump in expecting to program in the style of some former language only to be disappointed that JavaScript is not in fact their former language.
My second personal recommendation is to gain confidence around the expressiveness of functions in this language. Functions are first-class objects, which means they can be used anywhere a primitive type can be used. https://developer.mozilla.org/en-US/docs/Glossary/First-clas...
Perhaps the most important thing to learn for any language is data structures. If you have a solid understanding of data structures you can bend any algorithm to your will.
You mention not learning any APIs, but there are two exceptions you should make in order to better understand the language.
* DOM - If you are learning JavaScript in the browser I recommend learning the DOM. I mean the standard imperative DOM methods from the DOM specification. The DOM is a tree model of nodes where each node knows its place in the tree relative to its peers. By appreciating the nature of those fluid relationships you can do incredible things with little effort that execute incredibly fast. I built a complete GUI in the browser in just over 2 weeks that executes as fast as the OS's GUI because I had an understanding of the DOM. Here is the video demo: http://mailmarkup.org/sharefile/demo1.mp4 and code: https://github.com/prettydiff/share-file-systems
* Nodes fs library - If you are learning JavaScript on the terminal with Node.js I recommend learning Node's fs library methods. The file system is also a tree model comprised of nodes that can be walked very quickly.
After you have built one or more tools in this language you will independently learn to appreciate the conventions in this language that best suit your personal programming styles.
I would love to get some feedback.
Some notes:
* Currently it uses IP addresses for connection, which is less than ideal.
* Currently every device is treated as a separate user.
Road map:
* I am working on a web service that will issue named accounts and digital certificates. The named accounts will identify their current IPv6 address to the account service so users need only to connect to an account which can be any IPv6 address for portability.
* Once accounts are a thing I will need to change several things on the client application. My goal in this step is to separate users from devices so that a single user can connect and manage multiple devices. That extra layer of abstraction will allow options for management, security, and convenience that are not currently available.
* I also want to enable end to end encryption for all users/devices. That is just a simple matter of public key exchange built into the already designed invitation model.
* Then I want to create a text client that supports markdown.