1. 5

      NeWS is incredibly relevant today because the web stack is trying really hard to reinvent it and (for once) actually learn from its mistakes. NeWS and Display PostScript had a lot of the same advantages and disadvantages. On the plus side:

      • You could write sandboxed code that ran on the display server, so even on a high-latency network you could respond to a button click by animating the button instantly (without a network round trip) and process the event in the background.
      • You had full access to a rich programming model for graphics, inherited directly from PostScript and so you could render anything that a high-end DTP package / printer could.
      • The lowest level of the toolkit had access to an incredibly rich text layout engine.
      • Your display and print output languages were the same (far less important today now that printing is relatively rare and even phones have enough RAM to ship a pre-rasterised image to a printer at 2400dpi).

      On the down side:

      • You had to write PostScript. By hand.

      NeXT’s frameworks on top of DPS basically gave up on a lot of this and lost out on the first positive point in exchange for losing the negative point. They didn’t care too much about remote display, so this wasn’t too much of a limitation. You could write Objective-C to construct NSBezierPath objects that were basically encapsulations of PostScript programs without flow control. There’s a name for PostScript without flow control: PDF[1]. This is why Apple’s Quartz is sometimes referred to as ‘Display PDF’, it keept the PostScript drawing model but removed all of the flow-control commands, leaving something that could be fairly trivially serialised as PDF.

      In the modern browser world, you can write JavaScript or wasm that is sandboxed and runs on the display server (browser) and can respond locally to events and perform asynchronous communication with the back end (via async HTTP requests or WebSockets) to hide latency. The drawing model for canvas tags is the drawing subset of PostScript but with the control flow exposed to JavaScript (you can bounce from wasm to JavaScript, but I expect that direct wasm bindings to canvas are near the top of the to-do list for the folks wanting to do rich web apps without JavaScript). No one needs to write PostScript directly.

      The current problem with the web stack here is that the text layout that you get via the DOM is not fully exposed into canvas. I’m expecting to see a future web browser where the only thing exposed to JavaScript is a top-level canvas and the whole DOM (from HTML parsing onwards) is implemented in JavaScript + canvas.

      [1] Only slightly facetious here: PDF is a document object model where the display objects are a subset of PostScript with the flow-control operations removed and only the rendering left in.

      1. 1

        NeWS is incredibly relevant today because the web stack is trying really hard to reinvent it and (for once) actually learn from its mistakes. NeWS and Display PostScript had a lot of the same advantages and disadvantages.

        If there is something to add it would be the distinction between ‘pages’ versus ‘frames’ – layouting, drawing and so on are very page oriented throughout the stack. The modern end of the stick ‘GPU command buffers as draw commands’ is animation oriented. In that sense the ‘draw commands to handles to composition’ model of SurfaceFlinger and onwards is reasonable, but with quite a few other issues.

        I’m expecting to see a future web browser where the only thing exposed to JavaScript is a top-level canvas and the whole DOM (from HTML parsing onwards) is implemented in JavaScript + canvas.

        I’m expecting one where the ‘HTML as document and not ELF for javascript’ is actually a separate translation stage that merges ‘visual/accessibility/layouting template’ preferences (CSS) with interaction model (WM or browser plugins) and spits out an intermediate representation designed to glue together animation oriented with page oriented in a mostly network friendly format. Ideally one that works recursively where the canvas of one process composes canvases from others without lossless transformations to pixels or worse.

        There are some lessons that JS in browser needs to learn from a post-mortem on FirefoxOS for the JS + Canvas path to not run into similar ‘the devil: synchronization’ motion to photon latency problems, in a similar vein as to how 50Hz/60Hz frame of mind breaks game development. This is one of the systemic issues for which the primitives are unreliable and even printers lacked a working approach to (recover from paper jam and so on).

    1. 2

      This repository contains all the work done during the video recordings by system-crafters

      1. 1

        Does anyone know what does the author mean by “Also this enables me to write a Question-Asking macro for dryads wake without going totally insane.” in the homoiconity section? Does it do something more than you’d implement in other languages with something like a function:

        Choices([Choice]) {...}
        where Choice : (ResponseText, Message?, [Actions])
        

        Where’s the big issue here and how does homoiconity solve it?

        1. 2

          At the basis your function definition and his macro are not that different. Though the macro does not seems to be recursive and can’t really take a list of possible ResponseText, Message?, Actions it still has the upside of “fitting” with the rest of the language. For some (Choose choice action …) it still is better than (Choose ‘((choice . action) …)), e.g. it’s just nicer to read, but some times it has deep implications such as hiding the implementing structures, association list vs tree vs heap vs whatever. He may be very happy about it but the example is just strange.

        1. 1

          Is there a list of previous contest questions somewhere?

          1. 2

            On wikipedia of course :)

          1. 1

            I think this is a big step forward and I’m quite happy that there is something I can pick up with the Rust Book or any other of the introduction to Rust.

            1. 9

              I literally cannot make sense of this thread at all. Half of the messages are from someone who I would assume is a conspiracy-theory spammer. I could literally replace that person’s messages with things copy-pasted from Time Cube and get something about as coherent. Except other people in the thread appear to interact with that person and a quick glance at the group archive suggests this person is somewhat important to what they do?

              Is this some sort of Poe’s Law parody group that I’m just not deep enough into the material to get?

              1. 15

                The poster you’re talking about is Carl Hewitt. He has become a crank, and he denies various basic facts about lambda calculus, Gödel’s work, and Turing’s work. In this thread, he is complaining about Mark S. Miller’s proposed taxonomy for side channels and similar security issues, a work which simply tries to put names to certain common bug classes. Miller has written papers like this before, and just like how plan interference was first discovered in the context of capability theory, we might hope that other non-obvious bug classes can also be found via similar inquiries.

                The main thrust of my post is to rigorously show that Hewitt is wrong to claim that actors are above and beyond Turing machines; we can indeed compute with actors using standard computers. This is something that he and I have argued about before.

                I have owed this particular proof to the group for a few years; during an academic conference, I responded to an open unanswered question by noting that object graphs behave somewhat like hypergraphs, which can be lifted to categories. However, it wasn’t yet obvious how to mutate those graphs, and so it was an idle curiosity. The rest of the proof just snapped together last night.

                1. 5

                  The poster you’re talking about is Carl Hewitt. He has become a crank, and he denies various basic facts about lambda calculus, Gödel’s work, and Turing’s work.

                  Don’t argue with cranks, your life is worth more than that

                  1. 3

                    some people watch TV, some play video games… others, they have less conventional hobbies…

                2. 14

                  Carl Hewitt is famous for kinda sorta inspiring the actor model of concurrency, which is used by Erlang and Pony and stuff. In the mid-00’s or so he went completely bugnuts crazy and has since been banned from ArXiv, Wikipedia, and then Wikipedia a second time. However, since he did influential work in the 70’s and 80’s people still think he’s an intellectual giant.

                  I especially dislike him because he’s ruined a ton of Wikipedia and C2 pages on CS history. Every year Wikipedia admins find like another two dozen of his sockpuppets.

                  1. 1

                    went completely bugnuts crazy

                    Do you mind sharing some details?

                    1. 7

                      He’s been vandalizing Wikipedia pages for the past 15 years with falsehoods like “Gödel was wrong” and “all modern logic programming was inspired by PLANNER” and “Actors are stronger than Turing machines”.

                      If you want to learn more, best place to start is the Wikipedia talk page: https://en.wikipedia.org/wiki/User_talk:Prof._Carl_Hewitt. That doesn’t cover everything; it missed a bunch of pages he vandalized, or that, after having been banned for a decade, he was finally unbanned in October 2016 and then had to be banned again three weeks later.

                      1. 5

                        He gave a talk in Cambridge a couple of years back. I was excited to hear him speak, until about 5 minutes into the talk when it became clear that he was talking complete nonsense. It was pretty uncomfortable listening, he was making assertions that I’d expect any undergraduate to be able to disprove and no one wanted to interrupt because there’s no way of arguing usefully with someone that out of touch with reality.

                    2. 5

                      it’s category theory

                      1. 2

                        I’m gonna try just because I have some time on my hands: because of this document people wondered “do we have a formal model of this?” as it would be quite useful to reason about the stuff. Then @corbin (please correct me) linked the “everything is an actor” premises to a category theory notion, there must be a category of actors (he goes on to sketch one) and it might have some properties (can this thing actually compute everything?). A category of actors could be a Turing category and this is where things are confusing, the category of actors as sketched would be typed but we know Turing categories to be untyped, contadiction.

                        Is this some sort of Poe’s Law parody group that I’m just not deep enough into the material to get?

                        I’m gonna go with maybe :)

                        1. 2

                          I think that you picked up everything. The paradox of Turing categories is that all of the different types exist, but also they can be erased.

                          Like, given some object O, and a Turing object A, the arrows O -> A freeze elements of O as code literals. For example, if O were a natural numbers object, then the elements of O might be 42 or 100, and the corresponding elements of A might be "42" or "100". Similarly, the arrows A -> O are like evaluation of code literals, with "42" being sent to 42 and e.g. "anyRandomIdentifier" being sent to failure/partiality.

                          The effect of this is that an actor could both be fully strictly statically typed in the category-theory tradition, and also have the potential to evaluate code literals which could do anything, including representing elements who don’t belong to any type at all. I have mentioned this paradox before and given examples in C++ and Haskell.

                          Another effect, which contradicts Hewitt’s claims, is that actors can be truly Turing-complete; they can diverge.

                        2. 1

                          I’m curious, who? (you can respond privately if you don’t want to say in public)

                          Jonathan Shapiro and Mark Miller are two of the main figures behind capabilites. Shapiro used to be a professor at CMU. Miller was done lots of work related to sandboxing for JS (at google).

                          Carl Hewitt is the guy behind the Actor Model.

                          Lots of Actor model stuff sounds crazy (since it seems to try awfully hard to be it’s own unique thing), but it’s definitely influential on lots of things.

                          1. 12

                            Carl Hewitt is the guy behind the Actor Model.

                            Carl Hewitt is the guy behind the Actor Model of computation, which was a CS dead end. Notably, Steele and Sussman tried to implement it in Scheme and quickly abandoned it as pointless.

                            The Actor Model of concurrency was invented by Gul Agha, one of Hewitt’s grad students. Hewitt’s been taking credit for it ever since.

                            1. 2

                              OK, this plus the “yeah, he really is that sort of crank” stuff makes things make more sense, because I was reading “Actor” as the concurrency model and not getting anywhere from that.

                            2. 4

                              I’m curious, who?

                              It’s pretty clear he’s referring to message like this, which have a typography and writing style with more than a passing resemblance to the Timecube website.

                              This entire “Universal Intelligent Systems” (also see video) thing seems to be missing some points. It looks like a mathematician thinking they can solve problems that are not mathematical in nature with mathematics.

                              1. 3

                                I’ve seen his talks in person. They are much, much worse. But he keeps getting invited to prestigious places because he once did some interesting work. It’s kinda depressing all around.

                                1. 5

                                  I’ve seen his talks in person. They are much, much worse. But he keeps getting invited to prestigious places because he once did some interesting work. It’s kinda depressing all around.

                                  I’ve been to one of these, and IMO the best part of the talk was when Hewitt got so caught up in his own conspiracy theory rant that he forgot where he was and literally fell off the stage.

                                  1. 3

                                    I feel bad, but fuck me that’s hilarious. Pure absent-minded professor.

                                  2. 1

                                    I really think there should be a limit on how much we tolerate cranks in the CS space. I get that some people are contrarian, but still.

                                    1. 6

                                      Contrarian implies some level of expertise. In a 2018 keynote I attended, he claimed he solved the halting problem.

                                      1. 1

                                        I’m a contrarian (or maybe a partial crank) in that I think fear of the halting problem keeps us from doing a lot of really useful stuff, but it’s a pretty simple thing to grok, how could it be wrong/solved?

                                        1. 3

                                          I believe his specific claim was “actors can have timeouts, so they’re guaranteed to halt”

                                  3. 2

                                    Someone should do a psychological study on the people who use colors and typefaces like this

                                    https://professorhewitt.blogspot.com/

                                    I’m unfamiliar with SSRN.com - it’s an open-access site run by Elsevier?

                                    1. 3

                                      SSRN is a pre-print site owned by elsevier.

                              1. 7

                                What’s the advantage of this vs. just expressing dependencies directly? That is, if you have some frontend service Foobar that needs Postgres, why not just have foobar.service do After=postgresql.service etc. directly, instead of going through the hassle of putting that directive in infra.target and then having frontend.target depend on that? It just seems like a lot of abstraction for very little gain. In fact, you’ll probably take a boot performance hit because systemd can no longer fully parallelize boot. Specifically, if some frontend service Baz does not require Postgres, under this setup systemd is not allowed to start Baz at the same time as Postgres, even though it could.

                                What I have found targets to be very helpful for is grouping different services that make up one “app” together. For example: foobar-web@.service and foobar-worker@.service, where there might be an arbitrary number of web frontend processes and background job worker processes, respectively. It’s very helpful to bind these together into e.g. foobar.target so you can query and change the state of the entire Foobar app with a single systemctl command.

                                1. 2

                                  Additionally what I would personally do is to make most of these services start on demand instead. This would allow me to make services start when really needed at cost of some initial connections.

                                  1. 1

                                    What’s the advantage of this vs. just expressing dependencies directly?

                                    Now it’s quite simple to add another dependency to all your apps, say redis. As I run more and more apps knowing I get the same services to boot before them lets me think of my server more of a platform. E.g. starting nginx after all container names are registered makes it super easy to have route traffic to the correct app without having to hand out IP manually.

                                    In fact, you’ll probably take a boot performance hit because systemd can no longer fully parallelize boot.

                                    Yep, that’s true there’s a little overhead event with my simple use case I’m seeing 39s instead of 37s which in the end is something.

                                    What I have found targets to be very helpful for is grouping different services that make up one “app” together.

                                    That’s also very nice to have I was using namespaces for this but it’s much simpler.

                                    1. 3

                                      Now it’s quite simple to add another dependency to all your apps, say redis.

                                      Does all that apps require Redis? I highly doubt it. And finer grade control would allow to start such services before Redis, which could result in better startup performance.

                                      E.g. starting nginx after all container names are registered makes it super easy to have route traffic to the correct app without having to hand out IP manually.

                                      Or you can dynamically register services and just reload Nginx configuration after each new service is registered. This would allow to handle services faster with proper fallback to error message. You could use for example Consul to do so, with consul-template. No manual handling of IPs, distributed if needed, and more robust.

                                      1. 3

                                        I think we are getting further and further from each others use case, I run one VPS for my wonky web apps not software in production. That said it’s just very nice to add one new app and be sure it will get the same services as all the others, I can always register it as WantedBy=multi-user.target or specify its Wants if needed.

                                        Or you can dynamically register services and just reload Nginx configuration after each new service is registered.

                                        that’s all very nice but I will always take my configuration as text files thank you, I looked into using the nginx HTTP API and it’s not worth it for my usage. I have some M4 templates around and a shell script for adding and removing them and so far so good.

                                  1. 2

                                    I guess often the issue is that even if, for example, Postgres is up, that doesn’t mean it’s available for other services to use. So even if the startup order is enforced, that solves only part of the problem.

                                    If you know how to solve that with systemd, I’m interested!

                                    1. 6

                                      Well, PostgreSQL supports Type=notify if compiled with appropriate flags. You can use that to launch it and wait until it is ready to accept connections.

                                      1. 1

                                        Oh I didn’t know that! Thank you very much !!

                                      2. 2

                                        As you say there’s many things that might prevent a client from connecting, one that I found was the network name resolution. As I run postgres inside a container managed by systemd-nspawn I have to register the name postgres to be resolved by nss. I’m just lucky that nss_mymachines does this for me and is bound to networkd so I can just put another target there and wait for both my machined target along networkd. This way I know that everything has been started and the network names are registered.

                                        Obviously this does not mean you can just gloss over client side retries and backoffs, that’s just asking for troubles.

                                        If you are not that lucky and you are writing your own daemon I guess the best option is systemd.notify where you can signal that your daemon is now ready for doing real work and the unit startup sequence is only completed when you send the READY=1.

                                      1. 1

                                        First, it’s not possible to setup user namespaces in pure Go.

                                        That’s interesting!

                                        The creation of a user namespace systematically fails with EINVAL if the program is threaded, and there is no way to unshare the user namespace before Go creates a thread.

                                        So now I have my next experiment, trying if something like LockOSThread actually helps creating user namespaces or there’s more magic involved.

                                        1. 5

                                          Obviously missing a lot of languages, but prolog seems like a major omission. It was one of the inspirations for Erlang. In fact Erlang was prototyped in prolog before being rewritten in C for performance purposes.

                                          Joe Armstrong even helped the writer of 7 languages in 7 weeks learn prolog as part of writing the book:

                                          https://www.bennadel.com/blog/2060-seven-languages-in-seven-weeks-a-pragmatic-guide-to-learning-programming-languages-by-bruce-tate.htm

                                          1. 1

                                            Historically speaking, I’m of the opinion that Prolog isn’t that important. I know that it’s at least mentioned in many university-level PL courses, but why? It didn’t influence the design of any of the other languages on that chart: I didn’t know Erlang was prototyped in Prolog, but as far as language design goes, I don’t think Erlang derives inspiration from Prolog.

                                            What other omissions did you have in mind?

                                            1. 4

                                              Well, lots of languages: Algol, scheme, self, simula, sql, c#, COBOL, pascal, etc. (Edit: didn’t see Self before! Originally looked at the graphic on mobile. My bad.)

                                              Prolog I bring up because it is early logic programming language which is another (major? minor?) paradigm and it is a parent to Erlang, which is on the list.

                                              Ultimately, this is an opinionated list. So whatever floats your boat.

                                              I don’t think Erlang derives inspiration from Prolog.

                                              Erlang started out as a modified prolog.

                                              http://erlang.org/faq/academic.html#idp32827664

                                              1. 3

                                                Scheme is somewhat a major language, but it didn’t have the kind of influence that I imagined it would. The chart does show LISP, CL, and their influences, if it’s any consolation. The others, I still can’t justify crowding the chart with.

                                                I added Prolog: thanks for the read.

                                                Self was added after I got some comments about it. Sorry, the site isn’t really made for mobile: there are way too many large commutative diagrams that don’t render well on mobile.

                                              2. 3

                                                don’t think Erlang derives inspiration from Prolog

                                                seeing how it’s almost the weekend I’m gonna leave this here but I’m also gonna say that when Joe Armstrong was thinking about this new language he wrote down the rules and somebody else told him he had done “an algebra” and that he could embed it in prolog easily (not sure about where the quote comes from).

                                                1. 1

                                                  Thanks for the interesting read. It convinced me to include Prolog in the chart :)

                                            1. 3

                                              I’ve been interested in WebIDL for some time now and I’m writing some tools to make some things easier but kind of by chance I found this project using WebIDL to expose system programming API to Javascript. The project has many parts and the ES operating system is just one. They also have a browser, a keyboard, a portable computer and some more.

                                              1. 2

                                                I want to understand this, but I need to start with the motivation.

                                                Why would I be interested in corecursion and coinduction? What does it get me? When might I use these things?

                                                1. 1

                                                  Whenever you have a computation that works on a stream then you have a co-inductive structure at hand. A web server receiving requests and serving responses all day is quite different from a compiler because one works on a stream of data while the other works on files it can read fully (and will not work otherwise). The co-inductive part also comes with its own problems, co-recursion must be proved productive (it will return a response and a new stream) to advance the stream decomposition and return data to the client. Proving productivity syntactically does not always work and you have to come up with some alternatives (e.g. sized types) but you also have to come up with a sound way to decompose a stream, usually done with proving two streams S and (stream-cons a S') are equal up to something, usually a bisimulation.

                                                1. 2

                                                  Python is already almost pseudocode though… :P

                                                  1. 1

                                                    But we don’t want it to be executable!

                                                  1. 1

                                                    I might be biased but if your dependencies are already packaged then a package would be what you need. Installing a package not only install the software and its dependencies but it also can put configuration in place and you can save custom values in a database like dpkg to generate your configuration from templates. Also dpkg has a curses interface so you can put a lot of information to guide people who are not tech savy.

                                                    For anything fancier than put this file in this directory I would provide a web-ui where your admin can click things and save it to the database/config.

                                                    1. 4

                                                      I expected this <opt-in-script> tag to be defined as a custom element but it’s just ignored by the browser and rendered as a p while there is some JS to turn it into a <script> tag on the button click. It’s actually a quite nice implementation that can be used for older browsers.

                                                      1. 2

                                                        Yeah. No need for anything fancy, the script is less than 500 bytes. IIRC unregistered custom tags used to cause issues in IE8. After that they’ve been handled as unstyled inline elements.

                                                      1. 1

                                                        On Wednesday I have a presentation for my Topological Data Analysis course, it’s coming together but it’s slow. I also want to implement and replicate results from a paper in python+numpy seeing how a common combination is for scientific computing.

                                                        1. 5

                                                          I keep looking a Racket Stories from time to time and I think it’s a good tool for keeping up with development of Racket. You can find both blog posts, packages and papers eventually make their way there.

                                                          1. 1

                                                            The link redirects to the CS dept home page. The article is here in the ACM digital library, which currently doesn’t have any subscriber restrictions or paywall.

                                                            I find it interesting that a paper from 2003 listing canonical reading in computer science has nothing later than 1981. Were there no subsequent paradigm shifts or big advances in the field? I would’ve thought that human-computer interaction, parallel algorithms, and cybersecurity (if that’s within scope) all moved on dramatically in the intervening time.

                                                            1. 2

                                                              Unfortunately, the author of this paper passed away in 2019.

                                                              I would hope this paper continuous to influence computer science programs in various education venues.

                                                              I think, to a degree, the intent of the author was to separate ‘application’ of CS vs ‘foundations’ of CS.

                                                              Which is why there is a focus on fundamental ways to carry out a ‘compute’.

                                                              Have there been advances in the foundations of CS since ’81? I am sure.

                                                              But I could not come up with something that changed a fundamental carrying out of compute (with exception of quantum computing).

                                                              I think there are multiple new subfields developed, though, with most foundational one being program verification (that extends to verifiable correctness, security, computability limits). I think this subfield will have tremendous long lasting impact for next 100 years. As we will transition of how we teach CS from ‘guessing’ how to build ‘what will work’, to proving that it will work.

                                                              1. 2

                                                                The link redirects to the CS dept home page. The article is here in the ACM digital library, which currently doesn’t have any subscriber restrictions or paywall.

                                                                Thank you! I made an opsie again.

                                                                I find it interesting that a paper from 2003 listing canonical reading in computer science has nothing later than 1981.

                                                                They actually address this in the paper, mistery solved!

                                                                Another aspect of the readings shown is their age: for the most part, we have hewed to a rule that Canon papers should be at least 20 years old to be included in the course. The purpose of this rather arbitrary cut-off point is to provide a rough means of ensuring the lasting interest of the work in question.

                                                                1. 1

                                                                  Oh, thanks, I didn’t spot that paragraph in the article when I read it. It’d be interesting to consider what writing from 1981-2000 would be included in a modern update of that article using the same rules, but also what the likely candidates are from this millennium too.

                                                              1. 1

                                                                Asking as someone with basically no mobile dev experience but with interest in development a mobile PWA (progressive web app), how useful does GeckoView seem for that? Or does it make more sense to focus exclusively on a PWA for the foreseeable future?

                                                                This would be an authoring app where data preservation and state preservation would be paramount.)

                                                                1. 3

                                                                  We made a PWA for one of our mobile games and then wrapped it in a native app package with Cordova (because most mobile users are used to downloading apps).

                                                                  On iOS, using the WebView was fine. On Android, it was a giant pain, as several things don’t quite work in WebViews as they do in Chrome. Not to mention the version differences. There are several bugs, annoyances, and inaccurate or incomplete docs related to Android WebView and related APIs (for example, not being able to intercept the body of POST requests). Our PWA worked seamlessly in the mobile browser, but we ended up having to make several changes to make it work in the WebView.

                                                                  Super glad to see this posted today. It might save us from further hackery.

                                                                  1. 1

                                                                    Thanks! I don’t recall hearding about Cordova before and that looks helpful. Particularly grateful for the heads-up on your Android experience because that would be my primary target.

                                                                  2. 1

                                                                    This is an interesting question, I’m not sure which API are exposed to JS running in a webview. Having a full fledged browser embedded in your app can be a boon for modern API that are not available otherwise. I think workers might not be available in a common webview so a PWA re-packaged as an app might have some difficult times. You would have easier life on bundling your assets in the app but all the networking would be quite different, e.g. services workers might be gone.

                                                                    1. 1

                                                                      Thanks for the heads up!

                                                                  1. 2

                                                                    So, why is this coding stream upvoted and mine was marked as spam?

                                                                    Is it because I had posted my own stream? Because I was fixing bugs on an existing project that isn’t particularly popular? Because it was in progress rather than an old stream?

                                                                    I’m just trying to understand what is considered on-topic and what is considered spam. Is it more appropriate to post upcoming livestreams on IRC?

                                                                    1. 8

                                                                      You got one person marking it as spam. This isn’t necessarily indicative of everyone’s feelings here!

                                                                      Personally, I think that this board is maybe a bit not ideal for announcements on time sensitive things, but posting full recordings later if it’s an interesting stream is good.

                                                                      If you are interested in announcing in-progress streams, perhaps the IRC channel would be a better fit? I would click on it if it were posted in there

                                                                      To be crystal clear: I think a lot of people in the community like this kind of content! I imagine the spam vote was from somebody in a bad mood who read your post as “self promotion” (personally doesn’t make much sense to me)

                                                                      1. 5

                                                                        I appreciate that, I’ll try the IRC the next time I stream. Thanks!

                                                                      2. 4

                                                                        This is actually a good discussion that needs to happen here. There are already platforms that do some aggregation of live coding and my opinion is that they work better than lobsters for that. The front page is changing very fast already and having time constrained elements would make it change even faster.

                                                                        1. 2

                                                                          Thanks for the link! I’ll be sure to use that site next time.

                                                                          Edit: This bit does resonate with me;

                                                                          The front page is changing very fast already and having time constrained elements would make it change even faster.

                                                                          I wasn’t planning on posting every stream here, but this makes a lot of sense and I probably won’t post another here unless it’s much more relevant.

                                                                        2. 3

                                                                          Andrew Kelley is definitely a favorite on this site, which makes anything posted immediately more visible. I’m not sure why yours was flagged spam, but perhaps someone didn’t want to see it and needed a reason to downvote.

                                                                          1. 0

                                                                            Ah, so this is just a classic double-standard. Nice.

                                                                            I can understand if nobody liked my stream, but if livestreams are welcome then a “spam” downvote is just false.

                                                                          2. 3

                                                                            This is probably more about what is shown here: The demonstration aspect of what you can do in zig. And about showing people how you can do this live, thus in a reasonable amount of time and effort. This more a show-off how capable zig is already, and lobster is pretty interested in zig and new languages like this. At least this is why I felt like this belongs here, even though I haven’t watched it.