1. 1

    I’ve just started work on refactoring the frontend to my registrar API. I remember running into issues with SvelteKit a couple months ago but I conveniently realized I needed to do a refactor to my registry API.

    It’s fun to figure out the most optimal way of creating something technical and useful but I thoroughly enjoy scratching that design itch.

    1. 5

      Finally putting the new version of the frontend at work that I’ve been working on for about 3 months into production! It’s an exciting and also scary week, everything seems to work fine in staging but fingers crossed.

      1. 1

        Whew, good luck!

      1. 0

        I am most pleased with today’s announcements. Can’t wait to get my hands on the 16” M1 Max. I was looking to configure it with 64GB memory but that pushed my ship date to late November. I’ll make do with the (ridiculously powerful) 32GB base config.

        This laptop should last for quite some time.

        1. 8

          Anyone who’s worked at AWS knows everything is constantly on fire, but they do manage to keep blast radius small enough and overwork their on-calls enough that the chaos is rarely visible to customers.

          1. 1

            How the heck is this viable to them?

            1. 4

              It’s what AWS users pay Amazon for, right? Hardware fails, software has bugs, things will catch fire (figuratively or literally). We pay AWS so that Amazon’s workers take care of all that and we don’t have to think about it too much.

              1. 1

                It’s just fascinating to me that such a process hasn’t been streamlined at this point, I guess.

                1. 4

                  Amazon’s whole thing is basically to shave the margins down to nothing and grease the wheels with human misery. It’s working as designed as far as I can tell.

                  1. 2

                    There’s some truth there but this statement also misses the forest for the trees.

                  2. 1

                    What is streamlined?

                    1. 1

                      Not have things on fire all the time?

                      1. 2

                        I don’t think you can “streamline away” disk failures, RAM failures, power supply failures, datacenter cooling system failures, Internet connection failures, and all the other kinds of messy failures which occur when working with vast amounts of physical hardware. And they’re not in control of the software they run for the most part; companies like Netflix can design intelligent systems where a whole bunch of nodes can fail at the same time and other nodes seamlessly take over for the failed nodes, and some workers can take their time to fix the failed nodes whenever it’s most convenient. But that requires fancy distributed software, and one of the core abstractions Amazon provides is that of one highly reliable Linux computer with a fixed, large hard drive and a fixed IP address which never shuts down, and that seriously limits what you can do to engineer your way around downtime caused by hardware failures.

                        I’m not an expert in this by any means, it would be interesting to hear more specific details from someone who has done operations work for a cloud provider. But it doesn’t seem that difficult to me to imagine why what AWS is doing is a hard problem to do cleanly.

            1. 1

              Wow. At first glance this thing crushes the ~$30 Teensies I’ve been using for my home brew phone project. Amazing.

              1. 2

                I’m not sure how it “crushes” a $20 Teensy 4.0 with five times the clock speed, dual issue full Thumb2, FPU, four times the RAM, …

                Cheaper, yes. Better documentation, yes. Better capability – not even close.

                1. 1

                  Ooh, what’s this phone project?

                  1. 2

                    I wrote up a few updates on this project if you’re still interested in reading about it: http://zacstewart.com/2019/06/17/im-making-a-phone.html

                    1. 1

                      Thanks!

                1. 5

                  I was plotting out a small hard sci-fi novella, but realized early on that the setting and plot would lend itself really well to a 2D platformer. So now I’m learning Godot.

                  1. 1

                    I’m intrigued af.

                  1. 5

                    Last week I received another thank you email from Facebook for a position. It took me 1 week to get over. This week I focus on creating new plan how to get a job in FAANG again (:cry)

                    1. 2

                      I believe in you

                    1. 1

                      My new MacBook Air showed up late yesterday so I’m gonna be setting it up to my liking and cursing myself for not keeping my dotfiles up to date.

                      I’ll also be doing some $WORK when I have time. Teams got behind and we’re working up to a deadline. Not gonna stress myself though, it’s not life critical.

                      Sunday I may attempt getting Acid Pro 7 running on this laptop so I can finally free old songs from their ancient jail.

                      1. 2

                        The default styling for Firefox is not my taste so I use a Firefox Safari theme (find it on Github). Lately, I’ve been using The Browser Company’s beta browser and I’m loving it thus far (about a month or two in).

                        I still use FF for web development but for me, it’s days are numbered.

                        1. 3

                          Svelte and Tauri, some of my favorite projects on the front page of Lobsters? Nice.

                          I’ve built node-webkit, nwjs, and Electron apps. Tauri is best in class.

                          1. 3

                            I love Svelte. I always bring out this comparison between create-react-app and svelte’s sveltejs/template:

                            After a fresh app from create-react-app:

                            $ npm install
                            npm WARN deprecated babel-eslint@10.1.0: babel-eslint is now @babel/eslint-parser. This package will no longer receive updates.
                            npm WARN deprecated chokidar@2.1.8: Chokidar 2 will break on node v14+. Upgrade to chokidar 3 with 15x less dependencies.
                            npm WARN deprecated querystring@0.2.1: The querystring API is considered Legacy. new code should use the URLSearchParams API instead.
                            npm WARN deprecated fsevents@1.2.13: fsevents 1 will break on node v14+ and could be using insecure binaries. Upgrade to fsevents 2.
                            npm WARN deprecated querystring@0.2.0: The querystring API is considered Legacy. new code should use the URLSearchParams API instead.
                            npm WARN deprecated uuid@3.4.0: Please upgrade  to version 7 or higher.  Older versions may use Math.random() in certain circumstances, which is known to be problematic.  See https://v8.dev/blog/math-random for details.
                            npm WARN deprecated @hapi/joi@15.1.1: Switch to 'npm install joi'
                            npm WARN deprecated rollup-plugin-babel@4.4.0: This package has been deprecated and is no longer maintained. Please use @rollup/plugin-babel.
                            npm WARN deprecated sane@4.1.0: some dependency vulnerabilities fixed, support for node < 10 dropped, and newer ECMAScript syntax/features added
                            npm WARN deprecated urix@0.1.0: Please see https://github.com/lydell/urix#deprecated
                            npm WARN deprecated @hapi/bourne@1.3.2: This version has been deprecated and is no longer supported or maintained
                            npm WARN deprecated @hapi/address@2.1.4: Moved to 'npm install @sideway/address'
                            npm WARN deprecated @hapi/hoek@8.5.1: This version has been deprecated and is no longer supported or maintained
                            npm WARN deprecated @hapi/topo@3.1.6: This version has been deprecated and is no longer supported or maintained
                            npm WARN deprecated resolve-url@0.2.1: https://github.com/lydell/resolve-url#deprecated
                            npm WARN deprecated core-js@2.6.12: core-js@<3.3 is no longer maintained and not recommended for usage due to the number of issues. Because of the V8 engine whims, feature detection in old core-js versions could cause a slowdown up to 100x even if nothing is polyfilled. Please, upgrade your dependencies to the actual version of core-js.
                            
                            [...]
                            
                            added 1810 packages from 736 contributors and audited 1813 packages in 68.426s
                            
                            145 packages are looking for funding
                              run `npm fund` for details
                            
                            found 3 moderate severity vulnerabilities
                              run `npm audit fix` to fix them, or `npm audit` for details
                            
                            $ du -h node_modules/ | tail -n 1
                            229M	node_modules/
                            

                            After a fresh app from the Svelte template:

                            $ npm install
                            added 96 packages from 126 contributors and audited 97 packages in 2.922s
                            
                            6 packages are looking for funding
                              run `npm fund` for details
                            
                            found 0 vulnerabilities
                            
                            $ du -h node_modules/ | tail -n 1
                            21M	node_modules/
                            

                            One of those seems like a fairly neat system which I can understand, keep up to date with software updates, and take responsibility for as the dependencies for my application. The other seems completely unmanagable to me. I know that React isn’t just adding dependencies for the hell of it, I know it probably has a lot more features than Svelte. But… I say “probably” because I honestly haven’t ran into any features I miss yet, Svelte seems completely up to the task of building the kinds of web apps I need it to. And the development experience is really nice, with .vue files, automatic recompilation, a really fast compiler, live reloading, …

                            1. 2

                              With Svelte you can’t go wrong. Aside from complexity and whatnot of React, one of the things that irritates me the most is all. The damn. <div>s!

                              “Hey bro I heard you liked <div>s so we’re gonna put <div>s inside your <div>s!”

                              With Svelte I can write semantic HTML and ensure the output is that way too.

                              1. 3

                                You can write semantic HTML in React too though, I don’t understand this complaint. The reason why React devs only use divs so much is simply that they don’t bother learning/using semantic HTML.

                                1. 1

                                  Last I checked (which admittedly hasn’t been in a while), it was an uphill battle to get my React app to get started in an element that was not <div>.

                                  1. 3

                                    I don’t remember having any issues getting React to mount on an element that is not <div> or mount a tree that doesn’t start with a <div>. It used to give a warning (it still might, I haven’t checked) if you tried to mount the app directly on <body> because external libraries often append and delete elements from <body>, which might cause a conflict with React if the whole tree is rerendered, but other than that you can use whatever element you want as root/mount point.

                                    1. 1

                                      This has never been a problem as far as I know (been using it since version 0.8), save for the warning about <body> elements that @steinull mentions.

                                2. 1

                                  As a React user I took one look at create-react-app and decided never to touch it (for exactly the reason you highlighted). React isn’t create-react-app though. React itself is very small and you really really don’t need create-react-app.

                                  1. 1

                                    Oh wow, that’s news to me!

                                3. 1

                                  How well do they work on other *NIX platforms? I’m always a bit nervous of things that are based on web technologies for GUI apps because they seem to abruptly break as soon as the deployment platform is anything other than Linux/Windows/macOS (in a large part because Google refuses to accept Chromium patches for any minority OS unless it’s one that they own). One of the ones that was featured on Lobste.rs a while ago had a GTK WebView-based UI. The code for it was portable to any GTK/POSIX platform (no Linux-specific stuff), but was guarded by #ifdef __linux__.

                                  1. 1

                                    I honestly don’t know but their Discord is super helpful and responsive.

                                1. 3

                                  Getting ready to launch our puzzle adventure vr game tomorrow (july 27th) on all major vr stores! Weeehooo!

                                  I’ve coded gameplay, shaders, design tooling, optimizations, porting, and some other stuff. Hard to believe we’ve finally made it after a little more than 3 years!

                                  Announcement link: https://twitter.com/BitCakeStudio/status/1413233930858209280

                                  1. 1

                                    Congrats on launching!

                                    1. 1

                                      Thanks!! It surely feels good :’)

                                    2. 1

                                      Looks beautiful, great work - How big was the team?

                                      1. 1

                                        Thank you! The team was around 10 people and about 12 during peak development.

                                    1. 2

                                      I kind of envy all the geezers here. Y’all have seen life before the Internet. Going from reading cyberpunk novels to actual living in aspects of imagined futures sounds dope.

                                      It’s why I follow Gibson on Twitter today. Lil’ snippets of ye olde (cyber) days fascinated me.

                                      1. 1

                                        I used to read a ton of “cyberpunk” authors from the well-known Gibson and Stirling to the less well remembered Shirley and Kadrey, and there’s very few of their worlds I’d like to live in.

                                        1. 2

                                          Haha, fair enough.

                                      1. 2

                                        OS Dev seems to have such a huge barrier to entry (obviously? I’ve been through the OS Dev wiki a few times and it hasn’t stuck).

                                        Much respect to anyone that gets something even slightly off the ground for themselves.

                                        1. 13

                                          I didn’t do it all by myself! Much, much credit goes to https://github.com/repnop/, who I talked with nearly daily on the Unofficial Rust Discord server and who helped me figure out several bugs and taught me a ton of general background info about RISC-V. This is also my third or fourth serious attempt to write an OS of some kind or another, and I’ve gotten a little further each time. Plus the Rust crate ecosystem makes life a lot easier as well, since there’s a surprising number of low-level crates such as fdt and goblin for doing things like parsing data structures you’re going to need to parse anyway. And as I say way at the bottom of the readme, targeting RISC-V and the qemu virt machine architecture is also kinda easy mode since it’s quite minimalist but is also close enough to real machines to be satisfying. x86 would involve a lot more tedious “get everything perfect or the machine triple faults”, and ARM would drive me slightly crazy trying to understand what combination of instruction set + extensions + peripherals + whatever else I should be using today and finding the correct docs for all of them.

                                          You just find a good collection of giants and start a-climbing.

                                          1. 2

                                            find a good collection of giants and start a-climbing.

                                            I love this, thanks.

                                        1. 15

                                          That guy was picking a whole lot of fights in those PRs.

                                          Also turns out he got banned from lobsters for trying to pick more dights:

                                          8 months ago by pushcx: Repeatedly trying to use Lobsters to whip up an online outrage mob against organizations they don’t care for.

                                          1. 1

                                            Talk about persistent…like tracking.

                                          1. 3

                                            Happy Birthday!

                                            1. 3

                                              I’m not what you’d call a Mac fan - I haven’t been a regular Mac user since ~ 2007 (Xeon based Mac Pro, and boy, was that a machine). But I still do use them from time to time (i.e. when clients issue them to me). So I’ve noticed some of the UX consequences of unification between macOS and iOS. And TBH they haven’t impressed me one jot.

                                              Take one small example: the Bluetooth menu. Used to be that I could just click anywhere in the enabled line to toggle Bluetooth. Now I have to mouse (well, trackpad, since we’re verbing things) over to precisely where the little slider-toggle is, and click that. This is a meaningful regression in usability, apparently solely so that the UI looks and feels more like iOS.

                                              I’d love to know what the driving factors are here. Because it feels like usability is being chucked under the bus for something. But it’s not clear to me what that might be.

                                              1. 3

                                                My more designer-y friends (and Marco Arment) angrily blame Alan Dye for many seemingly nonsense and objectively terrible UI/UX decisions.

                                                Seems like a senior designer is trying to make a name for themselves. It’s the only reason that makes sense to me.

                                                1. 13

                                                  I know this marks me as a grumpy old man, but I miss the days of the Palm, Microsoft and Apple UX guidelines - for the most part, based on empirical user research and user-centric design.

                                                  Some days it seems like the majority of UX research these days is to manipulate users, not empower them - A/B testing of dark patterns in conversion flows, for example.

                                                  Maybe that’s me just being grumpy and old though ;) Or perhaps it’s a reflection of the fact that so often nowadays the user isn’t the customer.

                                                  1. 7

                                                    I get that people coming at user interfaces from a computer science perspective want to remove subjectivity from design decisions through science. But there are a few problems with empirical user research as the basis for design guidelines:

                                                    1. The research does not meet scientific standards. Take a look at the work Nielsen Norman did in their heyday of the early 2000s. Heat maps, A/B tests: they all looked impressive and science-y, but they had incredibly small sample sizes and drew conclusions about things like ideal layouts that the data did not justify.
                                                    2. The research is often divorced from context. People expect user interfaces to look and behave a certain way based on their prior experiences with technology. As technology changes, so do their expectations. Think, for example, about the proliferation of viewport sizes. Remember when almost everyone was using either a 800x600 or 1024x768 screen?
                                                    3. You can’t empirically research your way into good typography or harmonious color palettes, either. Certainly, science can help us compare the legibility of fonts (which also have mutable, albeit slower moving expectations) or identify accessibility issues. But it can’t tell us how to set up the best grid for the information we’re trying to convey or what color palette best fits a brand.

                                                    There will always be a subjective element to user interface design. It can be exhausting to keep up with design fashion. But every once in a while, there are designers who create simple but lasting designs that inspire multiple generations. The Vignellis covered this at length in their canon. User interface design needs such designers now, but they need to deeply understand the fluid nature of user interfaces running on a variety of touch and on-touch devices and driven by dynamic data. Much of today’s graphic design is still stuck in a print mindset.

                                                    1. 1

                                                      I’ll join you in feeling grumpy about that.

                                                  2. 2

                                                    I think the design changes were to make iOS apps look less awful on macOS.

                                                    For some reason, Apple is desperate to bring iOS apps to Mac. They’ve tried Catalyst, which was a failure, mostly because iOS design language was too different from macOS’s. Apparently Apple thought it was worth to throw away the very refined Aqua for a thin iOS-like macOS skin just to “fix” this mismatch.

                                                    Apple also brought iOS apps directly to M1 Macs. They’re still alien with bad UX, and the implementation is half-assed. And now Macs and iPads run the same hardware and bootloader.

                                                    I suspect the current unpolished macOS design exists only because all of it is just a half-way step towards… I don’t know what. I hope they do :)

                                                    1. 1

                                                      For some reason, Apple is desperate to bring iOS apps to Mac.

                                                      The number of iOS apps dwarfs the number of Mac apps. Convergence means instant and ongoing access to a ton of apps, and makes it more likely for people to buy a Mac. I think it’s pretty obvious that eventually iOS, iPadOS, and macOS will be unified into appleOS and run across all devices.

                                                      As long as I can still get a shell prompt, I won’t really care…

                                                      1. 3

                                                        Unfortunately I disagree, they’re pretty obviously trying to merge as much as the “backend” of the OS as possible, but I don’t think they will merge the frontends entirely for the forseable future.

                                                        Exploiting their monopoly on the app store makes them too much money to bring the macOS frontend features to iOS/iPadOS.

                                                        Limiting the MacOS frontend to the app store would be disastrous for developer market share.

                                                        Making app store exclusivity be the only difference would be begging for anti trust law to stop them from making money on the app store.

                                                        As a result they “need” to keep them separate for the foreseeable future, until something happens to upset the status quo. For example Epic winning big in their anti trust case, or some government regulator stepping up and doing the same.

                                                        1. 3

                                                          iPadOS was split from iOS quite recently and is diverging, so I’m not convinced.

                                                          1. 1

                                                            Only in terms of marketing. iPadOS and iOS are the same codebase with different features enabled/disabled. I think Apple would love it if macOS were the same way.

                                                    1. 14

                                                      An interesting counter-example: batch compilers rarely evolve to IDEs and are typically re-written. Examples:

                                                      • Roslyn was a re-write of the original C# compiler
                                                      • visual studio I think uses different compilers for building/intellisense for C++
                                                      • Dart used to have separate compilers for Dart analyzer and Dart runtime
                                                      • Rust is in a similar situation with rustc&rust-analyzer

                                                      Counter examples:

                                                      • clangd (c++) and Merlin (ocaml) are evolutions of batch compilers. My hypothesis is that for languages with forward declarations & header files you actually can more or less re-use batch compiler.

                                                      Non-counter examples:

                                                      • Kotlin and TypeScipt started IDE-first.

                                                      If I try to generalize from this observation, I get the following. Large systems are organized according to a particular “core architecture” — an informal notion about the data that the system deals with, and specific flows and transformation of the data. This core architecture is reified by a big pile of code which gets written over a long time.

                                                      You may find that the code works bad (bugs, adding a feature takes ages, some things seem impossible to do, etc) for two different reasons:

                                                      • either the code is just bad
                                                      • or the core architecture is wrong

                                                      The first case is usually amenable to incremental refactoring (triage issues, add tests, loop { de-abstract, tease-apart, deduplicate }). The second case I think often necessitates a rewrite. The rewrite ideally should be able to re-use components between to systems, but, sadly, the nature of core architecture is that its assumptions permeate all components.

                                                      For compiler, you typically start with “static world, compilation unit-at-a-time, dependencies are pre-compiled, output is a single artifact, primary metric is throughput” (zig is different a bit I believe ;) ), but for ide you want “dynamic, changing world, all CUs together, deps are analyzed on-demand, bits of output are queried on demand, primary metric is latency”.

                                                      It does seem that “bad code” is a much more common for grief than “ill-fit core architecture” though.

                                                      1. 4

                                                        As I heard it, Clang started out because Apple’s Xcode team had reached the limits of being able to use GCC in an IDE, and they wanted a new C/C++ compiler that was more amenable to their needs. (They couldn’t have brought any of GCC’s code into the Xcode process because of GPL contagion.) So while Clang may run as a process, the code behind it (all that LLVM stuff) can be used in-process by an IDE for interactive use.

                                                        1. 2

                                                          What do you mean by “GPL contagion”?

                                                          1. 1

                                                            The GPL is a viral license.

                                                            1. 1

                                                              Oh wow, yikes. Thanks.

                                                            2. 1

                                                              That if they had linked or loaded any part of GCC into Xcode, the license would have infected their own code and they would have had to release Xcode under the GPL.

                                                            3. 2

                                                              It’s interesting that the clang tooling has evolved in a direction that would avoid these problems even if clang were GPL’d. The libclang interfaces are linked directly to clang’s AST and so when you link against libclang you pull in a load of clang and LLVM libraries and must comply with their license. In contrast, clangd is a separate process and talks via a well-documented interface to the IDE and so even if it were AGPLv3, it would have no impact on the license of XCode.

                                                            4. 3

                                                              Thanks for the counter examples, those are really interesting!

                                                              I’ve been able to make changes to the core architecture of my engine incrementally on a few occasions. Some examples:

                                                              • I started out with a 2D renderer, but replaced it with a 3D renderer
                                                                • (adding a dimensions sounds easy in theory, but the way 3d renderers are deisgned is very different from how 2d renderers are designed! lots of data structures had to change and tradeoffs had to be adjusted.)
                                                              • I started out with hard coded character motion, but transitioned to a physics engine
                                                              • I started out with a flat entity hierarchy, and transitioned to an tree structure
                                                              • I started out with bespoke entities, and transitioned to an entity system

                                                              These were definitely challenging transitions to make as my existing code base had a lot of hidden assumptions about things working the way they originally did, so to make it easier I broke the transitions into steps. I’m not sure I was 100% disciplined about this every time, but this was roughly my approach:

                                                              1. Consider what I would have originally built if I was planning on eventually making this transition
                                                              2. Transition my current implementation to that
                                                              3. Make the smallest transition possible from that to something that just barely starts to satisfy the constraints of the new architecture I’m trying to adopt
                                                              4. Actually polish the new thing/get it to the state I want it to be in

                                                              It would be interesting to see retrospectives on projects where people concluded that this approach wasn’t possible or worthwhile and why. There could be more subtitles I’m not currently identifying that differentiate the above transitions from, e.g., what motivated Roslyn.

                                                              1. 2

                                                                This is super interesting, do you know of any materials on how to design an IDE first compiler?

                                                                1. 3

                                                                  The canonical video is https://channel9.msdn.com/Blogs/Seth-Juarez/Anders-Hejlsberg-on-Modern-Compiler-Construction, but, IIRC, it doesn’t actually discuss how you’d do it.

                                                                  This post of mine (and a bunch of links in the end) is probably the best starting point to learn about overall architecture specifics:

                                                                  https://rust-analyzer.github.io/blog/2020/07/20/three-architectures-for-responsive-ide.html

                                                                2. 1

                                                                  Did TypeScript start out “IDE-first”? I remember the tsc batch compiler being introduced at the same time as IDE support.

                                                                1. 6

                                                                  Rewriting Osmosis in Scala. Originally I had planned to write the final version in something like C or Rust. But C is too risky for a network library, and I haven’t written anything serious in Rust before, so that’d be a really steep learning curve.

                                                                  The choice was between Scala and, surprisingly, Dart. Osmosis is a library for data sync between desktop and mobile versions of an app, so it needs to be usable from some kind of cross-platform GUI framework. There are a lot of JS ones, but that won’t work–even though JS is portable, Node isn’t, and Osmosis needs native network and crypto code. Flutter would be nice, but Dart is a really small ecosystem. And then I discovered that JavaFX supports cross-platform desktop and mobile apps, using Gluon. And scala-js exists, so I could still put Osmosis on npm, without needing a separate JS library. So Scala, which I’m already familiar with, seems like the obvious choice.

                                                                  1. 2

                                                                    Great project, now I’m looking for a reason to use it.

                                                                    1. 1

                                                                      I’ve never heard of anyone using a JVM in an iOS app. It seems like it’d be quite large and slow (since iOS doesn’t allow 3rd party JITs.) Or is this an AOT compiler?

                                                                      JS is quite common, though. I’m sure React Native comes with the network and crypto interfaces you need.

                                                                      1. 2

                                                                        Gluon uses GraalVM, which compiles JVM languages to native. It looks like it supports Android and iOS, though it also looks like it’s not very widely used so I don’t know how stable it is. Either way, I’ll also be able to compile Osmosis to a JS library and a native library through Scala.js and Graal respectively, so it should be usable from a variety of platforms, including (hopefully) React Native.

                                                                        I’ve been trying to abstract away all native components (network, crypto, storage) into Scala implicits that are passed into Osmosis classes and functions only when needed, which will help with both portability and testing.

                                                                    1. 2

                                                                      Enjoying the stride I’m in with a personal project, yard work in the backyard, and finding an outfit for myself for a weekend trip I’m taking with the wife next month.

                                                                      She hasn’t had a SINGLE day without kids since March 2020. We’re celebrating.

                                                                      1. 2

                                                                        Has anyone tried Mailspring? https://getmailspring.com/ I haven’t yet, but it looks promising, cross-platform and GPLv3 licensed. It’s Electron, and I’m sure that’s a good reason to hate it, but VS Code is Electron and everyone still uses it.

                                                                        1. 5

                                                                          When it went full FOSS, I gave it a try. My verdict: it looks nice, but it is creepy-as-fuck. By default it tracks when people I send email to open their messages. So when I sent a message that I thought was plaintext only, it included an HTML part like this:

                                                                          --60884697_60ec5af9_3dab
                                                                          Content-Type: text/html; charset="utf-8"
                                                                          Content-Transfer-Encoding: quoted-printable
                                                                          Content-Disposition: inline
                                                                          
                                                                          <div>Testing transport from mailspring to upcoming project list.</div><br><=
                                                                          div>2021-04-27 13<span data-emoji-typing=3D"true">:14</span></div><br><br><=
                                                                          div>Geoff</div><img class=3D"mailspring-open" alt=3D"Sent from Mailspring" =
                                                                          width=3D"0" height=3D"0" style=3D"border:0; width:0; height:0;" src=3D"http=
                                                                          s://link.getmailspring.com/open/EF13F217-CD0A-4423-9425-9746A5ADD158@getmai=
                                                                          lspring.com?me=REDACTED&amp;recipient=REDACTED=
                                                                          REDACTED%3D%3D">
                                                                          --60884697_60ec5af9_3dab--
                                                                          

                                                                          The redacted parts sent my recipient’s base64-encoded email address to mailspring’s server when they opened it.

                                                                          No. Thank. You.

                                                                          I looked briefly at the source but was not confident in my ability to be sure I found and expunged all that creepy shit and did not test it a lot further.

                                                                          1. 1

                                                                            Well that’s disgusting