Adventures in Spartan-land

I am a big proponent of the Spartan Protocol. Now that Lagrange supports it directly, it is a real thing. A whole new unpopulated part of the galaxy to explore and fill with your stuff!

Granted, there is not much there yet!

TLDR: Some opinionated technical babble about the Spartan protocol follows.

Why bother?

Spartan is largely Gemini without TLS. As some of us here think, TLS is a largely unnecessary measure of fake security, which, when combined with self-signed certificates and TOFU (Trust-On-First-Use), is pretty much no security at all. A non-solution to a non-problem. In fact, it may convince non-technical users that there is more privacy and authentication than there really is. I won't bother reiterating pros and cons of TLS, as it is a part of Gemini and provides some protections from someone modifying your gemlog in transit -- if that is your concern...

For retrocomputing or embedded devices, choosing Spartan is a no-brainer. TLS requires some heavyish computation, while Spartan does not.

Spartan is plain text (most likely, unencrypted gemfiles). No client certificates. No server certificates. Built-in unlimited upload capability. And an extra kind of a link designed specifically for input fields!

Spartan's Input Field is much better than Gemini input.

The =: input field is a great thing. If you want input in Gemini, you have to do a jig:

• your gemfile has a link that the server must know about;
• the viewer clicks that link, hitting the url with no data;
• the server returns must a header indicating it wants input;
• the browser recognizes the header and request the user for text;
• the browser sends another request with user's data (same URL as before);
• the size of the data, combined with the length of the url, must not excede 1024 bytes;
• the server processes the input.

As you can see, this is a kluge at best. A royal pain, and not really adequate for many situations, requiring a whole other protocol for uploading data.

Spartan handles it like this:

• your gemfile has a link line (like => but =:);
• when clicked, the browser pops up an input field and gets input;
• the input is sent to the supplied URL
• the server processes the input.

Spartan sure is a lot less effort, and avoids an extra round trip (with no TLS handshakes as a bonus).

Built-in upload

Spartan requests to the server can just send data. No need for a separate protocol, or wierdly, an HTTP site for submitting your gemtexts. You can send and receive data in a single request.

The server will be notified of the exact size of uploaded data, avoiding some ambiguities that Gemini servers have to deal with (when is it safe to close the socket?)

Integration

I am looking forward to adding Spartan to my toolbox. And blabbing about it here. This is not really a competition - now that both Gemini and Spartan are a part of Lagrange - and I hope other browsers will follow - I choose to view these as complementary protocols.