1. 1

    I like that Rust’s HashMap talks almost immediately focuses on the hashing function used: https://doc.rust-lang.org/std/collections/struct.HashMap.html

    Performance-sensitive use cases should consider the hash function an important input to a hash table, and not just given. Hence this article isn’t about the hash map’s badness, but rather about the hash function itself.

    1. 1

      I didn’t know Rust’s default hash map was so advanced. I’m not sure I agree with using SipHash as the default, since it’s relatively uncommon for a hash map to be a DoS vulnerability, and they’re trading performance for resistance to that. (SipHash would be a bad choice in a (non-networked) game, for instance.)

      This paragraph is weird:

      The behavior resulting from such a logic error is not specified, but will not result in undefined behavior. This could include panics, incorrect results, aborts, memory leaks, and non-termination.

      Is that a typo, and means to say it will not panic etc.? Or is it that those bad effects are possible but are not considered undefined behavior?

      1. 2

        “Undefined behavior” has a specific meaning in Rust literature - it always refers to cases where a program performs operations which violate Rust’s correctness requirements, which the language says will result in undefined behaviour in that program.

        This paragraph in HashMap’s documentation attempts, perhaps unsuccessfully, to convey that your program will behave incorrectly and unpredictably in those cases, but only in ways which are “safe”[1] because they don’t invoke behaviour which is undefined by the language.

        I’ve written what I now realise is somewhat of a tome below, which explains this a bit more with some technical details on why this distinction is being made.

        The idea of the partition of Rust using unsafe is that the compiler prevents “safe Rust” code from using language operations if they can invoke said undefined behaviour[2]. Safe Rust need to be able to rely that it’s protected by Rust’s guarantees for safe code, which the operations allowed in unsafe can violate if used incorrectly. This also means that Rust imposes a contract upon authors of code in unsafe blocks, which are the boundary between safe and unsafe Rust code; they too must not allow safe Rust code to invoke undefined behaviour in unsafe regions.

        This means that code in safe Rust which has unspecified behaviour still cannot invoke Rust’s language level undefined behaviour. By extension, it means that this contract between authors of unsafe Rust and the language require them to defend against wild misuse and logic errors in safe traits like Eq[3] or Hash which are expected to comply by certain basic rules, similar to those of typeclass laws in e.g. Haskell. This is explicitly called out in the Rust language reference. It’s not permissible for your unsafe Rust code to allow even the worst of errors in safe code to allow things like stack or heap corruption, dangling references, or cause it to exhibit data races or violations of Rust’s ownership model.

        [1] As this paragraph implies, some surprising things are “safe” because the program state is well defined by the language - panics cause a defined abort or stack unwind, aborts cause the program to halt (which is a defined program state), memory leaks are a performance issue rather than a memory safety issue (see the famous “ballistic missile malloc” anecdote), and obviously, going into an infinite loop or returning incorrect values for safe types is defined behaviour. Integer overflow is also safe (surprising to C and C++ users in particular), because the behaviour is implementation defined, but specified, because the language only permits implementations to choose between either panicking or specifically having two’s-complement wraparound behaviour for integer overflow. This can still result in logic errors, but as discussed later, logic errors in safe code are explicitly defined to be safe.

        [2] Such restricted operations are typically useful operations which the language cannot prove are guaranteed to be sound in all cases - use of memory with uninitialised regions, executing functions across the FFI boundary, bit reinterpret casts (known as transmute in Rust jargon), reading or writing of mutable globals, accessing fields on unions, or dereferencing unsafe pointers. Misuse of these can either directly result in undefined behaviour, or can allow undefined behaviour to occur by violating Rust’s guarantees.

        [3] A clear logic error in Eq would be just returning random results always, because Eq specifies implementors must return the same result for multiple invocations with the same values. A more surprising logic error is failing to implement the Eq trait with the reflexive ((a == a) == true)[4], transitive ((a == b AND b == c) == (a == c)) and symmetric ((a == b) == (b == a)) properties, because Eq is the trait for total equality, which includes these propreties as a requirement, unlike PartialEq. An emergent logic error is one like HashMap’s documentation describes, where safely managed interior mutability through types like Cell or RefCell allow their implementations of Eq to violate the basic rule of equality producing the same results for the same pair of input values - because they defer their Eq implementation to the values they contain, which can change between invocations.

        [4] Rust’s builtin floating point types are defined to always be IEEE 754 compliant, and therefore do not implement Eq, because IEEE 754 values are not reflexive (because a == a is false if a is NaN). This has the effect that floating points can’t be used as keys in BTreeMap, or as values in BTreeSet; not that you should really want to do so.

        1. 1

          It is the second option - none of those listed effects are considered undefined behaviour in rust.

      1. 1

        Java is much older than Rust and carries backward compatibility weights. I am surprised it is not much slower.

        1. 2

          C++ is much older than java and I’d be surprised if it wasn’t in the same performance ballpark than Rust for optional. Old age is not an excuse for bad design.

          1. 5

            Are you sure it is bad design? Perhaps Java’s design just makes different trade-offs for performance (like consistency or lower mental model overhead or… I’m sure there could be many).

            1. 1

              I can confidently say that it isn’t for consistency or mental overhead when compared to c++‘s generic implementation. Else this mess wouldn’t exist: https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/function/package-summary.html and requiring fall back on external libs if you want more arguments, like https://projectreactor.io/docs/extra/3.2.0.M3/api/reactor/function/Consumer8.html

              1. 1

                I can confidently disagree, having seen the C++ standard library implementations of gcc, llvm, msvc, and a few others.

                1. 1

                  why would the stdlib implementation matters ? what matters is that as a C++ dev I can just do optional<int>, optional<float>, optional<std::string>, optional<whatever_type> while in Java I have to remember that I must use OptionalInt, OptionalLong, OptionalDouble, and Optional<T> for everything else.

                  Anecdotally, I find libc++‘s implementation (https://github.com/llvm/llvm-project/blob/main/libcxx/include/optional) fairly readable, outside of the necessary __uglification of headers (and when one takes into account all the various optimizations that it does that Java’s does not seem to do - if I read https://github.com/openjdk/jdk/blob/master/src/java.base/share/classes/java/util/Optional.java correctly, it means that Java’s Optional does not work with value types since it relies on value being nullable ? how is that remotely serious)

                  1. 1

                    What matters is that in rust I can do Option<NonZeroU32> and have a type with sizeof 4. C++ can’t do that - how is that remotely serious.

                    I hope this will help you see your replies in this thread in a different way :)

                    1. 1

                      ? Of course it can, boost::optional did this for e.g. storing optional<T&> in a pointer for years. Sure, it’s a bit of work to specialize std::optional for your NonZero type but there’s nothing technically impossible

                      1. 1

                        Not really. Sure, you could maybe handcode specializations for a few selected types? Maybe? It’s not a trivial template. But even then this only handles some explicit/short list of types. In rust this is automatic for any type with ‘spare’ bits and works recursively (https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=004c4172a53ba7ab00fc7afb5e3adceb).

                        Also, since two posts before you complained about java needing external libs then don’t use boost as an excuse for c++ standard libs ;)

                    2. 1

                      If you were implementing your own generic libraries instead of just consuming them, then your view might be different.

                      For the language designers, both viewpoints are important.

                      1. 1

                        Having had to do this in Java, C# and admittedly mostly) C++, I really prefer the C++ way, especially nowadays with concepts.

                        1. 1

                          Concepts help, but they are quite recent. Also, C++ has objectively quite a few more footguns than the other languages, despite individual preferences.

              2. 3

                Java has a huge boat-anchor, the JVM. It’s stuck with a bytecode instruction set, binary format, and runtime model designed in the mid-1990s before the language had even seen serious use. There have been minor changes, like clarifying the memory concurrency model, but AFAIK no serious breaking changes.

                This makes some improvements, like stack-based objects, either impossible, or achievable only with heroic effort by the JIT and only in limited circumstances. (See also: the performance limitations of Java generics due to the requirement of type-erasure.)

            1. 2

              I wonder if you could diff two ASTs easily by converting them to a gron-like representation: a list of (path, node) pairs. Unlike text, there are no parens/braces to mess up. And unlike(?) a tree, it would be easy(?) to tell when a subtree moved, because it looks just like a chunk of lines that moved.

              1. 4

                If you mean what I think you mean, it wouldn’t work well. For example, say you take the example from the gron page:

                json[0].commit.author = {};
                json[0].commit.author.date = "2016-07-02T10:51:21Z";
                json[0].commit.author.email = "mail@tomnomnom.com";
                json[0].commit.author.name = "Tom Hudson";
                

                and wrap the commit in a… commitGroup or something:

                json[0].commitGroup[0].commit.author = {};
                json[0].commitGroup[0].commit.author.date = "2016-07-02T10:51:21Z";
                json[0].commitGroup[0].commit.author.email = "mail@tomnomnom.com";
                json[0].commitGroup[0].commit.author.name = "Tom Hudson";
                

                Then the tree diff should be a single edit: “insert commitGroup as a parent of commit”, but the gron-diff shows that every line changed.

                My understanding is that computing tree diffs is, unfortunately, just plain-out computationally difficult. Cubic time in the size of the tree or something.

                1. 3
                  1. 2

                    Nope! I’m glad that exists, hopefully structured diffs are the future!

                    You’ll notice that the first listed known problem is “performance”. I remember talking to a Github employee at a conference years ago about structured diffs, who said that was a big obstacle and they had ideas for clever heuristics to make it faster. I wonder if that ever went anywhere (for all I know it could be related to difftastic).

                    (As an aside, I really love when a project points out both their strengths and weaknesses… you know it has some weak points, so it’s a question of whether they’re going to tell you or you have to find out the hard way.)

              1. 3

                Very nice introduction to criterion. One thing worth mentioning is that you don’t have to create fake binary to avoid profiling criterion logic. You can use --profile-time to run existing benchmark for some time without involving analysis done by criterion.

                1. 7

                  Has anyone submitted anything in the past? What’s the most comfortable framework for making games in Lisp/Scheme/etc? I ask as a curious person who is looking for a hygienic framework for creating games in. My issue is finding something that’s easy to cross-compile for other platforms (eg. I use Linux, but would want to compile for Windows friends). I have been mulling over Lua/love2d for a while but never committed since I would prefer a Lisp environment.

                  1. 13

                    You might like https://fennel-lang.org/

                    1. 15

                      I have participated in every one since 2018 using Fennel. The easiest way to get started IMO is using TIC-80 which has built-in support for Fennel and lets you publish your games to play in the browser, so no downloads are required: https://tic80.com

                      Targeting love2d is another popular choice tho. It’s a lot more complex than TIC-80 but it also offers a lot more flexibility: https://love2d.org It’s harder to get love2d games to run in the browser but still really easy to cross-compile from Linux to Windows.

                      (disclaimer: Fennel lead developer here)

                      1. 4

                        There’s even a starter kit for Love2D and Fennel

                        https://gitlab.com/alexjgriffith/min-love2d-fennel

                    2. 7

                      Hello, jam organizer here. There have been lots of submissions from a variety of different Lisps in the past. You can check out the past jams on our wiki. Fennel seems to be a popular choice each jam, but I can’t say much more than that, as I am a diehard Common Lisp user :) For Common Lisp, there are a lot of partial solutions, as most people seem to be focused on building extremely general game engines rather than focused engines for a particular game/genre. This is expected in a way, as Common Lisp is extrememly performant, and there is no reason we need to be confined to C++ etc with Unity/Unreal/Godot…it just isn’t there yet though. I have been working towards that for a good 10 years now…but nothing worth announcing yet…anyway have fun regardless of which dialect you decide on!

                      1. 1

                        Thank you! I appreciate the insight. I have indeed looked at Godot in the past but felt it was too much for me to take on. I definitely want to try something out in Common Lisp, so the wiki you linked looks like a great place for me to start doing some research. Thank you for organizing this event!

                      2. 5

                        For 2D in Common Lisp, popular choices are Sketch and trivial-gamekit (apologies for self-plug). I, as an author of the latter framework, use travis/appveyor/github actions CI solutions to make builds for different platforms. If there would be any interest, I probably can arrange github action for building gamekit-based stuff for Linux and Windows. But otherwise, there exist examples for how to do that with travis and appveyor.

                        1. 4

                          Thank you! I don’t mind the self-plug, in fact I’m more inclined to check out your project for responding to my question! I will totally look into your library to see how it works now!

                        2. 5

                          Perhaps you might like CHICKEN; it is straightforward to compile static binaries, and cross-compiling to Windows (mingw) from Linux is also supported. There’s hypergiant, a game development toolkit, and on IRC you’ll find a few people interested in game writing too. In CHICKEN 4 we used to have a love2d-inspired framework called doodle, which shouldn’t be too hard to port to CHICKEN 5.

                          1. 2

                            I have been doing a bit of practice with Chicken and trying to get familiar with that environment. The cross-compiling is very appealing to me and I was actively looking at hypergiant. I might have to give that another shot!

                        1. 18

                          The whole damn thing.

                          Instead of having this Frankenstein’s monster of different OSs and different programming languages and browsers that are OSs and OSs that are browsers, just have one thing.

                          There is one language. There is one modular OS written in this language. You can hot-fix the code. Bits and pieces are stripped out for lower powered machines. Someone who knows security has designed this thing to be secure.

                          The same code can run on your local machine, or on someone else’s machine. A website is just a document on someone else’s machine. It can run scripts on their machine or yours. Except on your machine they can’t run unless you let them and they can’t do I/O unless you let them.

                          There is one email protocol. Email addresses can’t be spoofed. If someone doesn’t like getting an email from you, they can charge you a dollar for it.

                          There is one IM protocol. It’s used by computers including cellphones.

                          There is one teleconferencing protocol.

                          There is one document format. Plain text with simple markup for formatting, alignment, links and images. It looks a lot like Markdown, probably.

                          Every GUI program is a CLI program underneath and can be scripted.

                          (Some of this was inspired by legends of what LISP can do.)

                          1. 24

                            Goodness, no - are you INSANE? Technological monocultures are one of the greatest non-ecological threats to the human race!

                            1. 1

                              I need some elaboration here. Why would it be a threat to have everyone use the same OS and the same programming language and the same communications protocols?

                              1. 6

                                One vulnerability to rule them all.

                                1. 2

                                  Pithy as that sounds, it is not convincing for me.

                                  Having many different systems and languages in order to have security by obscurity by having many different vulnerabilities does not sound like a good idea.

                                  I would hope a proper inclusion of security principles while designing an OS/language would be a better way to go.

                                  1. 4

                                    It is not security through obscurity, it is security through diversity, which is a very different thing. Security through obscurity says that you may have vulnerabilities but you’ve tried to hide them so an attacker can’t exploit them because they don’t know about them. This works as well as your secrecy mechanism. It is generally considered bad because information disclosure vulnerabilities are the hardest to fix and they are the root of your security in a system that depends on obscurity.

                                    Security through diversity, in contrast, says that you may have vulnerabilities but they won’t affect your entire fleet. You can build reliable systems on top of this. For example, the Verisign-run DNS roots use a mixture of FreeBSD and Linux and a mixture of bind, unbound, and their own in-house DNS server. If you find a Linux vulnerability, you can take out half of the machines, but the other half will still work (just slower). Similarly, a FreeBSD vulnerability can take out half of them. A bind or unbound vulnerability will take out a third of them. A bind vulnerability that depends on something OS-specific will take out about a sixth.

                                    This is really important when it comes to self-propagating malware. Back in the XP days, there were several worms that would compromise every Windows machine on the local network. I recall doing a fresh install of Windows XP and connecting it to the university network to install Windows update: it was compromised before it was able to download the fix for the vulnerability that the worm was exploiting. If we’d only had XP machines on the network, getting out of that would have been very difficult. Because we had a load of Linux machines and Macs, we were able to download the latest roll-up fix for Windows, burn it to a CD, redo the install, and then do an offline update.

                                    Looking at the growing Linux / Docker monoculture today, I wonder how much damage a motivated individual with a Linux remote arbitrary-code execution vulnerability could do.

                                    1. 1

                                      Sure, but is this an intentional strategy? Did we set out to have Windows and Mac and Linux in order that we could prevent viruses from spreading? It’s an accidental observation and not a really compelling one.

                                      I’ve pointed out my thinking in this part of the thread https://lobste.rs/s/sdum3p/if_you_could_rewrite_anything_from#c_ennbfs

                                      In short, there must be more principled ways of securing our computers than hoping multiple green field implementations of the same application have different sets of bugs.

                                    2. 3

                                      A few examples come to mine though—heartbleed (which affected anyone using OpenSSL) and Specter (anyone using the x86 platform). Also, Microsoft Windows for years had plenty of critical exploits because it had well over 90% of the desktop market.

                                      You might also want to look up the impending doom of bananas, because over 90% of bananas sold today are genetic clones (it’s basically one plant) and there’s a fungus threatening to kill the banana market. A monoculture is a bad idea.

                                      1. 1

                                        Yes, for humans (and other living things) the idea of immunity through obscurity (to coin a phrase) is evolutionarily advantageous. Our varied responses to COVID is one such immediate example. It does have the drawback that it makes it harder to develop therapies since we see population specificity in responses.

                                        I don’t buy that the we need to employ the same idea in an engineered system. It’s a convenient back-ported bullet list advantage of having a chaotic mess of OSes and programming languages, but it certainly wasn’t intentional.

                                        I’d rather have an engineered, intentional robustness to the systems we build.

                                        1. 4

                                          To go in a slightly different direction—building codes. The farther north you go, the steeper roofs tend to get. In Sweden, one needs a steep roof to shed show buildup, but where I live (South Florida, just north of Cuba) building such a roof would be a waste of resources because we don’t have snow—we just need a shallow angle to shed rain water. Conversely, we don’t need codes to deal with earthquakes, nor does California need to deal with hurricanes. Yet it would be so much simpler to have a single building code in the US. I’m sure there are plenty of people who would love to force such a thing everywhere if only to make their lives easier (or for rent-seeking purposes).

                                          1. 2

                                            We have different houses for different environments, and we have different programs for different use cases. This does not mean we need different programing languages.

                                      2. 2

                                        I would hope a proper inclusion of security principles while designing an OS/language would be a better way to go.

                                        In principle, yeah. But even the best security engineers are human and prone to fail.

                                        If every deployment was the same version of the same software, then attackers could find an exploitable bug and exploit it across every single system.

                                        Would you like to drive in a car where every single engine blows up, killing all inside the car? If all cars are the same, they’ll all explode. We’d eventually move back to horse and buggy. ;-) Having a variety of cars helps mitigate issues other cars have–while still having problems of its own.

                                        1. 1

                                          In this heterogeneous system we have more bugs (assuming the same rate of bugs everywhere) and fewer reports (since there are fewer users per system) and a more drawn out deployment of fixes. I don’t think this is better.

                                          1. 1

                                            Sure, you’d have more bugs. But the bugs would (hopefully) be in different, distinct places. One car might blow up, another might just blow a tire.

                                            From an attacker’s perspective, if everyone drives the same car, it the attacker knows that the flaws from one car are reproducible with 100% success rate, then the attacker doesn’t need to spend time/resources of other cars. The attacker can just reuse and continue to rinse, reuse, recycle. All are vulnerable to the same bug. All can be exploited in the same manner reliably, time after another.

                                            1. 3

                                              To go by the car analogy, the bugs that would be uncovered by drivers rather than during the testing process would be rare ones, like, if I hit the gas pedal and brake at the same time it exposes a bug in the ECU that leads to total loss of power at any speed.

                                              I’d rather drive a car a million other drivers have been driving than drive a car that’s driven by 100 people. Because over a million drivers it’s much more likely someone hits the gas and brake at the same time and uncovers the bug which can then be fixed in one go.

                                2. 3
                                  1. 1

                                    Yes, that’s probably the LISP thing I was thinking of, thanks!

                                  2. 2

                                    I agree completely!

                                    We would need to put some safety measures in place, and there would have to be processes defined for how you go about suggesting/approving/adding/changing designs (that anyone can be a part of), but otherwise, it would be a boon for the human race. In two generations, we would all be experts in our computers and systems would interoperate with everything!

                                    There would be no need to learn new tools every X months. The UI would familiar to everyone, and any improvements would be forced to go through human testing/trials before being accepted, since it would be used by everyone! There would be continual advancements in every area of life. Time would be spent on improving the existing experience/tool, instead of recreating or fixing things.

                                    1. 2

                                      I would also like to rewrite most stuff from the ground up. But monocultures aren’t good. Orthogonality in basic building blocks is very important. And picking the right abstractions to avoid footguns. Some ideas, not necessarily the best ones:

                                      • proven correct microkernel written in rust (or similar borrow-checked language), something like L4
                                      • capability based OS
                                      • no TCP/HTTP monoculture in networks (SCTP? pubsub networks?)
                                      • are our current processor architectures anywhere near sane? could safe concurrency be encouraged at a hardware level?
                                      • less walled gardens and centralisation
                                      1. 2

                                        proven correct microkernel written in rust (or similar borrow-checked language), something like L4

                                        A solved problem. seL4, including support for capabilities.

                                        1. 5

                                          seL4 is proven correct by treating a lot of things as axioms and by presenting a programmer model that punts all of the difficult bits to get correct to application developers, making it almost impossible to write correct code on top of. It’s a fantastic demonstration of the state of modern proof tools, it’s a terrible example of a microkernel.

                                          1. 2

                                            FUD unless proven otherwise.

                                            Counter-examples exist; seL4 can definitely be used, as demonstrated by many successful uses.

                                            The seL4 foundation is getting a lot of high profile members.

                                            Furthermore, Genode, which is relatively easy to use, supports seL4 as a kernel.

                                      2. 2

                                        Someone wrote a detailed vision of rebuilding everything from scratch, if you’re interested. 1

                                          1. 11

                                            I never understood this thing.

                                            1. 7

                                              I think that is deliberate.

                                          2. 1

                                            And one leader to rule them all. No, thanks.

                                            1. 4

                                              Well, I was thinking of something even worse - design by committee, like for electrical stuff, but your idea sounds better.

                                            2. 1

                                              We already have this, dozens of them. All you need to do is point guns at everybody and make them use your favourite. What a terrible idea.

                                            1. 8

                                              This is more like 60 lines, not 30. This is 30 a tcp proxy in 30 lines (in Go): https://gist.github.com/tumdum/afc52f43c257e655f0071701740b8f60 ;)

                                              1. 2

                                                Exact line count doesn’t really matter here. Both solutions work roughly the same in principle, this Rust one uses about 30 lines to configure clap. Arguably both could use better error handling, but that is not the point here.

                                                1. 2

                                                  So what does matter here?

                                                  1. 3

                                                    The relative simplicity of it and the ease of extending this for local / debugging purposes.

                                                    1. 3

                                                      My point is that this post is imho pointless - it took me max 10 minutes to write equivalent Go version. It also doesn’t really tell us anything which is not written in the tokio docs. I’m pretty sure you can just as easily write equivalent code in most modern languages.

                                                      1. 1

                                                        Simple / easy is relative. See also https://xkcd.com/1053/. Having experience makes things look easy. But if you for instance know http a little but have no idea how the underlying bits and pieces work this can be very enlightening.

                                                        1. 2

                                                          Contrary to what you are trying to suggest I didn’t make fun of the author in anything I wrote. But I do try to show that this is low-value content that shouldn’t have been posted to this site - right now this is barely anything more than a hello world.

                                                          I mean, if you want to read this kind of beginners posts regularly be my guest - I’m pretty sure there are many other sites where beginners show their discoveries. I just think that lobsters is not a place for this kind of content.

                                                2. 2

                                                  To be fair, 30 of the rust lines are an absurdly verbose parser for 2 CLI arguments, unrelated to the TCP proxy. But you don’t have to hate rust to like golang – it’s not zero-sum.

                                                  1. 2

                                                    Who is hating rust? I like it almost as much as I like Go. In fact I consider myself lucky since I work in a pure rust codebase :)

                                                1. 5

                                                  Discussing a YAML equivalent with the creator (ex-colleague) and another colleague came up with this gem:

                                                  alias graml="yq eval -j | gron | sed 's/json/yaml/'"
                                                  
                                                  1. 3

                                                    Then there is my pull request that adds yaml support https://github.com/tomnomnom/gron/pull/74 :)

                                                    1. 2

                                                      Depending on which yq you’re using (the one in arch linux’s community repo is https://kislyuk.github.io/yq/), that alias may need to be:

                                                      alias graml="yq | gron | sed 's/json/yaml/'"
                                                      

                                                      Also, seems like you’d only want to replace the “json” only at the beginning of the line:

                                                      alias graml="yq | gron | sed 's/^json\./yaml./'"
                                                      
                                                    1. 5

                                                      this might be why there is std::make_shared, with std::make_shared() being equivalent to std::shared_ptr(new Widget).

                                                      This is, indeed, the rationale behind std::make_shared. As a side effect, it also gives you a single allocation for both the underlying object and the reference count, which means that it’s always more efficient (or, in the worst case, no less efficient) to call std::make_shared than operator new followed by std::shared_ptr’s constructor.

                                                      C++14 added std::make_unique. This wasn’t in C++11 because there’s no efficiency gain, but it allows you to have a coding convention such as the C++ Core Guidelines that tell you not to have a bare operator new in any code. This is generally a good idea: if you’re calling operator new anywhere outside of a smart pointer class, that’s a bad code smell in modern C++.

                                                      1. 2

                                                        it’s always more efficient (or, in the worst case, no less efficient) to call std::make_shared than operator new followed by std::shared_ptr’s constructor.

                                                        Using make_shared can be less efficient when you consider the fact that it’s impossible to free that memory until all instances of both shared_ptr and weak_ptr refer to it. You can end up in a situation when only weak pointers prevent deallocation and your applications memory usage is growing needlessly. Depending on the sizeof of type parameter of shared_ptr this could be a serious issue.

                                                        1. 2

                                                          make_unique is also no less efficient

                                                          There is also the case that make_unique<uint8_t> zero-initializes the buffer. Which is most of the time nothing but a performance bug nobody wants (and to be honest, quite surprising).

                                                          So yes, we’re still not done with all valid uses of operator new :-(

                                                          1. 2

                                                            That’s a good point. For those unfamiliar with how std::shared_ptr works:

                                                            It allocates a control structure that contains a strong and weak reference count and a pointer to the real object. Strong references are owned by std::shared_ptr instances, weak references by std::weak_ptr. Weak references can only be created if you hold a strong reference. You cannot use a weak_ptr directly, you must convert it to a shared_ptr first. When the last strong reference (shared_ptr) goes away, it can delete the underlying object but keep the control structure around. When a weak_ptr is then accessed, it decrements the weak reference count and nulls out its reference to the control structure. When all weak_ptrs have gone away, the control structure is deallocated.

                                                            When you use std::make_shared, the control structure and the object are in the same allocation. When the last shared_ptr goes away, the object’s destructor will be run, but the memory won’t be reclaimed.

                                                            I’d largely forgotten about that, because I rarely use weak_ptr, but if you do then it’s an interesting omission in the standard: there’s no way of doing exception-safe allocation of an object with a separate shared pointer control block without writing your own allocation wrapper.

                                                        1. 1

                                                          One thing I find useful is to make sure that the hash map that I use is not deterministic - each time program is executed the order of iteration should be different, like for example the default rust hashmap.

                                                          1. 2

                                                            As somebody who is implementing a dynamically typed programming language, I don’t agree with the author. Generating high quality error messages is a lot of work regardless of what kind of language you are implementing. You don’t automatically get high quality errors in a statically typed language. High quality errors are not categorically impossible in a dynamically typed language (as claimed), it’s just an engineering problem. It looks to me that the GHC team has invested more effort in producing good errors than the Nix team, that is all.

                                                            1. 1

                                                              High quality errors are not categorically impossible in a dynamically typed language (as claimed), it’s just an engineering problem.

                                                              Engineering effort can certainly improve error messages in dynamically typed languages, resulting in high quality errors in certain cases. But I have trouble believing that dynamically typed languages can always produce an error as good as one from a statically typed language.

                                                              Consider how a dynamically typed language could possibly produce an error as useful as this hypothetical Nix static type error from the article:

                                                                  { option = [
                                                                      "max-jobs=5"
                                                                      "cores=4"
                                                                      enable "fallback"
                                                              #       ~~~~~~
                                                              #       This element of the list is not a string
                                                                    ];
                                                              

                                                              One of the article’s key points is the convenience of seeing where the error is in your actual code. How could dynamically-typed Nix provide that?

                                                              If it tracked function names better, its error message could have “enable” in place of “<λ>”, resulting in ‘generators.mkValueStringDefault: functions not supported: enable’. But that’s still not as useful as the above error. Knowing the unexpected function’s name is enable wouldn’t be much help if you had many instances of enable in the list, but you forgot to parenthesize only one of them.

                                                              An additional problem with that dynamic error message is that it says the error is within the function generators.mkValueStringDefault. The user’s code never explicitly called that function, so they might have to read their whole program to locate the problem. This could be mitigated by displaying the stack trace along with the error:

                                                              generators.mkValueStringDefault: functions not supported: enable
                                                              something.blah
                                                              something.foo
                                                              pkgs.lib.cli.toGNUCommandLine
                                                              something.processOptions
                                                              

                                                              But that still forces the user to scan the list until they find a function in their actual code, then read all parameters they pass to that function (and that’s assuming global state didn’t cause the error). The example static type error above skips those steps by highlighting the exact line the error was on.

                                                              Now, I could imagine some hybrid type system that doesn’t raise errors until a runtime problem is encountered, and then parses the source code to find all the values that contributed to the problematic value existing. That could be neat… but at that point the work has already been done to implement a static type system. At that point, it would be better make the language also do static type checking, allowing users to sometimes be notified of problems before they happen.

                                                              It looks to me that the GHC team has invested more effort in producing good errors than the Nix team, that is all.

                                                              Above I was describing how creators of a dynamically typed language could invest extra effort to replicate something the hypothetical statically typed language got almost for free. To get the type error “This element of the list is not a string”, the hypothetical static-typed-Nix team only had to annotate function return types. If that team tried to invest as much effort as the hypothetical dynamic-typed-Nix team, they might improve the type error further to this:

                                                                      enable "fallback"
                                                              #       ~~~~~~
                                                              #       This element of the list should be a string, but is a function.
                                                              #       
                                                              #       The formatting of your source code makes me think you might
                                                              #       have wanted this line to be a function call, like this:
                                                              #           (enable "fallback")
                                                              #       That would produce a string.
                                                              

                                                              Could you produce an error message like this with a dynamic type system?

                                                              1. 1

                                                                Racket is dynamically typed and this is how you can get similar error messages in it:

                                                                #lang racket
                                                                 
                                                                (module+ server
                                                                  (provide (contract-out [foo (-> (listof (and/c string? lower?)) number?)]))
                                                                  (define (lower? s) (sequence-andmap char-lower-case? s))
                                                                  (define (foo l) (length l)))
                                                                 
                                                                (module+ main
                                                                  (require (submod ".." server))
                                                                  (foo (list 'enabled "baz")))
                                                                

                                                                will produce:

                                                                foo: contract violation
                                                                  expected: string?
                                                                  given: 'enabled
                                                                  in: an and/c case of
                                                                      an element of
                                                                      the 1st argument of
                                                                      (-> (listof (and/c string? lower?)) number?)
                                                                  contract from: (/tmp/c.rkt server)
                                                                  blaming: (/tmp/c.rkt main)
                                                                   (assuming the contract is correct)
                                                                  at: /tmp/c.rkt:4.26
                                                                

                                                                In fact as you can see, Racket is able to enforce not only simple type level properties (is it a string?) but also much more interesting properties about values - does the list contain only lower case strings? (foo (list "baZ")) will produce:

                                                                foo: contract violation
                                                                  expected: lower?
                                                                  given: "baZ"
                                                                  in: an and/c case of
                                                                      an element of
                                                                      the 1st argument of
                                                                      (-> (listof (and/c string? lower?)) number?)
                                                                  contract from: (/tmp/c.rkt server)
                                                                  blaming: (/tmp/c.rkt main)
                                                                   (assuming the contract is correct)
                                                                  at: /tmp/c.rkt:4.26
                                                                
                                                                1. 1

                                                                  The error message in your first example is certainly more useful than error-checking in most dynamically typed languages. However, I think you missed the point of my comment, because that example doesn’t really address any of these problems that I noted Nix’s dynamically-typed message has and the statically-typed error message wouldn’t have:

                                                                  • Your example’s error message does show the incorrect value, “given: 'enabled”. But would this still work if the incorrect value were an anonymous function rather than a symbol? Or would Racket just say “given: <λ>” like the Nix example unhelpfully does?
                                                                  • Your example’s error message doesn’t include the stack trace at the point the incorrect value 'enabled was found. So if your example program used 'enabled correctly many times within the list but uses it wrongly once, you would have to manually scan all your program’s usages of it.
                                                                  • Even if Racket outputted the stack trace when 'enabled was found, that’s still not as helpful as knowing exactly where in your code 'enabled is written. By “exactly where”, I mean outputting a range of characters in the user’s source code, which is often rendered as an underline in an IDE. Your Racket example does include similar output with /tmp/c.rkt:4.26 in its last line, but this points to the contract that failed (library code), not to the code that broke the contract (the user’s code).

                                                                  In my previous comment, I showed why I thought the article was correct by explaining the above three ways that static type errors can give more relevant information than dynamic type errors.

                                                                  Regarding your second example, being able to assert things about run-time types can indeed catch errors that can’t be caught with static typing. I agree that this can be a useful feature. However, there’s no technical barrier to a statically-typed language supporting runtime-checked contracts as well. Assertions can usually be implemented as a library that throws an exception or returns an error type.

                                                                  I would guess that statically typed languages are less likely to have support for contracts in their standard libraries, due to static types covering some of their use cases. I acknowledge that this could be seen as a bad thing about statically typed languages if you want an ecosystem of programs that often make use of run-time contracts.

                                                              1. 4

                                                                I don’t think this is a good idea, nor actually needed.

                                                                First, the obvious failure mode. A “bad actor” can con their way onto the site via invite, post a comment that would violate most hosting providers AUP, and could then point to it being visible in the modlog as this site breaking that AUP, and getting the site in trouble. So even if most moderated comments could be visible, there’d still be “extra-banned” comments which would excite even more interest.

                                                                For those with a prurient interest in moderated or even deleted comments, it’s not hard to set up something that scans each submissions comments and keeps deleted ones (or tracks edits). Each submission page has a .json extension which gives a machine-readable view of that page. A couple of hours of hacking and a cronjob and it’s off to the races.

                                                                1. 3

                                                                  I would expect that 99,99% (if not more) of deleted comments is completely legal and can be displayed. The few that needs to be deleted can probably be removed via rails auto generated management api.

                                                                  Even if it is a real issue I still agree with op that showing removed comments would be a good improvement on transparency. So maybe during deletion mods should have an option to mark as removed or actually delete offending comment. This would solve illegal content issue but still improve transparency.

                                                                1. 8

                                                                  While I get the idea, I think all that would happen is that conversation would continue while referencing the dead/removed content. Lobste.rs does a really good job of keeping the conversations consistent, by for example preventing the editing of comments after a certain amount of time.

                                                                  IMHO if the content was removed unjustly, discussion in IRC or private communication with mods would probably be preferable. Lobste.rs isn’t the Orange Site, and I think a Backbone Cabal suits it well.

                                                                  1. 2

                                                                    I think all that would happen is that conversation would continue while referencing the dead/removed content

                                                                    I think that making it visible only in moderator log would be inconvenient enough to prevent that from happening.

                                                                    1. 3

                                                                      It could cause inconvenience for the operators in the current (cancel)cultural environment, eventually maybe even risking the site’s existence. It would pretty much undermine the purpose of moderation.

                                                                      1. 2

                                                                        What would you do with content which is illegal and could cause legal consequences?

                                                                        1. 1

                                                                          As far as I can tell this is not a real issue on this site.

                                                                          1. 3

                                                                            There was a link to the leaked WindowsXP, which was removed because of that reason.

                                                                            1. 2

                                                                              But it is a failure mode that can be exploited by a bad actor. I’ll expand on that in a top-level comment.

                                                                        2. 2

                                                                          We could possibly lock conversations on the removed content. It would only be visible.

                                                                        1. 7

                                                                          Interesting concept but I simply cannot relate with someone who seems to stop using things that quickly.

                                                                          I have 1 active belt and that lasts me years.

                                                                          If a T-shirt starts breaking, I fix it until it is not usable in public then it becomes a work shirt (gardening, moving, etc.), a training shirt or part of pajama attire.

                                                                          I believe that’s how you get the most out of clothes, not buying expensive branded stuff and calculating the “per wear cost” when you could repurpose them until they become unfixable.

                                                                          1. 1

                                                                            At least it seems that he is donating instead of throwing out “old” clothes.

                                                                          1. 28

                                                                            Any of y’all want me to throw my hat in the ring?

                                                                            Another time. :)

                                                                            Okay fisch. I’ll try. If enough folks are interested I’ll shoot an app in.

                                                                            1. 41

                                                                              friendlysock is pretty much the only user who I have mentally flagged as consistently antagonistic and obnoxious, generally to the detriment of friendly and civil discussion. Other users may have particular topics which they feel sufficiently strongly about that they occasionally get a little antagonistic responding to criticism. With friendlysock, I see unnecessarily inflammatory comments often enough that I now mentally think, “ugh, I won’t bother reading this comment chain, it looks like another friendlysock spat”. If you can’t moderate your own comments, I don’t think you’d be good at moderating other peoples.

                                                                              So if you really want our opinions, no, I do not want you to throw your hat into the ring.

                                                                              1. 25

                                                                                Strong disagree. friendlysock consistently engages in civil and friendly discussion, even when finding himself on the other side of an argument with someone whose political convictions make them feel they shouldn’t even attempt to be civil and friendly. I’ve never seen him make a comment I think could fairly be called unnecessarily inflammatory (and I say this as someone who has disagreed with him in the past). I generally enjoy seeing his posts and think he’s a good contributor to the site.

                                                                                1. 32

                                                                                  You’re painting a picture where angersock is the civil one who just so happens to be constantly surrounded by people mad at him.

                                                                                  That’s wrong: angersock frequently accuses others or entire communities of bad faith and assumes a position of authority he doesn’t have when saying content doesn’t belong here (do I even need to link that one?).

                                                                                  I’ve rarely seen anybody argue with angersock twice. That alone should be pretty damning: The only constant in arguments involving angersock is he himself.

                                                                                  One can be inflammatory, incite flamewars and toxic communication while saving face by “remaining civil”. I’m not sure how much of it was intended in /u/Thra11’s post, but to me the point is that angersock remains civil, but brings incivility.

                                                                                  That is not to say that he doesn’t try his best, and I don’t think he does any of this on purpose (though I am really not sure). But I really don’t think he is cut out for this job, and given the comment ratio on his top-post vs the rest of the thread, I think he would be quite a controversial mod to say the least.

                                                                                  1. 14

                                                                                    It’s also missing the point: One can be inflammatory, incite flamewars and toxic communication while saving face by “remaining civil”.

                                                                                    That form of trolling is called Sea-lioning. http://wondermark.com/1k62/

                                                                                    1. 13

                                                                                      I strongly disagree that how friendlysock has been showing up here can be seen as a form of sealioning.

                                                                                      1. 8

                                                                                        It still blows my mind that not only do some people think the woman rather than the sea-lion was the sympathetic character in that comic, but that there are enough such people for “sea-lioning” to have become a meme.

                                                                                        1. 8

                                                                                          I suspect it’s because many people use public social media for private conversations with their friends (as they would speak while walking about town). A stranger injecting themselves into the conversation to demand your time and attention (regardless of how righteous they are) is unwanted and weird.

                                                                                          1. 5

                                                                                            It’s pretty fitting, I think. Most people who cry “sea lioning” are just upset that someone responded to their public statements.

                                                                                            1. 5

                                                                                              I was puzzled by that as well. There were enough of us that the author wrote a three paragraph clarification on the errata page. It’s possibly worth reading the explanation there. I’d summarize it as “the sea lion is a stand-in for people who behave a certain way and the woman’s objection is based on that behavior”.

                                                                                            2. 6

                                                                                              I only have this comic as reference for as to what sealioning means, but the situation I see with angersock is not one where he actively seeks out people to engage in stupid arguments with. Maybe the term has evolved beyond that specific example, but then, without a new real definition, it has lost its meaning.

                                                                                              1. 3

                                                                                                The term has not lost its meaning, it has always been used to refer to people who make unwelcomed responses to publicly made statements.

                                                                                            3. 9

                                                                                              My own interactions with ‘sock have actually been pretty good, even in cases where we disagreed (as in this thread), and I don’t off-hand recall seeing and recent(ish) comments where I was “sjeez ’sock, relax mate”.

                                                                                              But I also skip most Rust stories, as I don’t have a lot of interest in Rust (not at the moment anyway), and that link is indeed very much a “sjeez ’sock, relax mate” type of conversation.

                                                                                              Point being: I guess people have a limited/biased view of ’sock (or any other members, for that matter) based on which stories they read and comment on. I certainly do, because I never would have seen that comment if you had not linked it here.

                                                                                              1. 2

                                                                                                do I even need to link that one?

                                                                                                Would be helpful for people like me who aren’t as deep in the day-to-day of lobste.rs.

                                                                                                1. 4

                                                                                                  It appears lobste.rs has some sort of retention on the index of comments per user, but here’s the most recent examples (not the best ones):

                                                                                                  All of those assume a place of authority and tell others how to use the site.

                                                                                              2. 6

                                                                                                In all fairness, this was not always the case (see also why I’m friendlysock instead of angersock), and even as recently as that Rust thread a few days ago I can still be more inflammatory than is helpful (less charitably: I can be a shithead). I’m no saint.

                                                                                                1. 4

                                                                                                  and yet, gestures frantically below

                                                                                                2. 6

                                                                                                  I would have to concur with this

                                                                                                3. 34

                                                                                                  I personally would prefer not to have a moderator who thinks having Nazis participating is a fine idea (https://lobste.rs/s/nulfct/problem_with_code_conduct#c_dwa6s5). “You could exclude neither [Nazis nor the target of Nazis], and let them sort it out themselves elsewhere. Indeed, seeing each other in a context that doesn’t constantly reinforce their ideology might serve to build bridges and mellow both sides.”

                                                                                                  Seeing as my grandmother was almost murdered by Nazis the “mellowing both sides” bit did not go over well with me.

                                                                                                  1. 26

                                                                                                    It’s taken me quite some time to form a response.

                                                                                                    Here in Bloomington, IN, last year and the year prior, we had to deal with a real Nazi problem in our city. It was BAD. https://www.nytimes.com/2019/08/18/us/indiana-farmers-market-white-supremacy.html

                                                                                                    We have had a city govt run farmers market near the city square. It was on the largest walking/biking/running trail the city has.. It really was an amazing market.

                                                                                                    Then, the Unicorn Riot discord hack happened. Normally, this would oust Nazies and similar ideology. Except this time, it ousted a lady by the name of Sarah Dye, a farmowner and a stall vendor at the farmers market. It only outed the first name in the general vicinity and owned a farm - I was the one who found her account on Youtube by the name of Volkmom, and got her banned from the other 2 farmers market boards she was on. I forwarded the videos to their boards. They compared her voice to her damning videos.

                                                                                                    However, Bloomington IN doubled down, claiming 1st amendment concerns. Peaceful protests to Dye and the city were done… And the cops arrested the peaceful protesters, up to and including the president of low barrier homeless shelters - dressed as a purple unicorn ( https://www.thedailybeast.com/unicorns-arrested-at-protest-of-white-supremacy-at-bloomington-indianas-farmers-market ).

                                                                                                    And since Dye was being defended by the city, we had other undesirables show up. Other neonazies did. So did the 3 percent’ers. But when the 3%ers showed up, they were armed to the teeth, with AR15’s strapped to them, handguns (plural), zipties, and more. There was no question - they were not peaceful. They wanted to make a show of force that they were present to support their kind. Having them all show up shat on the very idea of the farmer’s market of inclusivity and coming together over shared food.

                                                                                                    We (public) finally solved this by deprecating the city run market, and a new market was made by a non-profit org. All the vendors showed up here, with exception of Sarah Dye and her stall. And unlike the city market, visible weaponry wasn’t allowed. And being in Indiana, people will pack heat; but it can at least be diminished.

                                                                                                    When nobody knew she was a Nazi and she didn’t do anything suspicious publicly, it was uneventful and peaceful. People just bought their groceries and all was good. The moment it was known, all the dregs, white nationalists, neonazies, kkk, and similar moved in to support “their kind”. We all literally had to abandon and regroup to get them to stop.

                                                                                                    If you don’t strongly deal with white nationalist groups, they’ll eat you out of house and home, run everyone off, and leave you with a shell of a community. I’ve seen it happen locally how it progresses in real life… and damned if I’ll let it happen to communities I’m currently a moderator of.

                                                                                                    1. 21

                                                                                                      Forgive me for being dense, but my reading of this is that everything was quiet and peaceful until you went out of your way to dox a Nazi and get her kicked out, and then people decided to protest a lawful application of the 1st Amendment, and then counter-protests happened, and a bunch of ugliness occurred, and then after all this you got the original market back less one Nazi.

                                                                                                      If this is an accurate reading (and it may not be!), how could one not conclude that everything was fine until you got a bee in your bonnet about somebody being a Nazi in their free time? How is everything that followed not your fault? That being the case…how is all of the following ugliness not the result of the efforts to purge a secret Nazi?

                                                                                                      My desire to follow rules of topicality and civility is very much due to a desire to avoid that sort of protest-counterprotest stuff that harms communities more than it helps.

                                                                                                      1. 23

                                                                                                        how could one not conclude that everything was fine until you got a bee in your bonnet about somebody being a Nazi in their free time? How is everything that followed not your fault?

                                                                                                        Who escalated to violence? The white nationalists did. Arguing that the exposers of secret Nazis are at fault is the argument employed by domestic abusers. “Woman, why do you make me beat you? Why do you do this to me?”

                                                                                                        I know you’re arguing in good faith. But please do not try to justify violence from this crowd. They proved that they weren’t standing on moral high ground when they showed up with firearms and zipties.

                                                                                                        The violent response from white nationalists to nonviolent protests should prove just how much of a charade their pearl-clutching about “muh free speech” really is.

                                                                                                        1. 13

                                                                                                          Forgive me for being dense, but my reading of this is that everything was quiet and peaceful until you went out of your way to dox a Nazi and get her kicked out, and then people decided to protest a lawful application of the 1st Amendment, and then counter-protests happened, and a bunch of ugliness occurred, and then after all this you got the original market back less on Nazi.

                                                                                                          More specifically, there was already an anti-nazi campaign locally going against her with what I considered shaky proof. Many of us were very hesitant to engage in protests in person or online, without solid proof. I used my OSINT skills and was able to positively identify that it was her. Had it not been, I would have also said so. I’m not going to engage in a protest against an individual unless I’m damned sure I can prove it… And I proved it beyond a reasonable doubt.

                                                                                                          Speaking to “and then people decided to protest a lawful application of the 1st Amendment, and then counter-protests happened”…

                                                                                                          The problem was that the city was supporting the nazi speech AND show of force, while arresting peaceful (non-weapon-possessing) protestors. If the city had applied equal force to both sides, there would have been less of an issue with respect to 1FA.

                                                                                                          If this is an accurate reading (and it may not be!), how could one not conclude that everything was fine until you got a bee in your bonnet about somebody being a Nazi in their free time? How is everything that followed not your fault? That being the case…how is all of the following ugliness not the result of the efforts to purge a secret Nazi?

                                                                                                          You’re extrapolating and assuming when you don’t have the information.

                                                                                                          My desire to follow rules of topicality and civility is very much due to a desire to avoid that sort of protest-counterprotest stuff that harms communities more than it helps.

                                                                                                          This sort of civility is similar to Sea-lioning ( http://wondermark.com/1k62/ ).

                                                                                                          Simply put, there is no civility when discussing people who want to murder people (and have done so) who differ only in race, skin color, or sexuality.

                                                                                                          1. 21

                                                                                                            Over and over and over again the same “both sides are at fault” message, Nazis and their victims. You simply cannot get yourself to say “let’s leave Nazis out”, huh.

                                                                                                            1. 13

                                                                                                              A few questions to make sure I understand your arguments:

                                                                                                              • Assuming Lobste.rs vows to leave the Nazi out, who is going to decide which user is a Nazi? What is the definition of a Nazi?
                                                                                                              • Since we’re bound to leave the Nazi out, how can we ensure that there won’t be a “leave the Y out”, where “Y” can be muslim from Saudi Arabia, Palantir developers (are they morally superior to Nazis?), Steven Pinker, Noam Chomsky and everyone else group X doesn’t like ?

                                                                                                              ps. This discussion is not new by any means. It is a hard discussion, Karl Popper wrote extensively about this exact issue.

                                                                                                              1. 8

                                                                                                                Thank you for your observation.

                                                                                                                For me, I can’t help but notice that even if we say “Okay let’s get rid of the Nazis”, we still have the question of who is a Nazi?

                                                                                                                Form a practical standpoint: half of my country (US) voted for Trump, for whatever reason. That makes them some flavor of Republican–or worse. It is not a stretch (and is pretty common in various circles) to see any affiliation with Republicans as basically being a Nazi.

                                                                                                                If half of Lobsters is from the US, this means that like a quarter of the users–based on back-of-the-envelope calculations–are Nazis and should be banned, for being Nazis.

                                                                                                                If we just ban based on civility and topicality, we get to sidestep this issue.

                                                                                                                  1. 7

                                                                                                                    Any of the comments that article references are clearly outside decorum and, if posted here, would warrant administrative action.

                                                                                                                    1. 8

                                                                                                                      Weev is a public figure. Weev was banned from gab. Weev could participate anonymously on lobsters. If weev wants to post here as weev, is that OK?

                                                                                                                      1. 8

                                                                                                                        Why wouldn’t it be, if he follows the rules and isn’t an asshole and contributes to on-topic discussion?

                                                                                                                        It being weev, I imagine it would be less than an hour before he gets banned for saying stupid Nazi shit, but might as well give the fellow a chance.

                                                                                                                        Our purpose here isn’t to punish people for actions in other communities; our purpose is to discuss technology.

                                                                                                                        1. 5

                                                                                                                          Weev is a public figure known for being a Nazi. For weev to be named as weev, it’s the same as https://lobste.rs/u/neonazi .

                                                                                                                          Weev could go by a different name to participate in lobsters.

                                                                                                                          1. 0

                                                                                                                            Pretty sure there are many internet users with that nickname - most probably are unaware of some rando from US. To be honest I never heard about that guy until today. If he would have an account here I would judge him by what he writes here without crosschecking him across other sites. Who does that?!

                                                                                                              2. 7

                                                                                                                I won’t say it because I don’t believe it.

                                                                                                                I would rather have a polite Nazi talking to me about technology than either a rude not-Nazi talking about technology or a polite not-Nazi talking about not-technology. As somebody mentioned above re: the Nazi variant of the Turing test…a sufficiently polite and topical Nazi is indistinguishable from a normal user, because they’re presumably not talking about Nazi shit and picking on Nazi victims.

                                                                                                                If they are, the rules of civility and topicality give a handy way–and a more uniform way–of dealing with them. Even better, it gives a way of dealing with them that doesn’t give them the recourse of saying “Well you’re just doing this because you hate Nazis”, or “You’re just doing this because you support SJWs”, etc. I can point at the rules and say “You were off-topic and being uncivil. I don’t need to believe anything about Nazis or your relationship with that ideology to get rid of you.”

                                                                                                                1. 22

                                                                                                                  Apparently you definition of civility includes telling me and other Jews to “mellow out” about people wanting to murder us. No thanks.

                                                                                                                  1. -9

                                                                                                                    Do you want to murder them, given that you (by my reading here) believe they are a clear and present danger to you and yours?

                                                                                                                    1. 17

                                                                                                                      This is too far. There are diminishing returns now on this conversation and also both of you seem to have lost perspective that this post is about finding new moderators because pushcx might be under huge moderator load - you’re not helping. At the least, take this to a different venue or to personal chat to hash it out and bring back here any positive results.

                                                                                                                      @itamarst You are talking about a subject which is understandably extremely sensitive and important to you. I think everyone can and would acknowledge the pain that you and your family must have gone through, and it is a failing of people in this conversation that that is not the first and most obvious point to be reiterated and repeated without fail. We all must acknowledge that terrible things have happened and that we want to take positive actions to prevent them happening again. That being said you are grossly not applying good faith in a situation where one person’s actions seem to have been offensive to you, and you are bringing a subject that is most definitely off topic for lobste.rs into this space. In relation to the former, you could have chosen a much more amicable way of bringing your point forward such as: Quoting friendlysock, explaining how you reacted to and felt when you read his comment and asking friendlysock to confirm if that was his intention and to clarify his meaning if it was. You definitely could have done that constructively inside the context which was friendlysock applying to be a moderator, so you could have phrased your question in a way relevant to this topic. No one would ever question your pain or your discomfort at seeing discussions of a group of people that brought great harm to your family and by extension pain to you; you do not have to not be angry, or not be in pain; but having the expectation that you can bring this up in this way in this space and the outcome be constructive is poor judgement: whether or not this was a motivation, you are not going to get personal resolution to political issues that cause you pain on lobste.rs.

                                                                                                                      @friendlysock Whatever your position you are grossly failing to take a step back and acknowledge itamarst’s point where he is now, not where you think he should be or how you think his point relates to lobste.rs. If you keep doubling down on your position, itamarst has to double down on his. This does not seem like rocket science. Whether this is on topic or not, when someone has gone to the effort and made themselves vulnerable by presenting something they are angry or in pain about, particualrly if it’s such a HUGE subject as this with so much emotion attached, step 1 is acknowledge that and consider your position in relation to what they said. You have no idea how they feel and you can not begin to understand their position so if they are offering you this level of confrontation the most you can do is acknowledge and listen. You don’t have to take responsibility for having caused their pain - no one is calling you a nazi or accusing you of murdering people, but you do have to acknowledge that they felt a particular way after reading what you wrote, and if you want to, you can explore that, but with about 1000 times more sensitivity. Acknowledgement and reiteration of your fundamental positions as they relate to lobste.rs, or moderation on lobste.rs would perhaps be a way to frame your position, if you’re interested in doing that.

                                                                                                                      1. 16

                                                                                                                        “Good faith” only goes far when some spends so much effort explaining how important it is we include Nazis in our discussions. Especially when they want to be a mod.

                                                                                                                        And really the whole point of the exercise is mod policy. As I’ve said before, in other discussions, you gotta pick a side. And the clearer friendlysock’s opinions, the clearer the choice pushcx has to make.

                                                                                                                      2. 13

                                                                                                                        Enough is enough. You are bullying itamarst with repeated emotional manipulation by way of a topic that has violently effected them, apparently so that you can get them to call for killings on a thread in which you nominated yourself to moderate the community in pursuit of civility. Are you done trolling yet?

                                                                                                                        1. 6

                                                                                                                          Do you want to murder them

                                                                                                                          Come on, this is too much.

                                                                                                                          1. 6

                                                                                                                            No, of course not.

                                                                                                                2. 32

                                                                                                                  no offence, but I find that “mellowing both sides” is a very legit goal. seeing as I’ve spent most of my life in a warzone, this goes very well with me. I’m not jewish, but I’ve had multiple run-ins with Neo-Nazis due to the way I look and where I escaped the war to. I used to hang out in this bar that was split in half, one of it was extreme leftists, and the other were staunch Nazis, some not even Neo. we were all fucked, so we just drank together in a weird peace of sorts. one of the Neo-Nazis never liked the fact that I started hanging out there, and was constantly hostile, and due to past experiences I had to often stay alert and make sure to be ready for whatever may come, but the beer was cheap mind you and the weed was good.

                                                                                                                  one of the Neo-Nazis in particular was this big guy who had it so clear in his eyes that he’d like to beat the shit out of me to prove his worth or whatever. I didn’t care as this was the least of my worries (at that time). one of the old men I used to hang out with was a programmer as well, so we’d get high and discuss all sorts of computer things. one day the convo came to Blender and 3D modelling, and all of a sudden this big guy who never wanted to exchange a word with me and rather punches came and started talking about Blender with love in his eyes instead of hate, after a couple of hours of that he threw the shittiest but unfortunately the most fitting line of all:

                                                                                                                  “your people aren’t too bad after all.”

                                                                                                                  we actually continued conversing after that and went through a couple of his traumas and why he ended up on the path he ended up on. I by no means expect everyone suffering from oppression to engage in such antics with their oppressors, but I’d rather the ones who can’t, let the one who can, do what they gotta do.

                                                                                                                  at the very least, you can try to not monopolize suffering under your own school of thought, and within only your own context.

                                                                                                                  this is probably my last comment here for a while, so feel free to PM if you wanna discuss this further. I am also very sad to hear about your grandma, it sucks to be almost murdered, it sucks to see people you love get murdered, and it sucks to see people you love commit murder, but that shit happens on all sides of aisle.

                                                                                                                  dehumanize one, and you dehumanize all, I find.

                                                                                                                  fucking hell, I need a beer.

                                                                                                                  1. 27

                                                                                                                    Thank you for sharing! I think that’s slightly missing the point, though:

                                                                                                                    1. The issue was with “both sides”. Why do I need to “mellow” if someone wants to murder me?
                                                                                                                    2. You are describing a truce backed by violence. And that might work for some, but the more common case is people not going into the bar at all, because they don’t feel safe.

                                                                                                                    I’m sure many Nazis have reasons for how they ended up where they are (though in the US a lot of them aren’t suffering at all, they’re upper middle class or rich). Maybe hanging out with Nazis will make them change their mind. I doubt it, but it’s possible.

                                                                                                                    But given the choice between making a safe environment for everyone, and letting some Nazis in in the vague hope they will learn something and lots of other people choosing not to participate, I’d rather choose the latter former.

                                                                                                                  2. 10

                                                                                                                    You know, I can sympathise with your viewpoint here, especially as a Muslim in the current global climate, but the problem I see is that this seems to be leading to such extreme echo chambers, that it makes people say things like what one user in the thread you linked said:

                                                                                                                    Feminists believe that women are as human and as entitled to agency and dignity as men are; MRAs believe that women are inferior to men and should be enslaved.

                                                                                                                    This is such an absurd statement to make without backing up and so patently false; the only way someone can believe this is by being fed a constant diet of lies people who really hate MRAs instead of just speaking to MRAs directly.

                                                                                                                    Suddenly, we’re not just banning Nazis who want to kill you and me and our entire family trees, we’re banning practicing religious people who aren’t willing to rewrite their holy scripture or reinterpret it to suit people’s desires, we’re banning critics of said religious folks who believe baby penises should remain intact — hey, they’re MRAs, right?; whatever, they must be islamophobes or antisemites either way — we’re banning critics of affirmative action, we’re banning all manner of people with valid and not so valid positions or arguments.

                                                                                                                    We don’t discriminate on truth, we discriminate on whether it’s comfortable or not to a select group of people. People who can’t discriminate between a belief like, “men and women have roughly equal average IQ, but the distribution is wider for men, so the ratio of men to women at Google is roughly what we’d expect if Google were selecting for such and such IQ” — responding with such inanity as “do the women at Google not belong there, then?” — and a belief like, “women are inferior to men and so should be enslaved to them”.

                                                                                                                    1. 20

                                                                                                                      I think that if I were on a rocketry forum I’d be interested in hearing what Wernher von Braun had to say (not merely a Nazi, but an officer in the SS). If I were on a forum about filesystems, I’d be happy to talk to Hans Reiser. If I were given the opportunity, I think that Konrad Zuse (not a Nazi, but certainly a collaborator) would have interesting things to say about electromechanical computer design.

                                                                                                                      I’d be more than happy to throw any of them out if they start going into politics or murder, but if they have useful expertise and follow the rules of decorum, they should have a place.

                                                                                                                      1. 16

                                                                                                                        Let me put it like this: if Hans Reiser would join a forum where Nina Reiser’s brother (or sister, close friend, etc.) would also participate, would you think it’s reasonable if they would object to this?

                                                                                                                        It’s not hard to see how this would also extend to neo-Nazis (as in, literal neo-Nazis, who looked at the Holocaust and thought that all of that was just a spiffing good idea); would you enjoy interacting with someone who literally wants to kill you and everyone like you and worships an attempt to do exactly that? Are many people not a victim of these people’s actions just as much as Nina’s Reiser’s brother is? Would you happily discus webdesign best practices with the person running StormFront or some other neo-Nazi website?

                                                                                                                        I’m not so sure if “it’s limited to just technical conversation” is really all that important, never mind that this is too limited of a view of Lobsters IMHO, as it’s a community centred around technical topics.

                                                                                                                        For all we know Reiser or the StormFront maintainer are already participating on Lobsters anonymously. We can’t really prevent that because the only alternative would be to actively vet members. But if you know you’re talking to the StormFront webmaster then … yeah, I’d rather not.

                                                                                                                        I’m not suggesting that we implement some sort of wrongthink policy or anything of the sort; you put forth the extreme scenarios so I’m replying to those, and in more realistic scenarios things tend to be some shade of grey. If someone on Twitter said “I don’t like people of religion/ethnicity/identity X” then that would probably be okay; as in, I won’t like them more for it, but I see no reason to ban them here for just that. But I do think all of this is a bit more complicated than you put forth.

                                                                                                                        1. 19

                                                                                                                          Would you happily discus webdesign best practices with the person running StormFront or some other neo-Nazi website?

                                                                                                                          Let’s apply a variant of the Turing Test to this: if people from the interactions alone cannot tell whether they are made by a regular person or a Nazi, then the poster/commenter can be regarded as worthwhile talking to as any other normal person.

                                                                                                                          1. 5

                                                                                                                            Yes. Nobodies forced to use real names on lobsters. If someone posts anonymously, respect it. Don’t dox.

                                                                                                                            It’s not the same if he/she uses their neo-Nazi name. Lobsters has no moral obligation to be known as the place where neo-Nazis hang out.

                                                                                                                            1. 10

                                                                                                                              Yeah I think there’s a bit of a straw man being thrown around in some of these discussions about being randomly chosen as the target of doxxing. It’s pretty easy to be anonymous on this website.

                                                                                                                              To even be perceived as a member of a hate group on a site like this would require affirmative signaling to one’s peers that they hold hateful views towards other members of the community for their birth-given human characteristics, which seems like a good enough reason to remove such a user in the first place.

                                                                                                                              1. 3

                                                                                                                                Yes. Nobodies forced to use real names on lobsters. If someone posts anonymously, respect it. Don’t dox.

                                                                                                                                Yes, I pretty much said as much later on: “We can’t really prevent that because the only alternative would be to actively vet members” (that this isn’t feasible isn’t stated explicitly, but it’s pretty clear to everyone that it’s not).

                                                                                                                                I think both you and @ewintr have missed the point of my reply; this entire discussion is fairly hypothetical because of course no neo-Nazi is going to link to their StormFront account on their Lobsters profile (or Gab, or wherever these people hang out these days). I just wanted to point out why having known neo-Nazis on Lobsters is something that people would object to, and why some people would choose not to visit Lobsters if this were the case.

                                                                                                                                1. 3

                                                                                                                                  No. You’re wrong. It won’t remain hypothetical. Look at how many people got caught from the 6th based on social media.

                                                                                                                            2. 6

                                                                                                                              would you think it’s reasonable if they would object to this

                                                                                                                              I totally would understand why they might object to this. Then again, dude was put into prison and served his time. According to the law, he has received his punishment. Anything further is just extrajudicial retribution–understandable but not lawful.

                                                                                                                              would you enjoy interacting with someone who literally wants to kill you and everyone like you and worships an attempt to do exactly that?

                                                                                                                              If they were polite and solved my problem, sure. It’d be weird, but I’d rather have the help than not. The second they started going on about that other stuff, I’d report them cheerfully.

                                                                                                                              For all we know Reiser or the StormFront maintainer are already participating on Lobsters anonymously.

                                                                                                                              Exactly. For the dedicated opposition, this kneejerk intolerance serves no real obstacle–and can even be really useful as a leveraging point to disrupt a community. It’s like people have never played Among Us.

                                                                                                                              but I see no reason to ban them here for just that.

                                                                                                                              The problem is, several Lobsters I believe would be more than happy to do that, and would want it in a CoC. Further, where do you draw the line? How much Nazi is too Nazi? How little pedophilia is acceptable? I don’t want to make those calls–I’d rather focus on the (much simpler) tests of a) has this user treated other users respectfully in this space and b) has this user stayed on-topic. If followed, I believe those two rules are sufficient to guarantee a good time for everybody.

                                                                                                                              But if you know you’re talking to the StormFront webmaster then … yeah, I’d rather not.

                                                                                                                              As an aside, the world-wide experts in decentralization are about to all be, or keep company with, some really distasteful people. Ignoring their experience because they’re icky strikes me as a waste.

                                                                                                                              1. 4

                                                                                                                                The Reiser case is a bit more complicated, as I agree criminals should be given a second chance. However, it’s not unreasonable for victims of the crime to still harbour (strong) feelings of animosity; I don’t think that’s “extrajudicial retribution”. I don’t think that many people would happily chat with their sister’s murderer about filesystems after they served their time.

                                                                                                                                At any rate, I only mentioned Reiser to illustrate the perpetrator/victim relationship, as it’s so clear in this case. I was tempted to leave that out entirely as it’s quite a different case from neo-Nazis.

                                                                                                                                would you enjoy interacting with someone who literally wants to kill you and everyone like you and worships an attempt to do exactly that?

                                                                                                                                If they were polite and solved my problem, sure. It’d be weird, but I’d rather have the help than not. The second they started going on about that other stuff, I’d report them cheerfully.

                                                                                                                                Alright, fair enough. But it’s not hard to see how other people would make a different choice here.

                                                                                                                                where do you draw the line? How much Nazi is too Nazi? How little pedophilia is acceptable?

                                                                                                                                I don’t have clear answers to that; but this is a kind of reasoning I don’t really like. Maybe there’s a better name for this, but I like to call the “it’s hard fallacy”, which goes like: “it is hard to draw a line, therefore, we should not draw a line at all”.

                                                                                                                                I’ve seen the same type of reasoning in conversations about civility. It can be really hard to draw a clear line about what is or isn’t acceptable, but that doesn’t mean we shouldn’t try at all. Clearly there should a line somewhere otherwise people replying with just “you’re a cunt” would be “acceptable”, and I think we can agree that it’s not. You can also see this fallacy in some other (political) topics.

                                                                                                                                I’m not actually in favour of banning people for off-site behaviour unless it’s particularly egregious, such as active neo-Nazis, and even then I’d have to carefully look at the specific case at hand. In general I think the bar should be pretty high for this, but I do think there is a bar … somewhere.

                                                                                                                                I mean, do you really expect black people or Jewish members to happily interact with people we happen to know are neo-Nazis or KKK members? If someone in your local soccer club is a great bloke and fun to hang out with, and then you discover he’s a Grand Hobbit Ghoul in the KKK (or whatever ridiculous ranks they have) then you would continue that relationship as-if nothing happened (and before you answer “yes I would”, would you expect everyone to do so, including your black teammates?)

                                                                                                                            3. 16

                                                                                                                              The problem, of course, is that then you lose all the people who don’t want to hang out with Nazis, or with people (like Hans Reiser) who murdered their wife.

                                                                                                                              1. 25

                                                                                                                                In an online forum for talking about X, I’d much rather have a room full of people who may be assholes elsewhere talking politely about X than I would a room full of people who might be lovely elsewhere being assholes in my forum because of something completely unrelated to X.

                                                                                                                                1. 7

                                                                                                                                  Thank you for this succinct explanation.

                                                                                                                                2. 12

                                                                                                                                  On the internet, no one knows you’re a dog.

                                                                                                                                  Who’s to say what someone’s intentions are? If people start causing problems, by all means remove them. The alternative is doxxing everyone who joins lobsters or digging up dirt, is that somehow a better alternative?

                                                                                                                                  I get it, no one wants to share a board with Nazis or murderers. I don’t either. But this social equivalent of a preemptive strike has the potential to be way worse.

                                                                                                                                  1. 11

                                                                                                                                    A good rule of thumb, in programming and elsewhere, is to always consider at least three solutions to any problem. There are in fact other solutions beyond the false dichotomy “doxxing everyone” and “accepting everyone”, one common one being a Code of Conduct. Personally I would go with “you must pass this very bar to participate”.

                                                                                                                                    1. 7

                                                                                                                                      Just because a comparison of two solutions are presented doesn’t mean you have to jump to “this is a false dichotomy.” Also, I thought we already had that with the lobsters rules? How does a code of conduct actually differ?

                                                                                                                                      1. 15

                                                                                                                                        Well, friendlysock apparently can compare Nazis as somehow equivalent to their victims (both sides apparently need to “mellow”). Most CoC would involve kicking him out for that.

                                                                                                                                        1. 6

                                                                                                                                          I don’t agree with the comparison and I don’t think friendlysock would be a good mod based on the fact that he could draw it. I just want to put this out there though - if there was a felon, Nazi or other unsavory person who could provide some insight into problems I’m trying to solve then I would still have an open ear so long as they stay on topic and don’t bring up their unrelated interests. Not doing so seems short sighted.

                                                                                                                                          Most Codes of Conduct are pretty crappy btw. Ruby has a good one, nearly all of the others are too suffocating.

                                                                                                                                          1. 3

                                                                                                                                            I think both you and @itamarst may be missing something in how I wrote that–and that’s on me for articulating incorrectly.

                                                                                                                                            My point was not to draw equivalence between those groups. My point was that everybody has some outgroup that they would prefer to see kicked out.

                                                                                                                                          2. 4

                                                                                                                                            Maybe you should resolve that with friendlysock, then. Not going to fan these flames anymore.

                                                                                                                                      2. 9

                                                                                                                                        How is it “pre-emptive strike” to just not want to hang out with people you don’t like?

                                                                                                                                        This isn’t like…. the seat of government. This is a place to talk with people. Absolutely nobody is under any obligation to listen to people (short of mods basically “kicking people out”). There is zero moral requirement to listen to “varied viewpoints” or have an open mind.

                                                                                                                                        EDIT: And pointing to a previous declaration of moderation wishes as “digging up dirt” in a conversation about mod applications is rich. Are we supposed to just treat every conversation in some weird vacuum even when it comes to something so obviously relevant? I know you’re saying this in good faith but how is that not fair game?

                                                                                                                                        And like… you know what? These people that get doxxed or whatever? They are the ones that are vocal about their opinions. That’s how you even know that they are these kinds of people. If they kept their mouth shut we wouldn’t even be able to know!

                                                                                                                                        I’m tired of being lectured about how I’m the bad person for not wanting to deal with people who not only are (IMO) morally bad people, but also don’t have the social IQ to keep it to themselves.

                                                                                                                                        1. 10

                                                                                                                                          These people that get doxxed or whatever? They are the ones that are vocal about their opinions.

                                                                                                                                          Alright, where does the dirt digging stop, then? Everyone that’s somehow associated as commenting in this thread, supportive or otherwise? Because they may somehow have an agenda too?

                                                                                                                                          Dude, you’re not the bad person. No one’s saying you are. I’m just done with communities that engage in shit slinging, doxxing, and public shaming rather than actual discussion in good faith.

                                                                                                                                          Anyway, peace out, lobsters. N-gate was right about you.

                                                                                                                                          1. 4

                                                                                                                                            I had someone PM me with personal details about myself while using a randomized username on reddit a few years back because I said that I didn’t think Ohio State was very good that year. People dox and dig up dirt for varied reasons. The nazi thing is an extreme example of that, but it happens for all sorts of other strange reasons as well.

                                                                                                                                            I no longer use Reddit because of that event, and now I try to stick to a minimal set of social sites (like this one) where it’s obvious who I am if you search my username or look at my profile.

                                                                                                                                            I don’t think you should feel obligated to listen to someone’s viewpoint if it’s non-technical (or even if it is technical really), but in this forum, the less I know about people, the better. I like hearing opinions or thoughts on tech without knowing who they are. I can’t control how they think or feel otherwise.

                                                                                                                                        2. 5

                                                                                                                                          Are you asking for Lobsters (and its mods, etc.) to:

                                                                                                                                          • Explicitly condemn Nazism, white supremacy, and murder
                                                                                                                                          • Ban anyone who publicly espouses these ideas, on or off our site
                                                                                                                                          1. 24

                                                                                                                                            You write as if that would be some kind of absurd idea, when it seems quite sensible to me..?

                                                                                                                                            1. 10

                                                                                                                                              thank you for objecting to that.

                                                                                                                                              reductio ad absurdem requires absurdity, and I’m not used to seeing “explicitly condemn Nazism” held forth as obviously absurd.

                                                                                                                                              1. 5

                                                                                                                                                It seems absurd to me because it’s kind of a given. Not every site needs to say “hey don’t murder people” for me to feel good about using it. It’s a general human sentiment that murder is bad. Explicitly stating it and only targeting those viewpoints makes me wonder why we aren’t explicitly denouncing every type of supremacy, nativism, genocide, rape, etc.

                                                                                                                                                But I do think banning people who espouse any of those views (spoken or unspoken) on the site is not only warranted, but should also lead to a probationary period for the person who invited them.

                                                                                                                                                1. 7

                                                                                                                                                  I don’t think we need to make a list of things we don’t agree with. But I do think that we should be clear that people who are known for their malicious activities (e.g. support for murder or racism) are not welcome here.

                                                                                                                                                2. -1

                                                                                                                                                  Putting this bluntly, the second one is stupid and anyone who argues for it is stupid. On or off our site? What the hell. Maybe in person I could logic my way into thinking that it’s ok but online? Thousands of miles away with no immediate threat to my wellbeing?

                                                                                                                                                  Online there’s always going to be that one jerk who doxes someone else for wrong-think and it’ll start with this.

                                                                                                                                                  1. 12

                                                                                                                                                    Thank you for proving your commitment to the cause of rational discussion by calling me stupid.

                                                                                                                                                    The thing is, we want Lobsters to be a place where all people are welcome. If we allow known neo-nazis to hang out with us, then people that feel threatened by those neo-nazis won’t come here. Sure, it’s not a threat to them per se, but why would you want to spend your free time talking to people that literally want you dead?

                                                                                                                                                    Being a neo-nazi is a choice. Belonging to a minority group isn’t. We should give the neo-nazis the boot and welcome the members of minority groups.

                                                                                                                                                    1. 5

                                                                                                                                                      why would you want to spend your free time talking to people that literally want you dead?

                                                                                                                                                      Because they have information I want and are capable of staying on topic for the site I’m on. I do not care what they do anywhere else. It is incredibly vexing that people are making me defend the scum of humanity.

                                                                                                                                                      I believe all people are welcome on lobste.rs if they’re not talking about tons of off-topic stuff and spewing out hate while they’re here.

                                                                                                                                                      1. 13

                                                                                                                                                        Do you also want information from people who, for example, would feel uncomfortable sharing a discussion forum with neo-nazis?

                                                                                                                                                        This isn’t value-neutral, we have a choice to make: either we welcome the neo-nazis, or we welcome the people-who-don’t-want-to-talk-to-neo-nazis. I know who’s getting my vote.

                                                                                                                                                        1. 5

                                                                                                                                                          This isn’t value-neutral

                                                                                                                                                          I reject that premise.

                                                                                                                                                          The nazi stuff should not enter the flow of conversation for nearly any thread on lobste.rs. The only reason we’re discussing it now because this is a meta thread and it was brought up by itamarst. If he hadn’t then we’d not know and not care.

                                                                                                                                                          So I think that if we actually talk about the things that we thought we were going to talk about when we were invited in the first place there won’t be any issues with your first sentence.

                                                                                                                                                    2. 7

                                                                                                                                                      Please don’t call other users or standpoints stupid. It’s okay to disagree, it’s even better to providing reasoning, but name-calling never helps.

                                                                                                                                                3. 7

                                                                                                                                                  You only lose the people who care more about Nazi status more than technology–and they’d doubtless be happier elsewhere, in a community that puts ideology and identity above knowledge and civility. I’ve made my peace with that.

                                                                                                                                                  I don’t think that you can fundamentally ensure that people always feel welcome, and there is no surer road to ruin than to cater to everybody’s exclusionary preferences. Everybody has a reason to hate Nazis, or furries, or Republicans, or women, or whatever–the only way a community grows and flourishes is by providing people the space and protocols to interact without requiring alignment on those things.

                                                                                                                                                  Don’t want to take up more space here on it, but am happy to continue discussing in DMs with whoever would like to.

                                                                                                                                                  1. 34

                                                                                                                                                    The fact that you seem to define “civility” as - roughly speaking - some sort of shallow politeness enabling us all to chum it up with nazis so long as we’re speaking about computers, rather than as good citizenship and strong community built on respect for one’s peers suggests to me that you’d be a terrible moderator.

                                                                                                                                                    1. 20

                                                                                                                                                      Agreed, that kind of response seems like it comes from a place of privilege. As in, “this doesn’t concern me too much, what’s the big idea?”

                                                                                                                                                      It’s been interesting to see convos here and elsewhere around accepting views that are rooted in hate but somehow we should all just suck it up because that’s “fair.” I’m often the only Black person in cis-White male dominated spaces so this is nothing new to me. Just…interesting to see this play out in the open for the first time.

                                                                                                                                                      Confronted with the knowledge of one’s privilege blinding oneself to what the disenfranchised has known to be true for eons is fascinating to watch/read.

                                                                                                                                                      1. 5

                                                                                                                                                        I’ll politely point out that my view would extend, were the conversations civil and on-topic, to folks like Malcolm X or Newton or Seale–not just stuffy old white dudes.

                                                                                                                                                        I think that, as John Perry Barlow observed, we here in cyberspace have the opportunity to transcend the strife we were all born into. Part of that means evaluating people based on their behaviour and not on what we think about their beliefs.

                                                                                                                                                        Edit: fixed rather embarrassing misattribution.

                                                                                                                                                        1. 13

                                                                                                                                                          (Davos is a place in Switzerland. That piece was authored by John Perry Barlow. I recommend the movie Hypernormalisation, there’s a very interesting part featuring Barlow and the other technolibertarians, discussing the connections to the counter-culture movement in the 60s)

                                                                                                                                                          I cannot help but find this sort of cyber-utopianism incredibly naïve. Things that happen on the internet can and do have effects on people in the real world. It’s been a long, long time since “just walk away from the screen, just close your eyes” was a genuine take to have.

                                                                                                                                                          1. 4

                                                                                                                                                            Thanks for catching that, still waking up.

                                                                                                                                                            It’s a naive approach, but that’s kinda the point right? Like, should we not strive to live in that more ideal, simpler, better world?

                                                                                                                                                      2. 2

                                                                                                                                                        good citizenship

                                                                                                                                                        What do you mean by this?

                                                                                                                                                        I agree btw.

                                                                                                                                                      3. 18

                                                                                                                                                        Everybody has a reason to hate Nazis, or furries, or Republicans, or women, or whatever

                                                                                                                                                        I think you may be lumping together several dissimilar attitudes here.

                                                                                                                                                        I do not think lobste.rs is suffering from including “the wrong people” or anything like that. We probably do have some people with terrible opinions, but it doesn’t leak into our usual discussions.

                                                                                                                                                        However, I do think it would be bad to have a mod to express the attitude that “some people hate Nazis, some people hate women. A pox on both their houses!”

                                                                                                                                                        I say “express” because I am not saying what you really think is “hating women is equivalent to hating Nazis”. But a mod has to be careful.

                                                                                                                                                  2. 6

                                                                                                                                                    Why stop with Nazis? If anyone shows any Nazi propaganda, they should be out. But let’s extend it to all other groups that cause harm to others. Any member of US army should be gone, heck, they didn’t try to kill my grandma, they killed my relatives, which were civilians (and they are still killing others in my country due to depleted uranium that was used in bombings). Also all the members of tech companies that help these strikes (looking at you, Microsoft et al).

                                                                                                                                                    Obviously, I’m exaggerating here to show a point that if we only look at membership of a group to exclude someone, we might also start extending the groups, as various people can/are affected. Personally, I don’t care which group people belong to, as long as they are not a threat to my family and are trying to help (or are just plain neutral) — which I think plenty of people here are, and that’s the main reason I come to this site.

                                                                                                                                                    1. 9

                                                                                                                                                      We did exactly this when a Palantir showed up to show a neat thing. It was one of the most shameful things I’ve seen in my time here.

                                                                                                                                                      1. 5

                                                                                                                                                        You are not exaggerating at all.

                                                                                                                                                        1. 2

                                                                                                                                                          This reads like the opposite-day version of “First they came…” by Martin Niemöller.

                                                                                                                                                          1. 1

                                                                                                                                                            That is a great poem that I have only heard so far paraphrased. Thanks for sharing! However, it has been a rough week for me, so I don’t get the “opposite-day version” part, could you elaborate?

                                                                                                                                                        2. 4

                                                                                                                                                          Circumstances under which I would be OK with an Actual Nazi participating (both conditions must hold):

                                                                                                                                                          1. User does not reveal themselves to be a Nazi on the site, either by explicit statement or in the way they act, and
                                                                                                                                                          2. User is not notoriously a Nazi externally to the site, either for having done something terrible or by making themselves a “public figure” wrt their viewpoints.

                                                                                                                                                          If someone behaves themselves on the site, and their behavior on the site does not create distress for others, I don’t see why people should be encourage in shitstirring. (If it is inevitable that someone’s presence will create distress, regardless of the behavior of anyone on the site, I would strongly suggest they use a pseudonym.)

                                                                                                                                                          “Nazi” is an unlikely and hyperbolic example, but I’ve seen people go and seek out damning information of one sort or another about a member of a community (including doxxing them), and then make it a thing. It wouldn’t have been a thing, and wouldn’t have caused stress to members of oppressed populations, if they didn’t do that! By digging, they’ve actually caused harm. So my rule would be that the notoriety has to originate externally or via direct actions on the site, or you just incentivize this ugly community antipattern.

                                                                                                                                                          (Some of my ancestors were murdered by Actual Nazis or had to emigrate to avoid them, in case you need that for my opinion to be valid.)

                                                                                                                                                          ((EDIT: I don’t want to be a mod, though.))

                                                                                                                                                        3. 8

                                                                                                                                                          Maybe don’t apply if you’re seeking to do if because you think it’s what people want you to do… Someone with that personality might be inclined to lose interest before their term is up if they think popular opinion is drifting away from them…

                                                                                                                                                          1. 22

                                                                                                                                                            My reasoning–and I’ve always held this position–is that anybody seeking such a position is either a lunatic, a tyrant, or both, and not to be trusted. Myself included.

                                                                                                                                                            That said…

                                                                                                                                                            Look, if we’re down to just one moderator, that’s a rough gig. That, plus the current state of the world, makes me worry for the site focus and discussion culture of Lobsters, and if I can help I’m happy to do so–and pushcx is welcome to shitcan and ban me (and will likely do so with great relish) at will should I fail in my duties.

                                                                                                                                                            Asking for sufficient votes before appliying is me, in effect, getting a gauge of if the community would agree to abide. As we’ve seen in my country this year, the legitimacy of government ultimately stems from the consent of the governed.

                                                                                                                                                            1. 11

                                                                                                                                                              And as I’ve seen in my country (US) this year, it’s wise not to give power to folks who are in it for the attention :P

                                                                                                                                                              1. 5

                                                                                                                                                                I personally (and I have a decidedly average number of internet points) like the way your postings changed when your nick changed to friendly. That change shows an appreciation of your past and new styles that I would like to see in moderators.

                                                                                                                                                              2. 2

                                                                                                                                                                TBH asking to be upvoted seems like a bit of a conflict of interest with wanting to be a mod… as friendlysock said

                                                                                                                                                              3. 7

                                                                                                                                                                :(

                                                                                                                                                              1. 5

                                                                                                                                                                For example this great study shows that using Typescript would have prevented approximately 15% of all bugs that you find in typical Javascript code. It’s hard to argue against static types with evidence like that.

                                                                                                                                                                And yet, there is no shortage of contrarian people who will pop up to do just that :-)

                                                                                                                                                                1. 8

                                                                                                                                                                  *waves*

                                                                                                                                                                    1. 4

                                                                                                                                                                      The OP is talking about a paper not in that set: https://web.archive.org/web/20191014123107/http://ttendency.cs.ucl.ac.uk/projects/type_study/documents/type_study.pdf

                                                                                                                                                                      @yawaramin has been teasing me for a while because I keep meaning to do a serious analysis of the Typescript paper but never get around to it

                                                                                                                                                                      1. 3

                                                                                                                                                                        But that post does illustrate a meta point: mere existence of a paper is not a strong evidence, sadly.

                                                                                                                                                                        1. 3

                                                                                                                                                                          Of course, the existence of the paper doesn’t prove anything, you need to actually read the paper and judge whether it’s doing a good job.

                                                                                                                                                                    2. 5

                                                                                                                                                                      On the Impact of Programming Languages on Code Quality

                                                                                                                                                                      “This paper is a reproduction of work by Ray et al. which claimed to have uncovered a statistically significant association between eleven programming languages and software defects in projects hosted on GitHub. … We uncover a number of flaws that undermine the conclusions of the original study as only four languages are found to have a statistically significant association with defects, and even for those the effect size is exceedingly small.”

                                                                                                                                                                      1. 2

                                                                                                                                                                        What matters for a business is to create a product, as fast as possible, that people use.

                                                                                                                                                                        Certainly shipping bugs is counter-productive but is not the only metric. What you have to demonstrate is that it would have taken less time to get to a stable point using TypeScript than JavaScript. If it takes 2x longer to write code because of the extra type annotations and slower tooling, it might not offset the extra time that a JavaScript developer would have taken fixing those 15% extra bugs.

                                                                                                                                                                        The 2x number is pulled out of thin air and I’m not saying that JavaScript is superior. In my experience, the number of bugs is not linear to the size of the codebase and dynamically-typed language tends to hit a plateau where it becomes an unmanageable mess more quickly than statically-typed languages. Another metric is that teams that are familiar with a given language are more productive in it, even if it has a lot of quirks.

                                                                                                                                                                        Just saying that language choices is a complicated topic :)

                                                                                                                                                                        1. 1

                                                                                                                                                                          Language choices are indeed complicated topics, especially that even the “rule of thumb” you provided as the first sentence is not true in every circumstance. I agree that most startups and many larger businesses value releasing an MVP as fast as possible, but I worked for at least a couple of projects where correctness and code quality was highly valued, even more so than release speed. A simple example I might give is the hard medical sector where life is at stake.

                                                                                                                                                                          Does it mean that Rust is a perfect choice for those kinds of projects? No. There are certain standards that must be met. Some of the standards actually specify which languages are allowed or force you to use certain coding guidelines, avoid problematic parts of languages etc.

                                                                                                                                                                      1. 3

                                                                                                                                                                        Odd the .cat TLD wasn’t used here.

                                                                                                                                                                        1. 3

                                                                                                                                                                          It’s hard to get unless you live in or operate your business out of Catalonia.

                                                                                                                                                                          Edit: not entirely true, but still tricky https://en.m.wikipedia.org/wiki/.cat

                                                                                                                                                                          1. 3

                                                                                                                                                                            This is very on-brand for Catalonia…

                                                                                                                                                                            1. 0

                                                                                                                                                                              I kind of want to say meow and look at pictures of cats for ten minutes now.

                                                                                                                                                                              1. 1
                                                                                                                                                                            2. 3

                                                                                                                                                                              I had zero problems getting tilde.cat which has nothing to do with Catalonia.

                                                                                                                                                                              1. 3

                                                                                                                                                                                I thought providing a Catalan translation was enough?

                                                                                                                                                                          1. -7

                                                                                                                                                                            Static typing… So cute.

                                                                                                                                                                            1. 6

                                                                                                                                                                              At least try to explain why something is a poor design instead of dismissing it.

                                                                                                                                                                              1. 4

                                                                                                                                                                                Seems quite close to Python’s type hints. Not mandatory to use at all, but if used correctly, it massively helps you find bugs.

                                                                                                                                                                                1. 1

                                                                                                                                                                                  Yes, they can’t fix the wrong design, only put some patches on it here ant there.

                                                                                                                                                                                  1. 3

                                                                                                                                                                                    What wrong design do you have in mind?

                                                                                                                                                                                    1. 0

                                                                                                                                                                                      Dynamic typing.

                                                                                                                                                                                      It’s proponents claimed it superiority for years… And now all the mainstream dynamic languages try to add at least some static types. But you can’t just put it there easily, it needs to be baked into the heart of the language.

                                                                                                                                                                                      1. 1

                                                                                                                                                                                        Languages like C++, Java and C# have been getting welcome additions like var, auto and polymorphic lambdas. There is virtually no modern language that requires you to specify the type of your iterator and good riddance, too. Let’s say that there is a convergence.

                                                                                                                                                                                        1. 1

                                                                                                                                                                                          Var, diamond etc. means that your code is still statically typed. You just don’t need to write the type by hand because it’s obvious for the compiler.

                                                                                                                                                                                          It can look similar to dynamic languages… But type inference is static typing to it’s core (it isn’t by chance this comes from ML family).

                                                                                                                                                                                          1. 1

                                                                                                                                                                                            Moving static typing to tooling and giving hints to help that tooling is part of the convergence just like statically typed languages losing boilerplate is. There is no pedestal you can climb to say “they were wrong we were right all along”.

                                                                                                                                                                                            1. 2

                                                                                                                                                                                              No. They were wrong. And that’s why they now need to add boilerplate.

                                                                                                                                                                                              You need to be statically typed to be safe and you need a good type system to be safe and remove boilerplate.