1. 4

    Nothing much! I’m just drinking butter tea and enjoying the cool weather here :^)

    1. 3

      Where does one acquire yak butter…?

      1. 4

        From a yak

        1. 3

          No, you get it from a nak. A yak is male.

          1. 2

            Wait, then shouldn’t it be called nak butter? We don’t call cow milk bull milk

        2. 2

          Unfortunately, I don’t think you can acquire yak butter here in the US :( I just use sometimes-homemade cow-milk butter.

      1. 2

        well, I’m late to the party! Here’s my humble light-themed setup (only screenshot, sorry):

        I use i3wm as my window manager. The editor used is Emacs, obviously. I’m working on a Gemini client, which is what you see in the first workspace. In the second workspace, I have my IRC client, lurch open, which I’ve been working on since about November of last year.

        1. 2

          Ah, glorious. I’d love to see your bar config if possible :)

          1. 1

            Thanks! You can find my polybar configuration right here.

        1. 6

          I’ll be re-entering employed society on the 25th, after being out since Nov 2019 – So, I’m celebrating! And thinking about what I want to do with the next 2 weeks.

          I’m also still messing with colors, and I want to try and re-mount my fat emacs config into a doom emacs config – Many decisions I find myself making after hlissner has already made the thing I want. The thing holding me back was a way to pivot my keyboard layout into doom’s bindings, but the other day I learned someone has done the legwork for another layout!

          1. 2

            Congrats on the new job!

              1. 1

                Wow, you really are excited! :P

                1. 1

                  POGCHAMP

            1. 2

              Finally!

              1. 7

                In many ways, this is similar to the tildeverse: tilde.institute (OpenBSD), tilde.team (Ubuntu), etc. Most of the tildes have IRC (see tilde.chat) and gopher and/or gemini (e.g. cosmic.voyage)

                1. 1

                  Yup; envs.net has WWW, Gopher, and Gemini hosting.

                  Many tildes also run services: most run mail servers, git hosting, fingerd, and pastebins. envs.net runs Pleroma (Mastodon-compatible Fediverse server) and Matrix; Thunix runs a hidden service and a Minetest server.

                  1. 1

                    Litmus test; would https://sr.ht be implementable in Gemini?

                    I am not 100% sure, it’s possible that the TLS client certificate makes it easier to track people. The client would have to support selecting which identity to use for a given website at the minimum.

                    1. 1

                      I don’t think so; Gemini is for transmitting documents, not for creating web applications.

                      1. 1

                        No but that doesn’t necessarily mean it is reliant on the web. A large portion of sr.ht operations can be done from email

                      1. 34

                        There are no inline links (every link goes on its own line), no formatting, and no inline images

                        So it’s borderline useless for all but the simplest use cases, and even there it does a very subpar job. I’d like to have an inline image every now and then, or organize things in some multi-column layouts or the like, or a table. 19th century newspapers could do this, and if your technology can’t emulate typography produced on a daily basis – often in a hurry – 150 years ago then your tech is rather limited.

                        These protocols keep shooting themselves in the head with stuff like this, not even in the foot because this entire thing is dead on arrival for all but a few niche tech folk.

                        1. 17

                          I see this a lot, and I really, really wish that the people making this case would actually try to use Gemini for what it is before bringing their preconceptions into it. Easily a full third of the people I’ve spoken to about Gemini immediately start talking about some $FEATURE that they would add to it - and I’ve heard a lot of different features. Do you see the problem with this? This is just a recipe for re-inventing the bloat of the web.

                          You must first use, then understand, then change the software. You can’t skip steps one and two. It is possible to express yourself within these constraints (you’re already expressing yourself within some fairly arbitrary constraints right now, for instance, imposed by Lobsters’ strict markdown rules), and you should first apply a little bit of creativity to the new medium before you try to bend the medium to your will. We don’t really want it bent, we’re doing something different for a reason.

                          By the way, your comment can be losslessly represented in Gemtext.

                          1. 7

                            Easily a full third of the people I’ve spoken to about Gemini immediately start talking about some $FEATURE that they would add to it - and I’ve heard a lot of different features. Do you see the problem with this? This is just a recipe for re-inventing the bloat of the web.

                            I’d argue that this is because the problems it solves are inherently complex, so any good solution to it will be complex as well. That doesn’t mean I don’t think the web can’t be improved or made simpler – it’s an organically grown mess of 25 years – but it will never be replaced by a dead-simple solution such as Gemini.

                            And yeah, my Lobsters comments can be expressed in Gemini without much loss (except the inline links thing), but Lobsters isn’t my website though and I wouldn’t be able to express my fairly simple website on Gemini, or a fairly simple site as Wikipedia. And even the entire Lobsters website would be a worse UX in Gemini as it precludes any sort of design.

                            1. 1

                              Gemini does not preclude any sort of design, not at all - it just gives the responsibility for design to the client, not to the server.

                              1. 2

                                But isn’t this very limiting? Like, it would work for your blog, but in its current iteration adding a table would already be difficult, never mind something more advanced like the fivethirtyeight election forecast and results.

                                I suppose it all depends what your vision for Gemini is; if you want it to replace large parts of the web then it’s got basically 0 chance in its current state; if you just want some alternative to use yourself and like-minded people, then sure, go for it.

                                1. 1

                                  Of course Gemini doesn’t preclude design: It’s a networking protocol. You can use it to move HTML and JS and CSS and images and whatever else just fine.

                                  Attempting to conflate a protocol with a document format is wrong.

                                  1. 1

                                    The specification also includes a document format, as well as a networking protocol.

                                    Arguably, things would have been clearer if they were separated out more clearly, but this would kind of defeat the point of Gemini. The networking protocol and document format are intended to be used together.

                              2. 6

                                It seems interesting; to make it clear, I do hate tracking too, as well as inaccessibility & various Flash-equivalents of today. And dependency on the complexity tower of Chrome/Firefox/… So I’m certainly curious about alternatives to the current status quo.

                                I do understand that the protocol seems to allow for a lot of expression, and more “slow-food” style, relaxed consumption. Yet, I cannot escape immediately having a feeling of loss. If I understand this correctly, with no mathematical equations support, I would not be able to write or consume an article trying to explain Shor’s algorithm. With no graphs support, I assume whenever I’d want to display graphs, I’d have to resort to ASCII-Art as a workaround, with necessarily limited precision (for example, no smooth curves or complex 3D surfaces). Finally, I assume I would not be able to write or consume an article about typography, or bysantine icons. Or am I wrong?

                                Having the concerns mentioned above, I’m immediately starting to think about possible workarounds. I am assuming people would start resorting to “rich clients” - for example, with support for rendering of some kinds of mathematical equations. This, I am guessing, would quickly lead to on-site recommendations like: “This page requires support for LaTeX-Super-Renderer-3.7”. De-facto becoming in-band signaling of the kind Gemini apparently tries to dispell by “only allowing one field in response, the mimetype”. But wouldn’t people start doing that anyway, and start writing such plugins anyway, and start de-facto reinventing HTML anyway? With the likes of Flash plugins of yore raising from the dead in new clothes?

                                With regards to just graphs and images, I believe it could be somewhat easier actually. I am now reminded of the days of my childhood, when books in my country were mostly in black and white, with a few pages in the center being in color, and being referenced to by the b&w pages (“See illustration 7.b.”). I imagine something like that could work with images being listed, or linked, or attached (?) at the end of a Gemini page. But even then, I don’t think that would be usable for math-heavy documents. And from glancing through the few links around here, it’s not fully clear to me if any images at all, even at the end of a document, are expected to be supported? (Though mimetypes support kinda seems to hint at allowing this?)

                                So, with the ideal of simplicity sounding theoretically interesting and alluring, at the same time I’m concerned about losing access to, especially, maths-related content. (Assuming that some image-heavy, yet comparatively sparse in that regard, content could be possibly approximated with a list of image links at the end, referenced from the main article. Which kinda already sounds like a hack, that would probably soon lead to reintroducing inline images via specialized clients…) That feels like a pity to me.

                                1. 2

                                  I do understand that the protocol seems to allow for a lot of expression, and more “slow-food” style, relaxed consumption. Yet, I cannot escape immediately having a feeling of loss. If I understand this correctly, with no mathematical equations support, I would not be able to write or consume an article trying to explain Shor’s algorithm. With no graphs support, I assume whenever I’d want to display graphs, I’d have to resort to ASCII-Art as a workaround, with necessarily limited precision (for example, no smooth curves or complex 3D surfaces). Finally, I assume I would not be able to write or consume an article about typography, or bysantine icons. Or am I wrong?

                                  I’ve brought this issue about math up in the past, but remember, nothing is stopping you from using HTML or PDF. Gemini uses Gemtext as a lowest-common-denominator form of markup, but if you are writing a client, you can always built in HTML support or shell out to something else that does.

                                2. 5

                                  I think that the reason that people keep trying to suggest features is that Gemini is marketed as a replacement for “the web”, but designed (and only useful) as just a plain text delivery mechanism - there’s (rightly) some cognitive dissonance going on.

                                  That is, “the web” includes plain text, hypertext, rich documents, audio/video media, and interactive content. I don’t think that most people expect Gemini to implement the last two, but there’s some reasonable expectation that something trying to replace “the web” should at least be able to represent reasonably interesting documents - such as scientific papers, which Gemini clearly cannot.

                                  Perhaps if proponents of Gemini stopped trying to claim that it could actually replace anything but the tiniest slice of the web that is pure, plain text (not hypertext, as inline links are really important), you would stop getting people talking about adding features.

                                  Edit: that is, there’s no “preconception” going on here. GP post is responding to the argument that Gemini is a viable replacement for the web by pointing out that it is missing critical features for actually acting as a sane replacement, which has no “preconception” - it’s just a statement of fact. You cannot replace the web without inline links, formatting, or inline images, full stop.

                                  1. 1

                                    You cannot replace the web without inline links, formatting, or inline images, full stop.

                                    As a matter of fact, you can. Full stop.

                                    1. 7

                                      …that’s so obviously false that I shouldn’t need counterexamples, but here they are:

                                      https://graphicallinearalgebra.net/2015/04/26/adding-part-1-and-mr-fibonacci/

                                      http://foldr.org/mw/emacs/

                                      http://507movements.com/

                                      https://lobste.rs/

                                      https://www.av8n.com/physics/clifford-intro.htm

                                      None of these sites, or the majority of the thousands of other bookmarks that I have, can be replaced without inline links, formatting, or images.

                                      Linked files do. Not. Cut. It.

                                      Not only are linked (vs. inline) files objectively and meaningfully different (and, therefore, you cannot replace the web with them), but they are inferior from an information-processing standpoint. From both a practical and theoretical level, you cannot replace the web with Gemini as it currently stands. People will not use it, they are not equivalent, and I, personally, will discourage people from using it - it is a cognitive anti-tool, similar to a reverse printing press. Useful for implementors, terrible for anyone who actually wants to read documents and exchange information that will actually help them to learn and reason.

                                      1. 0

                                        I can provide another counter-example: you had 5 links in your comment, none of which were inlined, despite having access to inline links on lobsters.

                                        You can’t place identical content on Gemini as you can on the web. You can reformat your content for the new medium. Nothing transitions between mediums without change.

                                        Gemini replaces a subset of the web, which I stated in the opening article and have re-iterated dozens of times.

                                        1. 4

                                          I can provide another counter-example: you had 5 links in your comment, none of which were inlined, despite having access to inline links on lobsters.

                                          …that’s not a counter-example. I never claimed that you can’t replace any of the content on the internet, which is what that statement would be a counter-example to. Perhaps you should take a logic course. Edit: that was too aggressive, my apologies.

                                          Edit: I claimed that you cannot replace “the web”, which implies replacing the majority of the content at least, and all of the content at most.

                                          You can’t place identical content on Gemini as you can on the web. You can reformat your content for the new medium.

                                          …and, as it should be very clear, that re-formatting process is (1) lossy and (2) causes a significant decrease in readability and information processing - meaning that it is not a replacement. The format of the web is part of the web, therefore you cannot replace the web with Gemini.

                                          Gemini replaces a subset of the web, which I stated in the opening article and have re-iterated dozens of times.

                                          You have tried to claim that Gemini can replace anything but the tiniest trivial slice of the web that is pure, un-hyperlinked plain-text - which, as shown above, is false. The format of the web is part of the web. The content and the medium are entwined.

                                          1. 2

                                            Anything with “less features” is lossy, but that’s not correlated with a “significant decrease in readability”. On the other hand, putting the presentation entirely into the client’s control is a significant win for readability, because the user can configure fonts, contrast, and layout to their preferences and usability needs. The screen reader experience, for instance, is WAY better. Inline links and inline formatting are less accessible to some.

                                            1. 4

                                              Anything with “less features” is lossy

                                              Only true in the most needlessly pedantic sense. You can easily build systems with a small set of carefully-chosen features that still implement the vast majority of the functionality of larger systems that were poorly-built. This…does not describe Gemini. Gemini picked a basis of features that do not allow it to implement more complex functionality or richer documents.

                                              that’s not correlated with a “significant decrease in readability”

                                              Not in general, sure - but in the case of Gemini, it’s pretty clear that there is a significant decrease in readability (and, therefore, cognitive processing ability). Requiring users to click through to a separate document for each image, animation, or individual mathematical equation is extremely unreadable for anything with a reasonable density of those things - while “only” being merely slightly less readable for documents with only a few of those objects.

                                              On the other hand, putting the presentation entirely into the client’s control is a significant win for readability the user can configure fonts, contrast, and layout to their preferences and usability needs

                                              You can already almost entirely control presentation with major browsers for the current web, through userscripts and stylesheets.

                                              Moreover, HTML is actually structured, unlike Gemtext, so I have anchor points and document metadata that I can use to exert more control over my content than with unstructured Gemtext - so your statement is actually untrue.

                                              The screen reader experience, for instance, is WAY better.

                                              Modern web gives you more options to make a good screen reader experience - such as image alt text. Is it really inconsistently used? Sure, but that’s not a technical problem, that’s a social one - a social one that manifests itself in an equally bad way with Gemini, because Gemtext doesn’t have any way to bind accessibility-related metadata to document structure, because there is no document structure.

                                              Inline links and inline formatting are less accessible to some.

                                              Expanding links and controlling inline formatting are very basic features for screen readers.

                                              So, to summarize, modern web gives you a much richer interface for screen readers, as well as a better interface for people who don’t use screen readers (which is the majority).

                                              Gemtext is straight-up less conducive to thought and information transfer.

                                              1. 2

                                                I think “significant decrease in readability” is interpreted a little too literally here.

                                                Many of the documents linked by fouric would be way more inconvenient to read if they were adapted to fit in gemini’s limitations because of how heavily they rely on tables, anchor links to a specific part of the same document, and inline images (especially with how inconsistent most clients available today are at dealing with non-gemtext content types).

                                                I personally am a big fan of how gemtext files only ever result in a single request due to the lack of stylesheets, scripting, and inline resources, and have pushed back on the adoption of HTML and Markdown as alternate document content types because I think that is a valuable part of the protocol. I’m also not delusional: the stance I hold also directly limits the mass appeal of gemini as a technology, because normal people who just want to read these kinds of documents are unlikely to accept what seems like massive inconvenience for technical reasons they don’t fully understand. They’ll just stick to the Web.

                                                I am willing to put up with that inconvenience as a reader and writer of gemtext content because I think the other benefits of gemini are worth it, but I don’t expect anyone who isn’t another disillusioned Web developer to get on board quite as easily.

                                    2. 2

                                      How would metafilter-style writing look, with lots of inline links? Examples appreciated.

                                      1. 7

                                        You just wouldn’t have lots of inline links. You’d have a separate list of references, perhaps. Here are some examples of Gemini posts I have written with lots of links:

                                        https://portal.drewdevault.com/2020/11/01/What-is-Gemini-anyway.gmi

                                        https://portal.drewdevault.com/2020/10/22/Firefox-the-embarassment-of-FOSS.gmi

                                        https://portal.drewdevault.com/2020/10/01/Spamtoberfest.gmi

                                        Let me put it this way: how would inline links work in a newspaper, book, or magazine? The answer is: they wouldn’t, and you just work within those limitations. That doesn’t mean the medium is bad.

                                    3. 6

                                      19th century newspapers could do this, and if your technology can’t emulate typography produced on a daily basis – often in a hurry – 150 years ago then your tech is rather limited.

                                      Not arguing against you, but when it comes to web browsers, then they still haven’t learnt to properly hyphenate text. Another thing we could do 150 years ago. One of the reasons (another being rather poor support for rendering maths, or, in the case of Chromium, complete lack of it) I’m relieved whenever I get to read a PDF generated from LaTeX instead of a webpage.

                                      1. 5

                                        You can manually hyphenate with soft hyphens like you did 150 years ago just fine.

                                        Automating hyphenation is nearly impossible. LaTeX certainly requires some manual help.

                                        1. 2

                                          If I use soft hyphens, then copying He­re are rhi­nos. to terminal results in He re are rhi nos. visually, because it copied the text with the soft hyphens even though everything was on a single line.

                                          LaTeX certainly requires some manual help.

                                          It never required it when I used it. When you enable correct language support, it should just work.

                                          1. 3

                                            That’s because your terminal is 1970s computer technology.

                                            1. 1

                                              No. That’s because I copied text, but received bytes instead.

                                              FWIW it doesn’t happen with hyphenate: auto in CSS, but that’s only supported by Firefox, so it’s irrelevant.

                                            2. 2

                                              150 years ago you couldn’t copy manually-hyphenated text from your newspaper in to your terminal.

                                              1. 2

                                                I thought this analogy was cute for a little bit. But seriously, why is 150 years ago the standard? Are we really that painfully nostalgia-blind that we can’t recognize there’s a medium point between the old and the new?

                                                1. 3

                                                  It isn’t my standard, and frankly I don’t really care what we could / couldn’t do 150 years ago because I don’t believe it matters in the context of what are we doing, trying to do, and can’t do today.

                                          2. 4

                                            Firefox does hyphenation with hyphens: auto; if you set the document language.

                                            1. 1

                                              Does Gemini support setting the document language?

                                              1. 2

                                                A quick search on the specification shows it does. So hyphenation working on gemini or not would be a matter of the client implementing it.

                                            2. 2

                                              Well, 150 years ago it was a manual process, and not an automatic one :-) I regularly insert &shy for this on my website by the way. But yeah, I agree that the lack of a universally supported hyphenate: auto has been long overdue (only Firefox supports it, and it doesn’t even do a great job at it, although I don’t know if there are technical reasons that prevent it from doing a better job; I think I saw someone on HN detail some issues with automatic hyphenation on the web years ago, but I forgot what they were).

                                              Math rendering has also been supported by Firefox for 15 years with MathML, but for some reason Chrome doesn’t (but Safari does). Actually, looks like they removed it in Chrome years ago, although it looks like there’s work to add it back soon-ish.

                                              1. 1

                                                Actually, along with Firefox, some versions of Chrome (Android & Mac) support auto hyphenation, and Safari has it hidden behind a prefix: https://caniuse.com/css-hyphens I feel that together these may cover enough of the market to make it worth adding to web pages.

                                                If you want to see a quick and stupid demo, here’s my very unfinished Hugo theme I’m working on developing: https://www.maximumethics.dev/blog/2020/07/my-first-post/ If you shrink the viewport width until it’s skinny like a phone, you’ll see the longer 90 chars “alphabet” line break to hyphenate (on the aforementioned supported browsers), as well as random words in the text.

                                                1. 2

                                                  Ah yeah, it’s just the desktop version that doesn’t support it for some weird reason; I forgot about that detail.

                                                  I suppose it depends what you use it for: most of the time I really wanted auto hyphenation is for comparatively narrow pieces of text and/or for text-align: justify (e.g. a sidebar or info box). In those cases the hyphenation (manual or automatic) is pretty much a must-have rather than a nice-to-have, because without it it just looks ugly. Your site, on the other hand, looks fairly decent without hyphenation even on smaller screens, but it won’t hurt to add it for browsers that support it.

                                                2. 1

                                                  Math rendering has also been supported by Firefox for 15 years with MathML, but for some reason Chrome doesn’t (but Safari does). Actually, looks like they removed it in Chrome years ago, although it looks like there’s work to add it back soon-ish.

                                                  That’s what I was on about. If something isn’t available in Chrome, it’s irrelevant these days. I’ve been aware that “it looks like there’s work to add it back soon-ish” for quite some time now. I don’t have hope.

                                              2. 5

                                                I think the idea is that the publisher delivers only the information, not the presentation. This constraint allows for greater user control over presentation, for example one might configure Gemini to lay out news articles (maybe on a site by site basis) in a column style, to suit their preferences. I think it’s an interesting idea as a way of making better typesetting more widely available to content published on sites without the budget / know-how to tune their CSS for readability.

                                                I agree that Gemini would be better off if it supported inline images. That’s pretty often part of the information layer.

                                                1. 6

                                                  I think the idea is that the publisher delivers only the information, not the presentation.

                                                  Wait! That is HTML! (as compared to PDF)

                                                  1. 6

                                                    Not really, HTML still focuses a lot on presentation. Headers, side bars, footers, nagivation line, footnotes, etc. are all concepts foreign to the browser, that have to be manually re-implemented in the markup language, again and again. That’s actually what I think that protocols like Gemini misunderstand: HTTP/HTML is not too systamatically complicated (at most it’s “organically” complicated), it’s actually too simple. If for example the <head> section had made it possible to describe how a web-page is navigated, it would have been possible for the browser to render that part of the site, leaving the <body> to be actual content. It’s something you see with other simple languages too: Scheme has various implementations, that implement a common core, but diverge in their additional libraries, that are regarded as useful, but do not allow for code to be portable. So too, had HTTP/HTML has the foresight to recognize what people would want from websites (which is probably too much to ask), or at least the foresight to allow a certain degree of extensibility, a lot of implementation-specific complexity could have probably been avoided.

                                                    So the issue might not be “simplicity vs compexity”, but “what kind of complexity”.

                                                    1. 3

                                                      Years ago I came across a browser extension that would build a navigation bar if it found certain <link> tags in the header. I modified my blogging engine to automatically add said links. Sadly, the extension no longer runs (because of course the extension mechanism changed—at least twice—since then) but I still generate the data in the vain hope it’ll be useful again.

                                                  2. 5

                                                    A strict separation of information and presentation is something that sounds great in theory, but doesn’t really work all that well in practice once you move beyond the simple use cases, or use cases that are pre-defined and supported in some way.

                                                    1. 1

                                                      I don’t know if this was part of the design goal - from what I can see, Gemini doesn’t have any sort of mechanism to describe or annotate what content/information is being delivered, which would make any presentation strategy necessarily heuristic, as there would be no way to delineate e.g. where the “author” of the article is.

                                                      1. 1

                                                        I guess you’d just put that information into the document itself.

                                                        One underappreciated tag in HTML is the <address> tag, which is a nice place to put stuff like author, publication date, etc.

                                                        1. 1

                                                          I’m not quite sure what you mean - when you say “just put that information into the document itself” do you mean in a machine-readable format? Because if so, that’s not part of the Gemini text spec - which is the thing being discussed. Adding tags like <address> would be extending the Gemini spec to add features, which is what proponents of it are fiercely against.

                                                          1. 1

                                                            No, I just meant to add something like

                                                            • Author: Gustaf Erikson
                                                            • Date: 3 Nov 2020

                                                            in the body of the text somewhere.

                                                    2. 4

                                                      As it has been stated on the mailing list, “you can always serve up text/html or text/markdown, you aren’t limited to text/gemini.” There are sites out there serving up images and even music.

                                                      1. 12

                                                        Well, that’s not really what’s advocated for in this post (or on the Gemini website as far as I could see), and serving HTML over Gemini just sounds like a s/HTTP/Gemini/, and you can serve text or Markdown over HTTP as well. I don’t really see the point if you’re going to serve HTML over Gemini.

                                                      2. 4

                                                        I’m just going to drop a link to the FAQ page, in the hopes that it’ll answer some questions here.

                                                        1. 3

                                                          I’m sick of how complex html+css+js gets, and how complicated extracting the actual content can be, in order to view it on “unusual” platforms (small screens. ereaders, etc.), where a good experience depends on the client controlling the presentation of the content. Something like gemini could be the solution to that, but I have to say, the lack of inline images is a deal-breaker for me.

                                                          I view multi-column layouts as part of the presentation, not the content (I don’t want two columns of text on a phone screen: if I do want two columns of text on the desktop, I can write that into the client), but the images are part of the content.

                                                          I did wonder whether technically a gemini-ish client could fetch urls which look like they point to images and display them inline, but this is explicitly banned by the specification:

                                                          Clients can present links to users in whatever fashion the client author wishes, however clients MUST NOT automatically make any network connections as part of displaying links whose scheme corresponds to a network protocol (e.g. gemini://, gopher://, https://, ftp://, etc.).

                                                          I can sort of see what they’re aiming for, presumably trying to avoid the sort of nonsense some websites have become, where the initial request just gets a jumble of html elements that require the client to fetch and execute tons of javascript before they can be assembled into something resembling content, but I think they should have made an exception for images (They could still leave it up to the client whether it displays inline images or not).

                                                          Interestingly, gemini probably works really well with screen readers, until you get to an image link (or any link for that matter), at which point it depends entirely on whether the author bothered to provide a caption, or explain what the link is as part of the text (Although that’s arguably no worse than html, where the existence of alt text doesn’t mean that it is always used or used correctly).

                                                          1. 5

                                                            Another reason to not allow non-user-initiated network connections is that’s abused to track users (Facebook pixel etc).

                                                            IMHO this could be sufficiently solved by allowing additional requests to the same domain as the document request.

                                                            1. 4

                                                              One big reason I’m excited about Gemini is the possibility of escaping the web’s bloat, which we need to do in order to reduce energy usage / emissions in the climate crisis. For this reason, I support Gemini’s decision to ban inline images. If you have inline images, next people will want inline video, and soon even if Gemini is “simpler” it’s using as much storage+bandwidth+processing as a web page.

                                                              Inlining images, especially from other locations, is also a plausible method for sneaking user tracking back into the protocol, and I also approve of Gemini’s strong efforts towards privacy. I also hate ads even when they don’t track people, I’d love to live someplace where billboards are banned so I can escape the constant background hum of marketing. Eliminating inline images is also a great way to reduce the annoyance of advertising.

                                                              I’m going to have to agree with everyone in this thread that refusing to implement inline links was a mistake, though. That was one of the biggest problems I had with Gopher, and I was hoping Gemini would do a better job with hypertext.

                                                              1. 4

                                                                Inlining images, especially from other locations, is also a plausible method for sneaking user tracking back into the protocol, and I also approve of Gemini’s strong efforts towards privacy.

                                                                It’s a very difficult balance to strike between simplicity and functionality. You could probably avoid trackers by, as @m_eiman says, only allowing additional requests from the same domain as the original document.

                                                                Alternatively, you could create/use a format which embeds the images directly in the original document (similar to how pdf or epub does). Some might argue that this is inefficient, as you need to serve multiple copies of the image data if it appears on multiple pages. However, in this context, it could be seen as a feature, as we don’t want the kind of images (such as ads) which aren’t actually “part of the document”.

                                                                There will always be some people who abuse any protocol, but not having inline images is very limiting and means it isn’t any good for a significant portion of (what I consider) “good content that doesn’t need javascript/css”.

                                                            2. 1

                                                              I’d like to have an inline image every now and then

                                                              Might I ask what’s wrong with merely providing a link to the image?

                                                              or a table.

                                                              This can be easily done with some ASCII art (which is what you do for Markdown, anyways) coupled with a preformatted block.

                                                              1. 10

                                                                This can be easily done with some ASCII art…

                                                                But ASCII art is pretty much the quintessence of mixing presentation and content, which is very specifically what Gemini seeks to avoid. It can’t wrap or scroll differently on small devices, it can’t be extracted (easily and reliably) to a machine-readable data format, and it isn’t accessible because there’s no semantic information about the table structure.

                                                                1. 3

                                                                  You’re right. I kinda hope some kind of table syntax does make it into the Gemini spec after all.

                                                                2. 3

                                                                  I need to click a link to an image? It seems pretty obvious to me that this is worse UX than just displaying it.

                                                                  ASCII art relies on a monospaced font, which I don’t really like for reading text. I think Lobsters would be significantly worse if it was all monospaced text for example. It also relies on a certain screen size, which doesn’t work for smaller screens (or very big ones, for that matter). I mean, it kinda works but it’s a hack.

                                                                  1. 2

                                                                    I need to click a link to an image? It seems pretty obvious to me that this is worse UX than just displaying it.

                                                                    Yeah. You’re completely right, this is worse UX. I’m beginning to think of proposing an inline-image syntax for the gemini spec.

                                                                    ASCII art relies on a monospaced font, which I don’t really like for reading text.

                                                                    I admit I was wrong. ASCII tables are a hack, I suppose. Hopefully the simple table syntax I’m thinking of right now makes it into the spec!

                                                                    I think Lobsters would be significantly worse if it was all monospaced text for example. It also relies on a certain screen size, which doesn’t work for smaller screens (or very big ones, for that matter). I mean, it kinda works but it’s a hack.

                                                                    FYI there are gemini clients that support variable-width fonts.

                                                                    1. 4

                                                                      FYI there are gemini clients that support variable-width fonts.

                                                                      I tried to use it with Gopher years ago (I hacked up an existing client), and many sites don’t really work all that well because they assume stuff will be displayed as monospaced text (such as tables you mentioned, but also things like code examples, or other alignment things).

                                                                      Gemini is a bit of an improvement because the spec at least recognizes that proportional text exits and has “code blocks”, but it also leaves much to the clients. In other words: I wouldn’t be surprised if people would just keep using it as they used Gopher, and the weird (and IMO, broken) way line wrapping works in Gemini doesn’t help either. I suppose time will tell how it will be used in practice (but as mentioned, I don’t think it will be used much in practice beyond a few “Hacker blogs” like Drew’s).

                                                                      One of the big mistakes of HTML was, ironically, to “leave it up to the clients” which resulted in a big mess which had to be unified so that people could get a reasonably consistent experience irregardless of which browser they use, but that just unified the mess instead of clearing it up.

                                                                  2. 1

                                                                    I use HTML to add tables to my Markdown content.

                                                                    1. 1

                                                                      I personally find HTML’s table syntax difficult to read and use.

                                                                      1. 4

                                                                        Yep, I usually whip up a quick Perl script with the (deprecated) CGI module to generate it from plain text ;)

                                                                  3. 1

                                                                    Gemini is only a protocol, but the specification also propose a basic text/gemini format as a de-facto document type. It however supports any mimetype, including text/html:

                                                                    5 The text/gemini media type
                                                                    5.1 Overview

                                                                    In the same sense that HTML is the “native” response format of HTTP and plain text is the native response format of gopher, Gemini defines its own native response format - though of course, thanks to the inclusion of a MIME type in the response header Gemini can be used to serve plain text, rich text, HTML, Markdown, LaTeX, etc.

                                                                    You could totally sent the following HTML document over gemini:// and enjoy inline images:

                                                                    <html>
                                                                      <body>
                                                                      <p>My favorite cat picture:</p>
                                                                      <img src="gemini://domain.tld/cat.png" />
                                                                      </body>
                                                                    </html>
                                                                    

                                                                    It would then be up to the gemini client to process this document, fetch required resources (the cat picture) and render it nicely for you. The advantage of the gemini protocol here is that it would put a limit on the HTML subset one could put in a document. For example, <form> tags won’t be any useful. There would also be no need for <script> tags, as they wouldn’t be able to “phone home” over gemini.

                                                                    One of the biggest problem of the web is that the HTTP protocol itself grew in an enormous monster that’s impossible to understand, where sometimes the headers of a requests can be 10 times bigger than the content itself.

                                                                  1. 4

                                                                    I read a lot of text in my browser and I find variable-width fonts easier to read. Anything which wants me to do this reading in a fixed-width-font terminal I’ll ignore.

                                                                    1. 3

                                                                      That’s understandable – I also find variable-width fonts easier on my eyes! There are, however, a bunch of non-terminal clients that can use other fonts, such as Castor.

                                                                      1. 1

                                                                        At least on my machine, Castor hangs when opening a resource outside of Gemini (a [WWW] link, specifically).

                                                                    1. 4

                                                                      Why would one other Gemini over gopher?

                                                                      1. 9

                                                                        There are several advantages. I’m going to quote the FAQ page:

                                                                        • Unambiguous use of arbitrary non-ASCII character sets.
                                                                        • Identifying binary content using MIME types instead of a small set of badly outdated item types.
                                                                        • Clearly distinguishing successful transactions from failed ones.
                                                                        • Linking to non-gopher resources via URLs without ugly hacks.
                                                                        • Redirects to prevent broken links when content moves or is rearranged.
                                                                        • Domain-based virtual hosting.
                                                                        • Text in Gemini documents is wrapped by the client to fit the device’s viewport, rather than being “hard wrapped” at ~80 characters with newline characters. This means content displays equally well on phones, tablets, laptops and desktops.
                                                                        • Gemini does away with Gopher’s strict directory / text dichotomy and lets you insert links in prose.
                                                                        • Gemini mandates the use of TLS encryption.
                                                                        1. 6

                                                                          it really doesn’t offer anything over gopher. pulling in the whole mess of TLS isn’t the right way to ensure document integrity IMO.

                                                                          1. 1

                                                                            By allowing links within content pages instead of separating content from menu pages, Gemini acts as hypertext. You can have that always going forward, losing yourself in Wikipedia kind of experience. You don’t constantly hit dead ends; sites are naturally more interlinked.

                                                                          1. 2

                                                                            I wonder what the rationale for not allowing inline links is.

                                                                            1. 11

                                                                              I’ll just quote the Gemini FAQ page:

                                                                              Because text/gemini is an entirely new format defined from scratch for Gemini, client authors will typically need to write their own code to parse and render the format from scratch, without being able to rely on a pre-existing, well-tested library implementation. Therefore, it is important that the format is extremely simple to handle correctly. The line-based format where text lines and link lines are separate concepts achieves this. There is no need for clients to scan each line character-by-character, testing for the presence of some special link syntax. Even the simplest special link syntax introduces the possibility of malformed syntax which clients would need to be robust against, and has edge cases whose handling would either need to be explicitly addressed in the protocol specification (leading to a longer, more tedious specification which was less fun to read and harder to hold in your head), or left undefined (leading to inconsistent behaviour across different clients). Even though in-line links may be a more natural fit for some kinds of content, they’re just not worth the increased complexity and fragility they would inevitably introduce to the protocol.

                                                                              It’s true that you need to shift your thinking a bit to get used to the one link per line writing style, but it gets easier over time. There are benefits to the style as well. It encourages including only the most important or relevant links, organising links into related lists, and giving each link a maximally descriptive label without having to worry about whether or not that label fits naturally into the flow of your main text.

                                                                              1. 1

                                                                                Thanks for linking to the rationale!

                                                                            1. 1

                                                                              Busy setting up a Gemini “mirror” of https://k1ss.org at https://tilde.team/~kiedtl/k1ss/docs. It’s not a simple job – the KISS Linux website makes liberal use of huge ASCII art, tables, labeled code blocks, etc that must be trimmed off.

                                                                              1. 3

                                                                                Hey! My site, which was originally based on @icy’s excellent page, is here. Web development isn’t my strong point, but I do like to think I my site is at least passable :)

                                                                                1. 1

                                                                                  The content is too narrow: on a desktop browser, I’m having to horizontally scroll to view your code.

                                                                                  1. 1

                                                                                    It looks really nice. I like narrow content, it’s easier for me to read without having to rely on reader view, but it does become a challenge when you have code snippets. Fortunately, your posts are not very code heavy, so I don’t think that’s a problem.

                                                                                  1. 2

                                                                                    Brazilian developers will have a hard time using this tool.

                                                                                    1. 2

                                                                                      Why?

                                                                                      1. 3

                                                                                        I’m not sure this is the reason @tonnydourado made that remark, but “cu” apparently means “ass” in Portuguese.

                                                                                        Oh, and of course, “git” is slang for an unpleasant individual…

                                                                                        1. 2

                                                                                          Yeah, pretty much, it’s the “cu” part.

                                                                                          1. 1

                                                                                            Oh dear 😅

                                                                                            1. 2

                                                                                              Maybe they can apply this just for some clients :)

                                                                                      1. 19

                                                                                        I’m probably not the only one with the opinion that rewrites in Rust may generally a good idea, but Rust’s compile times are unacceptable. I know there are efforts to improve that, but Rust’s compile times are so abysmally slow that it really affects me as a Gentoo user. Another point is that Rust is not standardized and a one-implementation-language, which also discourages me from looking deeper into Haskell and others. I’m not saying that I generally reject single-implementation languages, as this would disregard any new languages, but a language implementation should be possible without too much work (say within two man-months). Neither Haskell nor Rust satisfy this condition and contraptions like Cargo make it even worse, because implementing Rust would also mean to more or less implement the entire Cargo-ecosystem.

                                                                                        Contrary to that, C compiles really fast, is an industry standard and has dozens of implementations. Another thing we should note is that the original C-codebase is a mature one. While Rust’s great ownership and type system may save you from general memory-handling- and type-errors, it won’t save you from intrinsic logic errors. However, I don’t weigh that point that much because this is an argument that could be given against any new codebase.

                                                                                        What really matters to me is the increase in the diversity of git-implementations, which is a really good thing.

                                                                                        1. 22

                                                                                          but a language implementation should be possible without too much work (say within two man-months)

                                                                                          Why is that a requirement? I don’t understand your position, we shouldn’t have complex, interesting or experimental languages only because a person couldn’t write an implementation by himself in 2 months? We should discard all the advances rust and haskell provide because they require a complex compiler?

                                                                                          1. 5

                                                                                            I’m not saying that we should discard those advances, because there is no mutual exclusion. I’m pretty certain one could work up a pure functional programming language based on linear type theory that provides the same benefits and is possible to implement in a reasonable amount of time.

                                                                                            A good comparison is the web: 10-15 years ago, it was possible for a person to implement a basic web browser in a reasonable amount of time. Nowadays, it is impossible to follow all new web standards and you need an army of developers to keep up, which is why more and more groups give up on this endeavour (look at Opera and Microsoft as the most recent examples). We are now in a state where almost 90% of browsers are based on Webkit, which turns the web into a one-implementation-domain. I’m glad Mozilla is holding up there, but who knows for how long?

                                                                                            The thing is the following: If you make the choice of a language as a developer, you “invest” into the ecosystem and if the ecosystem for some reason breaks apart/dies/changes into a direction you don’t agree with, you are forced to put additional work into it.

                                                                                            This additional work can be a lot if you’re talking about proprietary ecosystems, meaning more or less you are forced to rewrite your programs. Rust satisfies the necessary condition of a qualified ecosystem, because it’s open source, but open source systems can also shut you out when the ABI/API isn’t stable, and the danger is especially given with the “loose” crate system that may provide high flexibility, but also means a lot of technical debt when you have to continually push your code to the newest specs to be able to use your dependencies. However, this is again a question of the ecosystem, and I’d prefer to only refer to the Rust compiler here.

                                                                                            Anyway, I think the Rust community needs to address this and work up a standard for the Rust language. On my behalf, I won’t be investing my time into this ecosystem until this is addressed in some way. Anything else is just building a castle on sand.

                                                                                            1. 5

                                                                                              A good comparison is the web: 10-15 years ago, it was possible for a person to implement a basic web browser in a reasonable amount of time. Nowadays, it is impossible to follow all new web standards and you need an army of developers to keep up, which is why more and more groups give up on this endeavour (look at Opera and Microsoft as the most recent examples). We are now in a state where almost 90% of browsers are based on Webkit, which turns the web into a one-implementation-domain. I’m glad Mozilla is holding up there, but who knows for how long?

                                                                                              There is a good argument by Drew DeVault that it is impossible to reimplement a web browser for the modern web

                                                                                              1. 4

                                                                                                I know Blink was forked from webkit but all these years later don’t you think it’s a little reductive to treat them as the same? If I’m not mistaken Blink sends nothing upstream to webkit and by now the codebases are fairly divergent.

                                                                                            2. 8

                                                                                              I feel ya - on OpenBSD compile times are orders of magnitude slower than on Linux! For example ncspot takes ~2 minutes to build on Linux and 37 minutes on OpenBSD (with most features disabled)!!

                                                                                              1. 5

                                                                                                37 minutes on OpenBSD

                                                                                                For reals? This is terrifying.

                                                                                                1. 1

                                                                                                  Excuse my ignorance – mind pointing me to some kind of article/document explaining why this is the case?

                                                                                                  1. 7

                                                                                                    There isn’t one. People (semarie@ - who maintains the rust port on OpenBSD being one) have looked into it with things like the RUSTC_BOOTSTRAP=1 and RUSTFLAGS='-Ztime-passes -Ztime-llvm-passes' env vars. These point to most of the time being spent in LLVM. But no one has tracked down the issue fully AFAIK.

                                                                                                2. 6

                                                                                                  Another point is that Rust is not standardized and a one-implementation-language

                                                                                                  This is something that gives me pause when considering Rust. If the core Rust team does something that makes it impossible for me to continue using Rust (e.g. changes licenses to something incompatible with what I’m using it for), I don’t have anywhere to go and at best am stuck on an older version.

                                                                                                  One of the solutions to the above problem is a fork, but without a standard, the fork and the original can vary and no one is “right” and I lose the ability to write code portable between the two versions.

                                                                                                  Obviously, this isn’t a problem unique to Rust - most languages aren’t standardized and having a plethora of implementations can cause its own problems too - but the fact that there are large parts of Rust that are undefined and unstandardized (the ABI, the aliasing rules, etc) gives me pause from using it in mission-critical stuff.

                                                                                                  (I’m still learning Rust and I’m planning on using it for my next big thing if I get good enough at it in time, though given the time constraints it’s looking like I’ll be using C because my Rust won’t be good enough yet.)

                                                                                                  1. 2

                                                                                                    The fact that the trademark is still owned by the Mozilla foundation and not the to-be-created Rust Foundation is also likely chilling any attempts at independent reimplementation.

                                                                                                  2. 1

                                                                                                    As much as I understand your point about the slowness of compile time in Rust, I think it is a matter of time to see them shrink.

                                                                                                    On the standard point, Haskell have a standard : Haskell 2010 . GHC is the only implementation now but it have a lot of plugins to the compiler that are not in the standard. The new standard Haskell 2020 is on his way. Implementing the standard Haskell (not with all the GHC add-ons) is do-able but the language will way more simple and with flaws.

                                                                                                    1. 2

                                                                                                      The thing is, as you said: You can’t compile a lot of code by implementing Haskell 2010 (or 2020 for that matter) when you also don’t ship the “proprietary” extensions.

                                                                                                      1. 1

                                                                                                        It is the same when you abuse GCC or Clang extensions in your codebase. The main difference with Haskell is that you, almost, only have GHC available and the community put their efforts in it and create a ecosystem of extensions.

                                                                                                        As for C, your could write standard-compliant code that an hypothetical other compiler may compile. I am pretty sure if we only had one main compiler for C for so long that Haskell have had GHC, the situation would have been similar : lots of language extension outside the standard existing solely in the compiler.

                                                                                                        1. 3

                                                                                                          But this is exactly the case: There’s lots and lots of code out there that uses GNU extensions (from gcc). For a very long time, gcc was the only real compiler around and it lead to this problem. Some extensions are so persistent that clang had no other choice but to implement them.

                                                                                                          1. 1

                                                                                                            But does those extensions ever reached the standard? It as asked candidly as I do not know a lot of the evolution of C, compilers and standard that much.

                                                                                                            1. 3

                                                                                                              There’s a list by GNU that lists the extensions. I really hate it that you can’t enable a warning flag (like -Wextensions) that warns you about using GNU extensions.

                                                                                                              Still, it is not as bad as bashism (i.e. extensions in GNU bash over Posix sh), because many scripts declare a /bin/sh-shebang at the top but are full of bashism because they incidentally have bash as the default shell. Most bashisms are just stupid, many people don’t know they are using them and there’s no warning to enable warnings. Another bad offender are GNU extensions of the Posix core utilities, especially GNU make, where 99% of all makefiles are actually GNU only and don’t work with Posix make.

                                                                                                              In general, this is one major reason I dislike GNU: They see themselves as the one and only choice for software (demanding people to call Linux “GNU/Linux”) while introducing tons of extensions to chain their users to their ecosystem.

                                                                                                              1. 2

                                                                                                                Here are some of the GNU C extensions that ended up in the C standard.

                                                                                                                • // comments
                                                                                                                • inline functions
                                                                                                                • Variable length arrays
                                                                                                                • Hex floats
                                                                                                                • Variadic macros
                                                                                                                • alignof
                                                                                                            2. 1

                                                                                                              If I remember correctly 10 years ago hugs was still working and maybe even nhc :)

                                                                                                              1. 1

                                                                                                                Yep :) and yhc never landed after forking nhc. UHC and JHC seem dead. My main point is mainly that the existence of a standard does not assure the the multiplication of implementations and the cross-cIompilation between compilers/interpreters/jit/etc. It is a simplification around it and really depends on the community around those languages. If you look at Common Lisp with a set in the stone standard and a lot of compilers that can pin-point easily what is gonna work or not. Or Scheme with a fairly easy standard but you will quickly run out of the possibility to swap between interpreters if you focus on some specific stuffs.

                                                                                                                After that, everyone have their checklist about what a programming language must or must not provide for them to learn and use.

                                                                                                      1. 1

                                                                                                        This looks like nice work. Can you run down when you might prefer to use this versus fff versus ranger? I feel like most times where I’d want this, I’ve got curses and python, so I’d just use ranger. Which makes me think I’m missing something.

                                                                                                        1. 4

                                                                                                          This is great for smaller environments which may not have bash, ncurses, python, etc. There’s a Linux distribution that will be putting it in their initrd for example. It’s also good for environments where disk space is limited. I also personally no longer use bash so I’ve ported everything I use over to POSIX shell or C.

                                                                                                          Edit: Should also mention that it’s all contained in a single file and there’s no compilation step necessary!

                                                                                                          1. 1

                                                                                                            There’s a Linux distribution that will be putting it in their initrd for example.

                                                                                                            Just curious, which Linux distro would that be? :)

                                                                                                            1. 1

                                                                                                              Including it in initrd hadn’t occurred to me. It seems especially useful for that.

                                                                                                              Does it work well with the ash that busybox ships?

                                                                                                              1. 1

                                                                                                                Yes it does. It should work in all POSIX shells. If not, that’s a bug. :)

                                                                                                            2. 2

                                                                                                              Don’t know if Dylan will agree, but I like to think it’s less about “needing” this, and more about how creative you can get with limited resources—Creative limitation. It’s a really fun exercise in programming. For me, personally, I like trying to (re)write most of my tooling in pure bash—no external programs called whatsoever. And shfm, I feel, was something born out of the idea that fff (pure bash) could possibly be simplified further (POSIX sh).

                                                                                                              1. 3

                                                                                                                The need is deceivingly greater than it might occur to most people. Many systems don’t have much of what the average shell user is used to. NASes, plug computers, microcomputers, or even containers. Buying into tens or even hundreds of megabytes of dependencies always comes with considerable costs. An usually ignored downside of dependencies is their hit on software longevity.

                                                                                                                This adds a great deal of ergonomics and convenience in the form of a simple text file, that works has tiny dependencies. Even ncurses is left outside the dependency list. If you are in an unix shell and can open a socket to a remote internet location, you can use this. And most likely will be able to do so for many years to come.

                                                                                                            1. 0

                                                                                                              Absolutely not a fan of the name. Too Linux-centric.

                                                                                                              Low cost PLC running open source PLC porgramming languages

                                                                                                              A PLC implemented on top of Linux would be a comically bloated and unreliable PLC implementation.

                                                                                                              industrial-grade

                                                                                                              There’s nothing industrial-grade about Linux. It’s quite an irresponsible statement. I hope nobody gets killed in some factory due to a Linux crash on one of these boards.

                                                                                                              1. 1

                                                                                                                There’s nothing industrial-grade about Linux. It’s quite an irresponsible statement. I hope nobody gets killed in some factory due to a Linux crash on one of these boards.

                                                                                                                I am genuinely curious what you consider non-industrial-grade about Linux.

                                                                                                                Also, the “industrial grade” part actually refers the the hardware, not Linux.

                                                                                                                1. 0

                                                                                                                  I am genuinely curious what you consider non-industrial-grade about Linux.

                                                                                                                  Linux is not suitable for hard realtime or high assurance. Industrial-grade generally refers to reliability, the sort Linux can’t provide.

                                                                                                                  Also, the “industrial grade” part actually refers the the hardware, not Linux.

                                                                                                                  Considering the SBC’s name, this board is meant to run Linux.

                                                                                                              1. 2

                                                                                                                Neat!

                                                                                                                I believe scoop does something very similar (or used to, stuff might have changed since I last dug into its source).

                                                                                                                1. 5

                                                                                                                  Doing a bit of Dwarf Fortress. Going for the console tiles for the retro feel :)

                                                                                                                  1. 2

                                                                                                                    I’ve gotta give that one another attempt.

                                                                                                                    Whenever I’ve tried, I think I’m picking a crappy spot for my settlement, and maybe I’m also not handling all the job assignment mechanics right, because I can get all the above ground workers to do worker bee things, but I can’t get anyone to mine to save my soul :)

                                                                                                                    If you’re enjoying DF you might just possibly enjoy Kruggsmash’s Youtube channel where he details the ongoing fate of his fortress with amusing illustrations and decent story telling :)

                                                                                                                  1. 2

                                                                                                                    Continuing my work on my more or less useless irc bot. Maybe I’ll actually add a feature that would justify the bandwidth.