1. 4

    Can anyone help me understand why Metal was designed? Apple’s a heavy hitter in Khronos, right? So what was it that they felt like they couldn’t accomplish with OGL/OCL? Are there non-Mac targets that support Metal?

    1. 6

      OpenGL is a tired old API that is too high level for high performance graphics work. At the time when Metal was being developed folks were working on lower level APIs to expose the GPU more, like Mantle and DirectX 12, and Metal was Apple’s offering. I believe Mantle eventually evolved into Vulkan, but for some reason Apple is continuing to promote Metal. It’s a nicer API for Swift users, but that’s about it. I would have preferred that they’d make a safe API over Vulkan for Swift like Vulkano, they seem to be under some weird impression that they’ll be able to trap devs in their platform with their own, proprietary API. Or maybe they just can’t bear to give up all the sunk cost.

      1. 2

        they seem to be under some weird impression that they’ll be able to trap devs in their platform with their own, proprietary API

        Is it not working quite well for Microsoft with DirectX?

      2. 1

        As I vaguely recall, it started on ios as a way to utilize their graphics chips faster and more efficiently (lower overhead).

      1. 1

        Is the resulting C++ and Haskell source available somewhere?

        1. 1

          I gave up trying to find it shortly in due to how University of West Florida’s website is laid out. Most can take me right to the publications and software. It’s like they’re trying to hide their work behind a bunch of sales pitches. Coffey’s page was interesting in that he did a bunch of work on knowledge bases and cognitive applications. If not paywalled, his work on knowledge elicitation and representation might be submission-worthy.

        1. 2

          Personally I think these small language are much more exciting than big oil tankers like Rust or Swift.

          I’m not familiar with either of those languages, but any idea what the author means by this? I thought Rust has been picking up quite a bit recently.

          1. 10

            I understood the author to be talking about the “size” of the language, not the degree of adoption.

            I’m not sure that I personally agree that C is a small language, but many do belive that.

            1. 3

              Your involvement with rust will bias your opinion - rust team hat would be appropriate here :)

              1. 11

                He is right though. C’s execution model may be conceptually simple but you may need to sweat the implementation details of it, depending on what you’re doing. This doesn’t make C bad, it just raises the bar.

                1. 9

                  I had that opinion before Rust, and I’m certainly not speaking on behalf of the Rust team, so in my understanding, the hat is very inappropriate.

                  (I’m also not making any claims about Rust’s size, in absolute terms nor relative to C)

                  1. 4

                    Or you can just test his claim with numbers. A full, C semantics is huge compared to something like Oberon whose grammar fits on a page or two. Forth is simpler, too. Whereas, Ada and Rust are complicated as can be.

                    1. 5

                      I agree that there are languages considerably smaller than C. In my view, there is a small and simple core to C that is unfortunately complicated by some gnarly details and feature creep. I’ve expressed a desire for a “better C” that does all we want from C without all the crap, and I sincerely believe we could make such a thing by taking C, stripping stuff and fixing some unfortunate design choices. The result should be the small and simple core I see in C.

                      When comparing the complexity of languages, I prefer to ignore syntax (focusing on that is kinda like bickering about style; yeah I have my own style too, and I generally prefer simpler syntax). I also prefer to ignore the standard library. What I would focus on is the language semantics as well as the burden they place on implementation. I would also weigh languages against the features they provide; otherwise we’re talking apples vs oranges where one language simply makes one thing impossible or you have to “invent” that thing outside the language spec. It may look simpler to only present a floating 64-bit point numeric type, but that only increases complexity when people actually need to deal with 64-bit integers and hardware registers.

                      That brings us to Oberon. Yes, the spec is short. I guess that’s mostly not because it has simple semantics, but because it lacks semantics. What is the range of integer types? Are they bignums, and if so, what happens you run out of memory trying to perform multiplication? Perhaps they have a fixed range. If so, what happens when you overflow? What happens if you divide by zero? And what happens when you dereference nil? No focking idea.

                      The “spec” is one for a toy language. That is why it is so short. How long would it grow if it were properly specified? Of course you could decide that everything the spec doesn’t cover is undefined and maybe results in program termination. That would make it impossible to write robust programs that can deal with implementation limitations in varying environments (unless you have perfect static analysis). See my point about apples vs oranges.

                      So the deeper question I have is: how small can you make a language with

                      1. a spec that isn’t a toy spec
                      2. not simply shifting complexity to the user
                      3. enough of the same facilities we have in C so that we can interface with the hardware as well as write robust programs in the face of limited & changing system resources

                      Scheme, Oberon, PostScript, Brainfuck, etc. don’t really give us any data points in that direction.

                      1. 5

                        So the deeper question I have is: how small can you make a language with

                        1. a spec that isn’t a toy spec
                        2. not simply shifting complexity to the user
                        3. enough of the same facilities we have in C so that we can interface with the hardware as well as write robust programs in the face of limited & changing system resources

                        Scheme, Oberon, PostScript, Brainfuck, etc. don’t really give us any data points in that direction.

                        Good question. There are few languages with official standards (sorted by page count) that are also used in practice (well.. maybe not scheme ;>):

                        1. Scheme r7rs - 88 pages - seems to be only language without useful standard library
                        2. Ruby 1.8 - 341 pages
                        3. Ada 95 - 582 pages
                        4. Fortran 2008 - 621 pages - seems to be only language without useful standard library
                        5. C11 - 701 pages
                        6. EcmaScript - 885 pages
                        7. Common Lisp - 1356 pages
                        8. C++17 - 1623 pages

                        I know that page count is poor metric, but it looks like ~600 pages should be enough :)

                        1. 3

                          Here are the page counts for a few other programming language standards:

                          1. PL/I General purpose subset 443 pages
                          2. Modula-2 800 pages - base - 707 pages, generics - 45 pages, objects - 48 pages
                          3. Ada 2012 832 pages
                          4. Eiffel 172 pages
                          5. ISO Pascal 78 pages
                          6. Jovial J73 168 pages
                          1. 2

                            I know that page count is poor metric, but it looks like ~600 pages should be enough :)

                            Given that N1256 is 552 pages, yeah, without a doubt.. :-)

                            The language proper, if we cut it off starting at “future language directions” (then followed by standard library, appendices, index, etc.) is only some 170 pages. It’s not big, but I’m sure it could be made smaller.

                          2. 2

                            I’ve expressed a desire for a “better C” that does all we want from C without all the crap, and I sincerely believe we could make such a thing by taking C, stripping stuff and fixing some unfortunate design choices. The result should be the small and simple core I see in C.

                            That might be worth you writing up with hypothetical design. I was exploring that space as part of bootstrapping for C compilers. My design idea actually started with x86 assembler trying to design a few, high-level operations that map over it which also work on RISC CPU’s. Expressions, 64-bit scalar type, 64-bit array type, variables, stack ops, heap ops, expressions, conditionals, goto, and Scheme-like macros. Everything else should be expressable in terms of the basics with the macros or compiler extensions. The common stuff gets a custom, optimized implementation to avoid macro overhead.

                            “ What I would focus on is the language semantics as well as the burden they place on implementation. “

                            Interesting you arrived at that since some others and I talking verification are convinced a language design should evolve with a formal spec for that reason. It could be as simple as Abstract, State Machines or as complex as Isabelle/HOL. The point is the feature is described precisely in terms of what it does and its interaction with other features. If one can’t describe that precisely, how the hell is a complicated program using those same features going to be easy to understand or predict? As an additional example, adding a “simple, local change” show unexpected interactions or state explosion once you run the model somehow. Maybe not so simple or local after all but it isn’t always evident if just talking in vague English about the language. I was going to prototype the concept with Oberon, too, since it’s so small and easy to understand.

                            “but because it lacks semantics.”

                            I didn’t think about that. You have a good point. Might be worth formalizing some of the details to see what happens. Might get messier as we formalize. Hmm.

                            “So the deeper question I have is: how small can you make a language with”

                            I think we have answers to some of that but they’re in pieces across projects. They haven’t been integrated into the view you’re looking for. You’ve definitely given me something to think about if I attempt a C-like design. :)

                    2. 4

                      He also says that the issues with memory-safety in C are overrated, so take it with a grain of salt.

                      1. 13

                        He is not claiming that memory safety in general is not an issue in C. What he is saying is that in his own projects he was able to limit or completely eliminate dynamic memory allocation:

                        In the 32 kloc of C code I’ve written since last August, there are only 13 calls to malloc overall, all in the sokol_gfx.h header, and 10 of those calls happen in the sokol-gfx initialization function

                        The entire 8-bit emulator code (chip headers, tests and examples, about 12 kloc) doesn’t have a single call to malloc or free.

                        That actually sounds like someone who understands that memory safety is very hard and important.

                        1. 3

                          Not at all the vibe I got from it.

                        2. 4

                          I’m not familiar with either of those languages, but any idea what the author means by this?

                          I’m also way more interested in Zig than I am in Rust.

                          What I think he’s saying is that the two “big” languages are overhyped and have gained disproportionate attention for what they offer, compared to some of the smaller projects that don’t hit HN/Lobsters headlines regularly.

                          Or maybe it’s a statement w.r.t. size and scope. I don’t know Swift well enough to say if it counts as big. But Rust looks like “Rubyists reinvented C++ and claim it to be a replacement for C.” I feel that people who prefer C are into things that small and simple. C++ is a behemoth. When your ideal replacement for C would also be small and simple, perhaps even more so than C itself, Rust starts to seem more and more like an oil tanker as it goes the C++ way.

                          1. 3

                            I agree with your point on attention. I just wanted to say maybe we should get a bit more credit here:

                            “compared to some of the smaller projects that don’t hit HN/Lobsters headlines regularly.”

                            Maybe HN but Lobsters covers plenty oddball languages. Sometimes with good discussions, too. We had authors of them in it for a few. I’ve stayed digging them up to keep fresh ideas on the site.

                            So, we’re doing better here than most forums on that. :)

                            1. 2

                              Sure! Lobsters is where I first learned about Zig. :-)

                        1. 6

                          I loved QBasic and it’s where I started too… but I don’t see how it is any easier than, say, ruby or python for the same tasks being done in this post. No need to introduce advanced concepts just because a language has them.

                          1. 9

                            He double clicked the icon on his desktop and in a split second, we were in the IDE..

                            Ruby and Python can’t do that.

                            Also, OP doesn’t mention it, but: graphics. In Ruby or Python if you want graphics you end up having to deal with gem and rvm and pip and virtualenv and on and on and on and fucking on. In QBasic you type CIRCLE and hit F5.

                            I’ve written about these issues before. You have to try teaching programming for yourself to see the tiny things that trip noobs up.

                            1. 3

                              I expected graphics to be the reason OP thought QBasic was the way to go, but then it was never mentioned so it seemed like a much less compelling argument.

                              1. 3

                                you end up having to deal with gem and rvm and pip and virtualenv and on and on and on and fucking on. In QBasic you type CIRCLE and hit F5.

                                Racket can do just that.

                                You have to try teaching programming for yourself to see the tiny things that trip noobs up.

                                Racket is also made specifically for teaching.

                                1. 2

                                  True. The drawback of Racket: much as I hate people harping on lisp parentheses, they do hinder noobs. Also mentioned in my post linked above.

                                  But Racket also has Pyret. Which seems pretty nice, though I haven’t tried it.

                                2. 2

                                  And then VB6 made GUI’s about as easy. And like you said about QBasic, I’d click VB6, IDE loaded in a second, start project, type some code for the console thing if I wanted, press run, wait one second, results. Rinse repeat. The concept that mattered aside from speed is flow: the BASIC’s have a development flow that maximizes mental flow to keep people constantly moving. Pascal’s can do it, too, since they compile fast. Smalltalks and LISP on extreme end of it.

                                  The other advantage of BASIC’s are that they look like pseudocode people write down before actually coding. BASIC is so close to pseudocode that they can do the pseudocode in BASIC itself or barely do a translation step. In the Slashdot and other comments, I see the “it looks just like pseudocode!” response show up constantly among people that started with BASIC. Something that shouldn’t be ignored in language design at least for beginners. Probably also DSL or HLL designers, too, trying to keep things closer to the problem statement.

                              1. 1

                                Less well known are integer overflow bugs. Offset-length pairs, defining a sub-section of a file, are seen in many file formats, such as OpenType fonts and PDF documents. A conscientious C programmer might think to check that a section of a file or a buffer is within bounds by writing if (offset + length < end) before processing that section, but that addition can silently overflow, and a maliciously crafted file might bypass the check.

                                So, some experiences from the pixel mines.

                                We were implementing our own format for 3D mesh data for static (initially) meshes, and went through probably 4-5 implementations. The initial format was based on nice tree structures, while the final format was more of a length-prefixed block-based approach.

                                The reason for this change is that, if you have a maliciously-formed tree structure, it can be really easy to hamstring your parser. You have extra records, or not enough records, and parsing gets to be a headache. You also have to build a smarter parser, because you kind of need to keep an idea of state as you pop up and down in the hierarchy of things, and you can’t really make a lot of allocation guarantees ahead of time until the tree is walked.

                                By contrast, a block format lets you quickly skip down the list of blocks, do most of your allocations up front, and then patch up and copy things around at the end. At that point, having good safe arithmetic routines prevents you from over-allocating or under-allocating things.

                                Towards that end, in C++ a very handy thing to do is to create a BinaryRegionReader class that provides “safe” and bounds-checked access to a region of memory, and which allows the creation of child BinaryRegionReaders.

                                1. 1

                                  Towards that end, in C++ a very handy thing to do is to create a BinaryRegionReader class that provides “safe” and bounds-checked access to a region of memory, and which allows the creation of child BinaryRegionReaders.

                                  So, basically std::string_view?

                                  1. 0

                                    Sort of, but also with the ability to read off native types in order and respect endianness and do seeking safely.

                                    1. 1

                                      Sure, that makes sense.

                                      Btw what lead you to go with completely custom format instead of using something like protocol buffers or cap’n proto?

                                      1. 1

                                        Reasons we didn’t use those:

                                        • We had our own routines that better handled certain issues (see: safe arithmetic)
                                        • We were doing some of that as a learning project
                                        • Wanted to easily support multiple platforms–our codebase was already setup for that
                                        • Would still have required coming up with a format for the layout (since you want something that is easy to shove into graphics buffers anyways) even with the help those libs provide
                                        • Add extra build steps and autogenerated code wasn’t appealing
                                        • Having our own code/copyright gave more licensing flexibility (WTFPL ftw)
                                1. 2

                                  for all the diligence required to solve this sort of problem, you’d think that would start pushing programming more towards, ya know, engineering as a way of building things, but at least its a cool story!

                                  1. 2

                                    As it was a hardware issue in this case, I’m not sure I understand what you’re saying. Do you mean that if, say, the software was verified and guaranteed not to crash, they would have immediately diagnosed the crash as a hardware issue, thus saving a lot of time?

                                    1. 3

                                      In general, you can do that sort of thing in Design-by-Contract with a certified and non-certified compiler. In debug mode, the contracts can all become runtime checks showing you exactly which module fed bad input into the system. That lets you probe around to localize exactly which bad box took input that accepted its preconditions, did something with it, and produced output that broke the system. When looking at that module, it will normally be a software bug. However, you can run all failing tests through both a certified and regular binary to see if the failure disappears in one. If it does, it’s probably a compiler error. Similar check running sequential vs concurrent in case it’s a concurrency bug. Similarly, if the logic makes sense, it’s not concurrency, and passes on certified compiler, it’s probably an error involving something else reaching into your memory or CPU to corrupt it. That’s going to be either a hardware fault or a privileged component in software. With some R&D, I think we could develop for those components techniques for doing something similar to DbC in software for quickly isolating hardware faults.

                                      That said, I don’t think it was applicable in this specific case. They’d have not seen that problem coming unless they were highly-experienced, embedded engineers. I’ve read articles from them where they look into things like effects of temperature, bootloader starting before PLL’s sync up, etc. Although I can’t find link, this isn’t the first time sunlight has killed off a box or piece of software. I’ve definitely seen this before. I think a friend might have experienced it with a laptop, too. We might add to best practices for hardware/software development to make sure the box isn’t in sunlight or another situation that can throw its operating temperature. I mean, PC builders have always watched that a bit but maybe the developers on new hardware should ensure it’s true by default. The hardware builders should also test the effects of direct sunlight or other heat to make sure the boxes don’t crash. Some do already.

                                      1. 3

                                        However, you can run all failing tests through both a certified and regular binary to see if the failure disappears in one. If it does, it’s probably a compiler error.

                                        I don’t think that’s true, at least in C. I know CompCert at least takes “certified” to mean “guarantees well-defined output for well-defined input”, so it’s free to make hash of any UB-containing code the same as Clang.

                                        That said, if your test results change between any two C compilers, it’s a strong suggestion you have a UB issue.

                                        1. 2

                                          it’s a strong suggestion you have a UB issue.

                                          True, too. There’s teams out there that test with multiple compilers to catch stuff like that. OpenBSD folks mentioned it before as a side benefit of cross-platform support.

                                          1. 2

                                            That said, if your test results change between any two C compilers, it’s a strong suggestion you have a UB issue.

                                            In C, this can also mean that you depend on implementation-defined bahaviour or unspecified bahaviour which are not the same as undefined behaviour (which often will also be a bad thing ;)).

                                          2. 2

                                            Are you proposing gamedev companies should adopt that kind of techniques?

                                            1. 3

                                              Im always pushing all programmers to adopt anything that helps them that they can fit in their constraints. Aside from Design-by-Contract, I’d hold off on recommending game developers do what I described until the tooling and workflow are ready for easy adoption. Ive got probably a dozen high-level designs for it turning around in my head trying to find the simplest route.

                                              One thing Im sure about is using C++ is a drawback since it’s so hard go analyze. About everything I do runs into walls of complexity if the code starts in C++. Still working on ideas for that like C++-to-C compilers or converting it into equivalent, easier-to-analyze language that compiles to C (eg ZL in Scheme). So, I recommend avoiding anything as complex as C++ if one wants benefits from future work analyzing either C or intermediate languages.

                                              Edit: Here was a case study that found DbC fit game dev requirements.

                                              1. 2

                                                The other day there was a link to a project that does source-to-source transformation on C++ code to reduce the level of indirection: https://cppinsights.io

                                                1. 2

                                                  Try doing an exhaustive list of FOSS apps for C and C++ doing this stuff. You’ll find there’s several times more for C which also collectively get more done. There’s also several certifying compilers for C subsets with formal semantics for C++ still barely there despite it being around for a long time.

                                                  So, that’s neat but one anecdote goimg against a general trend.

                                                2. 1

                                                  Im always pushing all programmers to adopt anything that helps them that they can fit in their constraints.

                                                  This is meaningless - is there someone who doesn’t?

                                                  Aside from Design-by-Contract, I’d hold off on recommending game developers do what I described until the tooling and workflow are ready for easy adoption.

                                                  So the only one thing you propose would not help at all with problem with overheating console or with performance regression from that post ;)

                                                  One thing Im sure about is using C++ is a drawback since it’s so hard go analyze.

                                                  Sure, it’s hard but there are tools that can do some sort of static analysis for it (for example Coverity or Klocwork). Either way, there are no alternatives today for c++ as language for engine that can be used for AAA games.

                                                  Here was a case study that found DbC fit game dev requirements.

                                                  Have you actually read it? I have nothing against DbC, but as far as I can see that study doesn’t really show any great benefits of DbC nor is it realistic. They do show that writing assertions for pre/post conditions and class invariants helps in diagnosing bugs (which is obvious), but not much more.

                                                  They don’t show that really hard bugs are clearly easier to diagnose and fix with DbC, nor do they show that cost/benefit ratio is favourable for DbC.

                                                  Finally, that paper fails to describe in detail how was the experiment conducted - all I could gather is this:

                                                  Implementation took approximately 45 days full-time and led to source code consisting of 400 files.

                                                  code was predominantly implemented by one person

                                                  Even it was an interesting paper (which imo it is not) it’s impossible to try and replicate it independently.

                                                  1. 1

                                                    “This is meaningless - is there someone who doesn’t?”

                                                    Yes, most developers don’t if you look at the QA of both proprietary and FOSS codebases. I mean, every study done on formal specifications said developers found them helpful. Do you and most developers you see use them? Cuz I swore Ive been fighting an uphill battle for years even getting adoption of consistent interface checks and code inspection for common problems.

                                                    “but as far as I can see that study doesn’t really show any great benefits of DbC nor is it realistic. They do show that writing assertions for pre/post conditions and class invariants helps in diagnosing bugs (which is obvious)”

                                                    It’s so “obvious” most developers aren’t doing DbC. What it says is that DbC fits the requirements of game developers. Most formal methods don’t. It also helped find errors quickly. It’s not mere assertions in the common way they’re used: it can range from simple Booleans to more complex properties. One embedded project used a whole Prolog. Shen does something similar to model arbitrary, type systems so you can check what you want to. Finally, you can generate tests directly from contracts and runtime checks for combining with fuzzers taking one right to the failures. Is that standard practice among C developers like it has been in Eiffel for quite a while? Again, you must be working with some unusually-QA-focused developers.

                                                    “would not help at all with problem with overheating console “

                                                    First part of my comment was about general case. Second paragraph said exactly what you just asked me. Did you read it?

                                                    “Even it was an interesting paper (which imo it is not) it’s impossible to try and replicate it independently.”

                                                    The fact that it used evidence at all would put it ahead of many programming resources that are more like opinion pieces. Good news is you don’t have to replicate it: you can create a better study that tries same method against same criteria. Then, replicate that. If that’s the kind of thing you want to do.

                                                    1. 1

                                                      I mean, every study done on formal specifications said developers found them helpful. Do you and most developers you see use them?

                                                      Academic studies show one thing, while practitioners for unknown reasons do not adopt practices recommended by academics. Maybe, the studies are somehow flawed. Maybe the gains recommended in studies don’t have good roi for most of gamedev industry?

                                                      What it says is that DbC fits the requirements of game developers. Most formal methods don’t. It also helped find errors quickly. It’s not mere assertions in the common way they’re used

                                                      The study was using “mere assertions in the common way they’re used” so I don’t know what is the point of rest of that paragraph - techniques you mention there are not even mentioned in that paper so there is no proof of their applicability to gamedev.

                                                      First part of my comment was about general case. Second paragraph said exactly what you just asked me.

                                                      I asked you about your recommendations for gamedevs not about some unconstrained general case and just pointed out that your particular recommendation would not help in case from the story - nothing more :)

                                                      Did you read it?

                                                      Sure I have, but to make it easier in future try to make your posts more succinct ;)

                                                      1. 1

                                                        Academic studies show one thing, while practitioners for unknown reasons do not adopt practices recommended by academics.

                                                        I agree in the general case. Except that most practitioners trying some of these methods get good results. Then, most other practitioners ignore them. Like CompSci has it’s irrelevant stuff, the practitioners have their own cultures of chasing some things that work and some that don’t. However, DbC was deployed to industrial practice via Eiffel and EiffelStudio. The assertions that are a subset of it have obvious value. SPARK used them for proving absence of errors. Now, Ada 2012 programmers are using it as I described with contract-based testing. Lots of people are also praising property-based testing and fuzzing based on real bugs they’re finding.

                                                        So, this isn’t just a CompSci recommendation or study: it’s a combo of techniques that each have lots of industrial evidence they work and supporters that work well together that also have low cost. With that, either mainstream programmers don’t know about them or they’re ignoring effective techniques despite evidence. The latter is all too common.

                                                        “I asked you about your recommendations for gamedevs not about some unconstrained general case”

                                                        What helps programming in general often helps them, too. That’s true in this case.

                                                        “Sure I have, but to make it easier in future try to make your posts more succinct ;)”

                                                        Oh another one of you… Haha.

                                                        1. 2

                                                          Lots of people are also praising property-based testing and fuzzing based on real bugs they’re finding.

                                                          Those techniques are not what I would call “formal specifications” any more than simplest unit tests are, but if you consider them as such, than…

                                                          either mainstream programmers don’t know about them or they’re ignoring effective techniques despite evidence. The latter is all too common.

                                                          … I have no studies to back this up, but my experience is different. DbC (as shown in that study you linked), property based and fuzzing based testing are techniques that are used by the working programmers. Not for all the code, and not all the time but they are used.

                                                          When I wrote about studies showing one thing and real life showing something opposite I was thinking about methods like promela, spin or coq.

                                                          1. 1

                                                            Makes more sense. I see where you’re going with Coq but Spin/Promela have lots of industrial success. Similar to TLA+ usage now. Found protocol or hardware errors easily that other methods missed. Check it out.

                                        1. 2

                                          Have there been some interesting developments since last time it was posted (apart from name change ;))?

                                          1. 8

                                            I know where the author is heading, but some browsers building with one compiler doesn’t strike me as a monoculutre. Not too long ago “everyone” (with few exceptions) using or programming for Linux was using GCC and glibc. Now people use clang, gcc and probably others (icc, etc.). So it’s more like things became a lot less of a monoculture and probably mostly for the effort of BSD and MacOS users and developers making sure that software doesn’t only work with GCC.

                                            Yes, it’s at least Mozilla and Chrome now using clang, but these are neither the only browsers nor is big projects focusing mostly on a defined set of tools something very uncommon.

                                            It’s just a guess, but I also think that it will not suddenly become a huge undertaking to try to compile Firefox with another compiler. For the Rust parts maybe, but it’s already like that.

                                            Not to say it’s a good thing, but there of course are up- and downsides. Especially for such a big project and especially for a project already using said implementation, helping to develop it it makes a lot more sense than in various other cases where you often only have one supported version of GCC. People using source based approaches to install packages probably know this. Compiling some version of some compilers, maybe taking hours just to compile a little piece of software that absolutely requires it.

                                            Other than that, even if Mozilla now uses one compiler over different platforms I hope they won’t start “ruling out” compilation with other compilers or rejecting a few lines of code to keep or establish compatibility. At least from the article it sounds like that would be the case.

                                            1. 10

                                              It makes me really appreciate the projects that require only a c89/c99 compliant compiler, like sqlite and lua. Admittedly their dependencies are also minimal, only require the c standard library iirc, but it sure is nice.

                                              1. 5

                                                I know where the author is heading, but some browsers building with one compiler doesn’t strike me as a monoculutre.

                                                So, even for a “toy” project, we used to build again:

                                                • MSVC on Windows 7, x32, x64
                                                • GCC on Linux, x32, x64, Itanium
                                                • Clang on Linux (iirc), x32, x64
                                                • GCC on Irix, MIPS

                                                And we would’ve built on an Alpha if we had one lying around–helps reveal the really thorny issues.

                                                The thing is, not using multiple compilers (and architectures!) helps hide bugs.

                                                1. 1

                                                  Completely agree, but it’s still not unusual for projects to use one compiler for their official releases.

                                                2. 2

                                                  It’s just a guess, but I also think that it will not suddenly become a huge undertaking to try to compile Firefox with another compiler.

                                                  Suddenly? No, but I’m afraid that sooner or later having both clang and rust will become required for any platform that wants to ship firefox. Which is a shame, since Mozilla mission is:

                                                  Our mission is to ensure the Internet is a global public resource, open and accessible to all.

                                                  1. 1

                                                    Suddenly? No, but I’m afraid that sooner or later having both clang and rust will become required for any platform that wants to ship firefox. Which is a shame, since Mozilla mission is:

                                                    That’s already the case. Stylo needs clang to build. You can build some parts with GCC though.

                                                    1. 1

                                                      Clang and rust are both open projects, so I don’t see how it conflicts with their mission.

                                                      1. 1

                                                        I agree. Sadly the browser already without this has very big difference in platform support, even without that. For example WebRTC (the multimedia part), sandboxing capabilities, etc. But then of course supporting that on many platforms isn’t easy. Would be great of course, if that mission lead to a focus on not only supporting Windows, Linux and MacOS.

                                                        Maybe someone has more insights, but something that makes me wonder a lot about how things work internally at Mozilla is that there is quite a few bug reports with ready to integrate patches remaining unanswered for often years, yet there is often changes that completely surprise users, some of them being very far away from Mozilla’s stated mission.

                                                        While I get that not all the people working for Mozilla work in all areas it seems a bit like on the “accepting and integrating contributions” side of things there is a problem. As a foundation asking for monetary contribution it’s often a bad sign when contribution in form of work gets not taken care of. I hope Mozilla can fix this, so contributors don’t get too frustrated.

                                                      2. 0

                                                        So it’s more like things became a lot less of a monoculture and probably mostly for the effort of BSD and MacOS users and developers making sure that software doesn’t only work with GCC.

                                                        Not to belittle works of BSD people, a lot of Clang portability work was done by Debian before BSD decided on Clang. https://clang.debian.net/ goes back to Clang 2.9.

                                                        1. 3

                                                          FreeBSD initially imported Clang at revision r72732 into the tree June 2nd 2009:

                                                          https://svnweb.freebsd.org/base?view=revision&revision=193323 https://llvm.org/viewvc/llvm-project/?pathrev=72732

                                                          This was long before FreeBSD 9.0-RELEASE (January 2012).

                                                          The public documentation of the effort starts back in Feburary of 2009:

                                                          https://wiki.freebsd.org/action/recall/BuildingFreeBSDWithClang?action=recall&rev=2

                                                          As of June 2009, Clang was at version 2.5. Version 2.6 didn’t happen until October 2009.

                                                          http://lists.llvm.org/pipermail/llvm-announce/2009-March/000031.html http://lists.llvm.org/pipermail/llvm-announce/2009-October/000033.html

                                                          So this means the devs were working with the devel/llvm-devel FreeBSD port, which would have been based on HEAD or slightly newer than Clang 2.4.

                                                          https://docs.freebsd.org/cgi/getmsg.cgi?fetch=512205+0+/usr/local/www/mailindex/archive/2009/cvs-ports/20090222.cvs-ports

                                                          So I’m not sure that I believe the story that Debian was that invested in LLVM/Clang before FreeBSD was. There was no reason to; the Linux kernel had so many GCC-isms to overcome, what would be the gain? (other than some faster compiling of packages but poorer performing binaries)

                                                          edit: FreeBSD was trying to build all of the ports collection with Clang around May 2010. This still predates Debian by over a year

                                                          https://wiki.freebsd.org/action/recall/PortsAndClang?action=recall&rev=1

                                                          1. 1

                                                            Okay, wrong perspective then. From my angle I saw how tons of projects got pull requests, patches, etc. so they’d work with clang.

                                                            Do you have any background on why the Debian clang community even popped up early? I’d have considered them to be be philosophically closer to sticking to GCC (other than for where it’s necessary).

                                                            Also saw that Wikipedia actually does have a nice timeline. However it doesn’t mention where Debian starts only where it “finishes”: https://en.wikipedia.org/wiki/Clang#Status_history

                                                            1. 3

                                                              Do you have any background on why the Debian clang community even popped up early?

                                                              Debian is so large that it has a lot of (pardon me) crazy people. As an evidence, I submit the existence of Debian GNU/kFreeBSD.

                                                        1. 1

                                                          If I read this correctly, it seems like the reason for it is mostly Rust usage. Is that correct?

                                                          1. 3

                                                            Yes, clang and rustc both use llvm - this should allow for LTO across both types of object files.

                                                          1. 2

                                                            There is nice a Racket dsl just that (paper).

                                                            1. 6

                                                              Much simpler solution that often might be enough is xxd -i.

                                                              1. 4

                                                                Author of koio here.

                                                                objcopy is another simpler, good choice. I need koio to provide a stdio-like API and a consistent external baseline for how embedding files is done in chopsui so that it can be consistent between chopsui, third-party chopsui libraries, chopsui applications, and end-user extensibility. To that end I found it more appropriate to write a tool like this.

                                                              1. 3

                                                                For a good laugh, look here at this PR.

                                                                1. 17

                                                                  It’s both easier and more polite to ignore someone you think is being weird in a harmless way. Pointing and laughing at a person/community is the start of brigading. Lobsters isn’t big enough to be competent at this kind of evil, but it’s still a bad thing to try.

                                                                  1. 6

                                                                    https://github.com/tootsuite/mastodon/pull/7391#issuecomment-389261480

                                                                    What other project has its lead calmly explaining the difference between horse_ebooks and actual horses to clarify a pull request?

                                                                    1. 3

                                                                      And yet, he manages to offend someone.

                                                                      1. 4

                                                                        Can someone explain the controversy here? I legitimately do not understand. Is the individual claiming to be a computer and a person? Or do they just believe that someday some people will be computers and desire to future-proof the messages (as it alluded to in another comment)?

                                                                        1. 7

                                                                          This person is claiming they think of themselves as a robot, and is insulted at the insinuation that robots are not people.

                                                                          Posts like this remind me of just how strange things can get when you connect most of the people on the planet.

                                                                          1. 6

                                                                            So, I tried contacting the author:

                                                                            http://mynameiser.in/post/174391127526/hi-my-name-is-jordi-im-also

                                                                            Looks like she believes she’s a robot in the transhumanist sense. I thought transhumanists thought they would be robots some day, not that they already are robots now.

                                                                            I tried reading through her toots as she suggested, but it was making me feel unhappy, because she herself seems very unhappy. She seems to be going through personal stuff like breaking up from a bad relationship or something.

                                                                            I still don’t understand what is going on and what exactly does she mean by saying she’s a robot. Whatever the reason, though, mocking her is counterproductive and all around a dick thing to do. Her request in the PR was denied, which I think is reasonable. So “no” was said to something, contrary to what zpojqwfejwfhiunz said elsewhere.

                                                                            1. 6

                                                                              As someone who’s loosely in touch with some of the transhumanist scene, her answer makes no sense and was honestly kind of flippant and rude to you.

                                                                              That said, it sounds like she’s been dealing with a lot of abuse lately from the fact that this Github thread went viral. I’m not surprised, because there are certain people who will jump on any opportunity to mock someone like her in an attempt to score points with people who share their politics. In this case she’s being used as a proxy to discredit the social justice movement, because that’s what she uses to justify her identity.

                                                                              Abuse is never okay and cases like this require some pretty heavy moderation so that they don’t spiral out of control. But they also require a pretty firm hand so that you don’t end up getting pulled into every crazy ideascape that the internet comes up with. If I was the moderator of this GitHub thread, I would have told her, “Whatever it is you’re trying to express when you say ‘I am a robot,’ the Mastodon [BOT] flag is not the right way to do it.” End of discussion, and if anyone comes around to try to harass her, use the moderator powers liberally so as not to veer off-topic.

                                                                              Then you could get into the actual meat of the discussion at hand, which was things like “If I have a bot that reposts my Twitter onto Mastodon, could that really be said to ‘not represent a person’? Maybe another wording would be better.”

                                                                              In the end she’s just a girl who likes to say she’s a robot on the internet. If that bugs you or confuses you, the nicest thing you can do is just take it like that and just ignore her.

                                                                              1. 8

                                                                                I don’t think she was rude to me. She’s just busy with other things and has no obligation to respond to every rando who asks her stuff. I’m thankful she answered me at all. It’s a bit of effort, however slight, to formulate a response for anyone.

                                                                                1. 3

                                                                                  I mean, I can kind of see where you’re coming from, but I’d still argue that starting with “You should develop your software in accordance to my unusual worldview”, followed by flippantly refusing to actually explain that worldview when politely asked, is at least not nice.

                                                                                  Regardless, that might justify a firm hand, but not harassment, because nothing justifies harassment.

                                                                                  1. 2

                                                                                    I see this point of view too. But I’m also just some rando on the internet. She doesn’t owe me anything, If someone needed to hear her reasons, that would have been the Mastodon devs. They handled it in a different way, and I think they handled it well, overall.

                                                                                    1. 1

                                                                                      I’m inclined to agree on that last point, though it’s hard to say for sure given all the deleted comments.

                                                                                      And I do hope she can work through whatever she’s going through.

                                                                              2. 4

                                                                                I don’t know, personally, anyone who identifies as a robot, but I do know a bunch of people who identify as cyborgs. Some of it’s transhumanist stuff – embedding sensors under the skin, that sort of thing. But much of it is reframing of stuff we don’t think of that way: artificial limbs, pacemakers, etc, but also reliance on smartphones, google glass or similar, and other devices.

                                                                                From that standpoint, robot doesn’t seem a stretch at all.

                                                                                That said, I agree that the feature wasn’t intended to be (and shouldn’t be) a badge. But someone did submit a PR to make the wording more neutral and inclusive, and that was accepted (#7507), and I think that’s a positive thing.

                                                                                1. 2

                                                                                  Actually, that rewording even seems clearer to me regardless of whether someone calls themself a robot or not. “Not a person” sounds a bit ambiguous; because you can totally mechanically turk any bot account at any time, or the account could be a mirror of a real person’s tweets or something.

                                                                                2. 1

                                                                                  That’s unfortunate. It’s always difficult to deal with these things. I, too, understood transhumanism to be more of a future thing, but apparently at least some people interpret it differently. Thanks for following up where I was too lazy!

                                                                                3. -6

                                                                                  American ‘snowflake’ phenomenon. The offendee believes that the rest of the world must fully and immediately capitulate to whatever pronoun they decided to apply to themselves that week, and anything other than complete and unquestioning deference is blatant whatever-ism.

                                                                                  1. 16

                                                                                    Person in question is Brazilian, but don’t let easily checked facts get in the way of your narrative.

                                                                                    1. -5

                                                                                      Thanks for the clarification. Ugh, the phenomenon is spreading. I hope it’s not contagious. Should we shut down Madagascar? :-D

                                                                                      1. 3

                                                                                        TBH I think it’s just what happens when you connect a lot of people who speak your language to the internet, and the USA had more people connected than elsewhere.

                                                                                        1. 0

                                                                                          It definitely takes a lot of people to make a world. To paraphrase Garcia, “what a long strange trip it will be”.

                                                                                    2. 3

                                                                                      She says “she” is a fine pronoun for her.

                                                                                4. 1

                                                                                  It’s wonderful. :)

                                                                                5. 3

                                                                                  What is happening there? I can’t tell if this is satire or reality

                                                                                  1. 2

                                                                                    That’s pretty common with Mastodon; there’s an acrid effluence that tinges the air for hours after it leaves the room. That smell’s name? Never saying no to anyone.

                                                                                    1. 12

                                                                                      Seems “never saying no to anyone” has also been happening to lobster’s invite system :(

                                                                                      People here on lobsters used to post links to content they endorse and learn something from and want to share in a positive way. Whatever your motivation was to submit this story, it apparently wasn’t that…

                                                                                      1. 4

                                                                                        The person who shared the “good laugh” has been here twice as long as you have.

                                                                                        1. 1

                                                                                          I’m absolutely not saying you’re wrong, but I’m pretty confident there’s something to be learned here. I may not necessarily know what the lesson is yet, but this is not the first or the last situation of this kind to present itself in software development writ large.

                                                                                  1. 13

                                                                                    To be honest, this isn’t really lisp related - authors are just using sexp syntax to show region based memory management technique.

                                                                                    1. 3

                                                                                      Ok, I buy that. As I understand it, the majority of “tiny lisps” are not sufficient lisps. Should we drop the lisp tag?

                                                                                      See this comment. Is PicoLisp lisp-related?

                                                                                      1. 5

                                                                                        To me, proper Lisp needs to support repl, macros and treat function as first class values.

                                                                                    1. 8

                                                                                      I would be very interested to see how this compares with say Carp. I’m not knowledgeable in this space though so it might be universes apart.

                                                                                      1. 3

                                                                                        Despite having posted this myself, I’m interested in such a comparison, too. Though, I hadn’t heard of Carp until today. (That’s the right link, right? The author recommends RabbitVM instead.)

                                                                                        So, I’d like to see a comparison to PicoLisp.

                                                                                        1. 7
                                                                                          1. 5

                                                                                            PicoLisp has a single data type internally, and as a result doesn’t do anything fancy in terms of garbage collection (there’s no real avenue for heap fragmentation). As such it’s just a mark-sweep collector.

                                                                                            newlisp does do something more fancy, Automatic Memory Management in newLISP, which is similar in nature to what Interim does, and what Rust does as well, albeit in a completely different way.

                                                                                            newLISP follows a one reference only (ORO) rule. Every memory object not referenced by a symbol is obsolete once newLISP reaches a higher evaluation level during expression evaluation. Objects in newLISP (excluding symbols and contexts) are passed by value copy to other user-defined functions. As a result, each newLISP object only requires one reference.

                                                                                            1. 1

                                                                                              newLISP memory management in practice felt like Tcl to me, and not in a good way. The details are different, but you end up doing similar kluges, where you pass a handle to data that must be manually GC’d if you need to pass large stuff around/mutate data. That’s radically different from what Rust does, both in broad strokes and in the details.

                                                                                              [Edit: accidentally wrote PicoLisp the first time I drafted this comment.]

                                                                                              1. 1

                                                                                                Yes, Rust is undoubtedly better in practice, though far more complicated to learn, and implement (from a compiler standpoint). A couple of hacks here and there and you get “arena-like” allocation properties, and it’s easy to implement? Yeah, seems like a good trade off for small, embeddable languages, to me.

                                                                                            2. 3

                                                                                              Oops! There’s some naming conflict there. I’m the author of the Carp and Rabbit you mentioned, both of which are small learning projects. https://github.com/carp-lang/Carp is probably the Lisp you are looking for.

                                                                                          1. 2

                                                                                            The whole thing is great, but one idea that seems particularly useful in arbitrary languages without regard to how it fits with other features is to specify the list of globals used by a function. In Python-like syntax, imagine this:

                                                                                            def draw_quad(origin, left, up) [m]:
                                                                                                m.Position3fv(origin - left - up)
                                                                                                m.Position3fv(origin + left - up)
                                                                                                m.Position3fv(origin + left + up)
                                                                                                m.Position3fv(origin - left + up)
                                                                                            

                                                                                            Now you get a guarantee that the function uses zero globals besides m.

                                                                                            1. 4

                                                                                              In PHP you have something like that, global variables are not accesible from inside functions unless you specifically allow each one you want

                                                                                              $m = new M();
                                                                                              function draw_quad($orgin, $left, $up){
                                                                                                  global $m; // or $m = $_GLOBALS['m'];
                                                                                                  $m->Position3fv($origin - $left -$up);
                                                                                                  $m->Position3fv($origin + $left - $up);
                                                                                                  $m->Position3fv($origin + $left + $up);
                                                                                                  $m->Position3fv($origin - $left + $up);
                                                                                              

                                                                                              in practice, I haven’t found useful global variables other then the contextual ones ($_POST. $_GET, $_SESSION), which are superglobal and always defined

                                                                                              1. 2

                                                                                                I’d like to see something similar but generalised to “contextual” environmental bindings, rather than traditional global vars. And a compiler that ensures that somewhere in all call chains the binding exists. But you might want a global in some cases, or a “threadlocal”, or an “import” of some sort, or something like the context in react, etc.

                                                                                                Some mechanism in which the compiler makes sure the environmental dependencies are fulfilled, without necessarily requiring that value be propagated explicitly through each owner/container between provider and consumer.

                                                                                                1. 4

                                                                                                  I can’t find it but Scala has an extra context var that is passed with function invocation.

                                                                                                  And early Lisps had dynamic scope, meaning that a var bound to the next occurrence up the call stack.

                                                                                                  Both of these mechanisms supply the building blocks for AoP, so that a programmer can mixin orthogonal properties.

                                                                                                  1. 3

                                                                                                    And early Lisps had dynamic scope, meaning that a var bound to the next occurrence up the call stack.

                                                                                                    Today they still have it - see DEFVAR and DEFPARAMETER in Common Lisp.

                                                                                                    1. 2

                                                                                                      I can’t find it but Scala has an extra context var that is passed with function invocation.

                                                                                                      In Scala you can use implicit parameters for this:

                                                                                                      def foo(origin: Vec3, left: Vec3, up: Vec3)(implicit m: Context) {
                                                                                                          m.Position3fv(origin - left - up)
                                                                                                          m.Position3fv(origin + left - up)
                                                                                                          m.Position3fv(origin + left + up)
                                                                                                          m.Position3fv(origin - left + up)
                                                                                                      }
                                                                                                      

                                                                                                      In Haskell you could use a reader/writer/state monad thingy. In Koka or Eff you could use effects.

                                                                                                      1. 2

                                                                                                        Yeah, Scala’s context is probably closest to what I’m thinking of, from what I know of it.

                                                                                                      2. 4

                                                                                                        You can kinda get this with effect types. Effect types let you label certain functions as using resource A or B, and then you can have a documentation mechanism for what dependencies are used, without passing stuff around.

                                                                                                        It can still get a bit heavy (at least it is in Purescript), but less so than dependency injection

                                                                                                      3. 1

                                                                                                        A compiler or analyzer should be able to tell you that just from what variables or expressions go into the function. A previously-declared global would be one of the arguments. Why do we need to declare it again in the function definition?

                                                                                                        1. 1

                                                                                                          See my final sentence. “Now you get a guarantee that the function uses zero globals besides m.” The program documents/communicates what it uses. The compiler ensures the documentation is always up to date.

                                                                                                          In my example, m is not one of the arguments. Because m is a global, lexically accessible anyway in the body of the function. There’s no redundancy here.

                                                                                                          1. 0

                                                                                                            I’m saying a compiler pass should be able to do the same thing without a language feature. I think it won’t be important to that many people. So, it will probably be optional. If optional, better as a compiler pass or static analysis than a language feature. It might also be an easy analysis.

                                                                                                            1. 3

                                                                                                              You’re missing the point. It’s a list of variables that the code can access anyway. What would a compiler gain by analyzing what globals the function accesses?

                                                                                                              There are many language features that help the compiler do its job. This isn’t one of them. The whole point is documentation.

                                                                                                              (Yes, you could support disabling the feature, using say syntax like [*]. C++ has this. Just bear in mind that compilers also don’t require code comments, and yet comments are often a good idea. SImilarly, even languages with type inference encourage documenting types in function headers.)

                                                                                                        2. 1

                                                                                                          What if the Position3fv method uses global variable n? You also need to specify that for draw_quad. This quickly blows up like checked exceptions in Java and people want shortcuts.

                                                                                                          1. 2

                                                                                                            The problem with checked exceptions is that they discourage people from using exceptions. But there’s no problem in discouraging people from using global variables.

                                                                                                            I don’t mean to imply that I want all code to state what it needs all the time. In general I’m a pretty liberal programmer. It just seems like a good idea to give people the option to create “checkable documentation” about what globals a piece of code requires.

                                                                                                        1. 4

                                                                                                          I don’t get what the problem is here - do a fork and move on? Call it VoidStar Linux or something? :)

                                                                                                          1. 15

                                                                                                            We would like to keep the name, Void is still a small distribution and just started to get a bit more known. I don’t think a fork would kill the project but it would be annoying and we would like to avoid (“Avoid Linux” would get my vote for a rename) it.

                                                                                                            1. 3

                                                                                                              I really like Void. I use it on my Media PC and it has a lot of cool stuff in it. It feels so minimalist and that’s really great.

                                                                                                              So long as you have control over the .com, losing the .eu would kinda suck but it feels more like an inconvenience than a killer issue. Thankfully there are lots of Github alternatives like BitBucket, Gitlab or even a self hosted solution like Gog or the self-host Gitlab.

                                                                                                              Thanks for all your work. I’m glad Void is out there and hope it continues to grow as a distro. Currently I only use Void and Gentoo .. probably because I can’t do anything the easy way. :-P

                                                                                                              1. 1

                                                                                                                We would like to keep the name

                                                                                                                Is this legal?

                                                                                                                1. 7

                                                                                                                  I don’t know. We just want to continue the project like we did for over a year now. But its becoming more challenging each month that goes by without any contact.

                                                                                                                  If he for some reason doesn’t agree with us continuing the project we can hard fork and rename. But because there is no contact we don’t know.

                                                                                                                  I would personally be happy to hear from him again and I hope he is fine.

                                                                                                            1. 17

                                                                                                              Gimp 2.10 is the release that stops dumping stuff into $HOME, so even if you don’t really care about the new features, it’s a worthwhile upgrade for this reason alone!

                                                                                                              1. 4

                                                                                                                Why is that so important to you?

                                                                                                                1. 18

                                                                                                                  It’s very impolite for programs to spam things into the $HOME directory without explicit permission.

                                                                                                                  1. 3

                                                                                                                    Yes, it’s extremely rude.

                                                                                                                    1. 0

                                                                                                                      Can’t decide whether this is sarcasm, but 😆

                                                                                                                    2. 2

                                                                                                                      I want to be able to do backups or blow away the cache without inspecting each and every .folder individually.

                                                                                                                    3. 4

                                                                                                                      Do you have a link to further information? “Ctrl+F HOME” in the release notes didn’t turn up anything relevant.

                                                                                                                      1. 2

                                                                                                                        It is mentioned here and here. Hope this helps!

                                                                                                                    1. -8

                                                                                                                      @bootandy What exactly is interesting here that you decided to share that with us?

                                                                                                                      1. 10

                                                                                                                        Why a service instead of a library?

                                                                                                                        1. 4

                                                                                                                          money

                                                                                                                          1. 1

                                                                                                                            If you want to spend money, use pdflib locally. A bit antique, but reliable and comes with Ruby bindings.

                                                                                                                          2. 2

                                                                                                                            Because developers should be compensated for their time, unless they’re in the business of charity.

                                                                                                                          1. 3

                                                                                                                            Any alternatives to reddit? Lobsters is nice, but it’s basically /r/programming: the website, which doesn’t include a lot of the other communities I browse on reddit (gaming, news, and memes). Has anyone tried 4chan?

                                                                                                                            1. 5

                                                                                                                              Has anyone tried 4chan?

                                                                                                                              4chan is ok if you’re into the Imageboard format and can stand (or even enjoy) being endlessly provoked, insulted and made fun of because of nothing. It’s an older format, it has different conventions, so it’s most certainty not an “alternative” to reddit (especially taking their distaste of the latter into account).

                                                                                                                              The main problem’s I encountered were a decreasing quality over time (as boards get more popular) and political, especially far-right, injection being thrown into unrelated discussion (slurs about Indians when talking about simple programming jobs were, and I guess still are, popular on 4/g/). Some other imageboards are better in these respects, but maybe it has changed since I haven’t really used 4chan since late 2015, although I still do like the idea in itself.

                                                                                                                              1. 1

                                                                                                                                It hasn’t changed. The Indian slur thing was in the last thread I saw in 2016.

                                                                                                                              2. 3

                                                                                                                                Gaming: Neogaf and Resetera.

                                                                                                                                1. 2

                                                                                                                                  I haven’t found anything, and I’ve been looking since web forums died, about 10 years ago.