Clendar VS share-file-systems

Client. This app doesn’t have any servers. It’s an open source project so you can verify it: https://github.com/vinhnx/Clendar

Hello and Happy New Year HN! Hope all the bests in 2022. So I've been working on a minimal calendar app , named Clendar (Calendar without an 'a'). I know, it's not a good SEO name, but I will go with it :)

I've been building Clendar on my spare time. At first, it's just a side weekend project so that I can learn new Apple technologies, but, the app came to the point of usability that I think I should publish on the App Store anyway for the world to know and use it. Besides, I have been trying to design the app for minimal and usability in mind. Also, the app is fully open-source, as a way for me to give back to the app developers community.

+ App Store: https://apps.apple.com/app/clendar-a-calendar-app/id1548102041

+ Landing page: https://clendar.info

I'm happy to answer any questions, thanks!

Clendar - Universal calendar app. Written in SwiftUI.

I have been working on a universal Calendar app for Apple platforms, as iOS, iPadOS, watchOS and macOS specifically; named Clendar. [0][1]

My goal is to learn SwiftUI and explore new Apple technologies.

The app is now open source on GitHub as well, it's my way to give back to the community as I was learning it. [3]

Feedback welcome!

---

[1] Download link: https://apps.apple.com/us/app/clendar-a-calendar-app/id15481

[2] Landing page: https://vinhnx.github.io/clendar-site

[3] GitHub: https://github.com/vinhnx/Clendar

If anybody needs a practical launching point to study distributed systems maybe I can help.

I have a browser/Node.js application that I worked on for several years that is a browser based peer-to-peer file system sharing tool. The application is massive in size, but its easy to tinker with, the build takes about 8 seconds, and the test automation is decent enough for anybody interested to get started. The idea is to invert the transmission model of the web from anonymous connections towards a server instead to trusted connections between owned computers and even restricted connections to different users (and their various devices) all in real time using sockets and streams and a tiered distribution model. https://github.com/prettydiff/share-file-systems

I am currently working on a web server application that allows spinning up many different web servers quickly and a monitoring dashboard that shows the various servers, their connected sockets, port management, and various other things. This all started with the idea that you can proxy and redirect anything super efficiently where a proxy in Node.js is as simple as:

    proxy.pipe(socket);socket.pipe(proxy);

Try look at my prior personal project: https://github.com/prettydiff/share-file-systems

Imagine loading a large dynamically populated page in the browser with state restoration fully executed as faster than 80ms. I describe that in great detail here: https://github.com/prettydiff/wisdom

I built an original test automation engine for that application because I needed something that supported command and control across multiple computers in the browser for a peer-to-peer environment. On just a single computer it achieved 300 points of evaluation in less that 8 seconds with full file system execution from the browser.

The application also demonstrated an OS-like GUI in the browser that achieved accessibility with full file system display.

Here are the key insights I employed:

* Less is more. Focus on architecture with an obsession on simplicity and reuse even if greatly inconvenient. That often required an irrationally high level of refactoring.

* Speed is an understanding of tree models and transmission and nothing more. Always navigate tree models where they are available, such as the file system and the DOM, in preference to string parsing. String parsing, in any form, is a performance killer. Binary payloads and bidirectional communication are vastly superior to HTTP in every conceivable scenario.

* Other UI developers are cowardly. Don’t let that limit your ambition. Don’t listen to a bunch of bullshit cliches. Measure things and execute according to evidence. Reinvent absolute everything you see fit, and yes it will make other UI developers cry. Real world users don’t care about the sad tears of your peers.

Some things I learned about trusted localhost HTTPS:

* Windows is the easiest... by far. There is only one trust store and its extremely easy to access at different levels of trust. Firefox has its own trust store so you can either add your certs to both the Windows store AND the Firefox trust store or flip a config in Firefox to tell it to use the Windows trust store like everyone else.

* Linux is a challenge because you have to add your certificates to the OS trust store and then each browser has their own trust stores.

* MacOS is pretty close to impossible, at least fully automated. If the cert is not registered with a third party of the OS's choosing the cert will not be trusted in the browser. The way around this is to manually add your localhost cert chain to the MacOS keychain.

If anybody wants an example here is something I wrote a ways back in JS (but please be warned its specific to my application:

* Build the certificate chain - https://github.com/prettydiff/share-file-systems/blob/master...

* Install the cert by OS type - https://github.com/prettydiff/share-file-systems/blob/master...

That second sample also installs pcap so that I can serve on localhost over ports 80/443.

Some developers believe everything is always a framework or any attempt to avoid frameworks creates a new framework. I cannot help these people. Any non-religion is a cult type nonsense of affirming the consequent fallacy.

Otherwise a valid example is this one file that creates a complete OS-like GUI in the browser awaiting content typically populated from WebSocket messaging: https://github.com/prettydiff/share-file-systems/blob/master...

I wrote a similar concept around private internet access to your file system. It’s at https://github.com/prettydiff/share-file-systems

The window and state management can be demoed on my personal site at https://prettydiff.com

File sharing and soon remote execution over the internet cross OS. Private and no servers.

https://github.com/prettydiff/share-file-systems

Done: https://github.com/prettydiff/share-file-systems/blob/master...

You would need a warrant to extract the messages/identity directly from a person's computer as there is nothing otherwise to obtain.

Perhaps this is true in the context of the web. But I got tired of watching the web as a platform continuously repeat the same mistakes so I started working on something different. In the last day or two I was finally able to functionally prove my competing idea in a way that forcefully imposes privacy with complete Zero Trust conformance.

https://github.com/prettydiff/share-file-systems/blob/master...

I am performing a similar file system tree navigation asynchronously in Node.js which is just a shallow API over the C Linux FS APIs.

I can see you are using opendir and closedir functions? What is the benefit from using the opendir function[1] when readdir[2] can be called on a location directly? Is the benefit that opendir returns a file descriptor for use in opening a stream to gather directory object descriptors?

[1] https://man7.org/linux/man-pages/man3/opendir.3.html

[2] https://man7.org/linux/man-pages/man3/readdir.3.html

Your project is probably more mature but if you want an alternate approach to examine here is I have been doing it: https://github.com/prettydiff/share-file-systems/blob/master...

I considering changing my use of readdir to use the withFileTypes option so that it returns a list of directory entries (objects of artifact name and type) instead of a list of conditions to discern types like I am doing on lines 382-432.