1. 7

    For a simple form of this, take the input file stream (ifstream) declaration for reading from each file:

    std::ifstream current_file(e.path()); In this statement, std::ifstream is the type, current_file is a variable name, and (e.path()) is… an argument list to std::ifstream’s default constructor. Previously, this would look like:

    std::ifstream current_file = std::ifstream::ifstream(e.path())

    This is not “new” for C++11, and the “stuttery” version is not how someone would typically write it in “old” C++.

    1. 4

      “Previous” or older would be, here’s a FILE* (pointer) and good luck with it. If you were on Linux at least. Not sure how verbose windows would be.

      1. 4

        On Windows it would be: here’s an opaque value HANDLE and good luck with it. Oh by the way, you can open an existing file by calling the CreateFile() function. It’s signature:

        HANDLE CreateFileA(
          LPCSTR                lpFileName,
          DWORD                 dwDesiredAccess,
          DWORD                 dwShareMode,
          LPSECURITY_ATTRIBUTES lpSecurityAttributes,
          DWORD                 dwCreationDisposition,
          DWORD                 dwFlagsAndAttributes,
          HANDLE                hTemplateFile



        By the way, if there’s a Windows programmer who wants to tell me to drop the A function in the favor of W, then please read this document, which tells that MS doesn’t recommend using W anymore. They want to push UTF8 support through the A family of functions. I think that UTF8 is superior to UTF16, that’s why I’ve pasted the A function ;)

        1. 2

          Thank you, been a couple years since I’ve written C++ on Windows but I’ve always reached for the W functions.

        2. 1

          To be clear I wasn’t talking about the i/o library so much as the authors claim that X x(arg); was some recent new variable declaration syntax shorthand, and that X x = X(arg) was what it replaced.

      1. 22

        tl;dr: I, personally, like Golang more than C++. Ergo, C++ is bad.

        Can we cut it with these fact-free language wars already?

        1. 7

          People can have their opinions right? Doesn’t mean we have to read them, that’s where the hide button is for.

          C++ is changing rapidly, (as rapid as an iso standard can change), I guess in the future we might even ditch types all together. We already can store “anything” without explicitly knowing the type, I recently wrote about that: https://raymii.org/s/articles/Store_multiple_types_in_a_single_stdmap_in_cpp_just_like_a_python_dict.html - recently there was this as well: https://artificial-mind.net/blog/2020/10/10/return-type-overloading and with all the templates and auto everywhere, you can write a dialect of c++ which looks like Javascript or python…

          Most of these “opinions” don’t write c++ professionally, but just in university. If you need raw performance or work with anything embedded, c++ is your best bet. But all these youths only know Javascript and the hip frameworks of today, which reflects in their opinions. Not to say that is wrong, and I do like that they write, I like reading opinions that differ from my own. However, I think that Your argument falls apart quickly if your biggest gripe is “std::” is annoying” or as toy say, it’s not go.

          1. 3

            yes but headlining the own opinion as absolute truth doesn’t hold its promise

            1. 2

              I don’t think that types will ever go away. You can do typeless programming right now with void*. But nobody is doing it, because it’s not useful.

              Python, Ruby, JavaScript (-> TypeScript) all started without types and are heading towards types (at least they’re giving an option to use them).

              My crystal ball tells me that in the future we’re more likely to use conditional types (so, more strict type of types) than to drop types altogether.

            2. 2

              Go is a weird comparison. If you’re in a problem domain where global garbage collection is acceptable in terms of latency and memory overheads, C++ is definitely the wrong choice because there are a lot of languages where you can be more productive if you’re willing to sacrifice some control. Once you’re in that worlds, there are also a lot of languages that are nicer than Go, the only advantage Go has in that space is that it’s easy to build stand-alone statically-linked binaries.

            1. 1

              Yes and no. I would draw a line between the language and the ecosystem/tooling.

              C++17 is a better language than C++98. It’s much safer, more user friendly. But I don’t use it for my hobby projects, because some of its aspects are too old, and nobody is doing anything to fix that. I am using it in work though.

              Tooling is still in a sorry state. There’s still no package management, #include-based modules are still from the ’80s. Lots of new languages (even from the ‘90s) have these problems solved, but not C++ – I have an impression that authors are focusing on mostly irrelevant things (user defined literals? uh cool, but was it really necessary? or designated initializers – also fine, but that doesn’t change how C++ will be used much). Some features like concepts are pretty experimental, and I think C++ should be more conservative, it’s used in too many projects to get away with experimental stuff that gets introduced in one revision, only to be deprecated in another (and C++ had features like that). Some features instead of being designed are a result of some kind of emergent behavior (like SFINAE; at least it looks like that to me).

              By the way, don’t listen to people who say that C is better than C++ – very often they say that because they didn’t manage to punch through the C++ learning curve.

              1. 1

                There’s still no package management

                I still consider this a feature of C++. Language-based package management fundamentally assumes that a program is written in one language. That is rarely true. I recently had to install Jupyter, which depends on Python and NodeJS (and some other stuff, including a bunch of native C/C++ libraries). I had a version mismatch between one of the Python components installed via pip and the NodeJS component installed via npm. This was such a common occurrence that there was documentation on how to address it.

                On Windows, you can use NuGet for C++ packages, but NuGet is only really cross-platform for .NET packages. It’s probably a better approach overall than language-specific package managers.

                #include-based modules are still from the ’80s

                Modules are not #include-based, they’re pre-parsed ASTs that can be lazily instantiated. They’re new in C++20, and have been prototyped and the design reviewed in WG21 meetings repeatedly over the last decade, so I don’t think you can fault the standards committee for not working on them.

                Some features like concepts are pretty experimental

                Concepts fix a real problem in C++ (understanding why a template instantiation failed from 100 pages of compiler error). They were originally proposed for C++11 and the prototype has been refined considerably in last 10 years, I don’t think it’s fair to call them experimental: they’re the result of well over a decade of experimentation.

              1. 1


                I wish webapps would start implementing better error handling to tell the user what’s wrong. It’s true that there would be times that the user wouldn’t be able to fix the issue, but some of times on the contrary.

                1. 1

                  While I agree with your general sentiment, I don’t get any errors when I view the site from my browser.

                  1. 1

                    Unless you are responsible for fixing whatever went wrong, it’s typically better in security terms to not say. “Something went wrong, sorry, it’s been logged” is all you really need to know.

                    1. 1

                      Remind me to not use any system that you’ll build :P. Security by obscurity is never the solution.

                      I simply disagree. Sometimes the user is able to fix things. Also some things are not working because of the user. Not telling the reason for failure is a source of frustration and nothing more.

                      1. 1

                        By the way, “security by obscurity” is all about doing nothing but hiding the details. Being able to tell the difference in problems handling a request is why there are different HTTP response codes.

                        You can tell a user that they need to authenticate with a 401, but you don’t let them enumerate valid user IDs by telling them that just the password was wrong. If a database query fails, you give them a 500, and not barf out an Oracle error message that tells them they’ve likely found a SQL injection vulnerability. You log the error, and make sure that someone can figure out why the error occurred, and hopefully fix it before it gets exploited.

                        Not all users are your friends, and what you propose is like holding up a flag when a sniper just misses their target. It’s not our job to make the attacker’s job easier.

                  1. 1

                    I’m not sure Java should be included in this graph. The graph focuses on the language design, and IMO the main point of Java is not the language itself, but the runtime. The language itself was intentionally stripped from many features in order to “dumb it down”, so it’s probably true the language won’t influence anything, but it’s also true that Java ecosystem has influenced .NET environment, and both JRE+NET are being used to actually run businesses, unlike majority of languages from OP’s list. Of course the OP can think whatever he likes, but I believe that a “remarkedly bad design” wouldn’t allow the JRE design to grow to such sizes.

                    But again, I’m not a big fan of the Java language, but telling how Java is bad, slow and poorly designed makes me think the person telling such things doesn’t know Java that well.

                    1. 1

                      Agreed. I included Java precisely for the JVM. See the (*) on top of Java.

                    1. -11

                      You know what I’m going to complain about and I think there’s a significant amount of users here who share my thoughts at this.

                      But I’m not going to put that directly this time, just because some too sensitive people might get “offended”.

                      Well, just stay on topic in the posts, okay? That’s not the first time and not the only blog with this particular “issue”.

                      1. 46

                        But I’m not going to put that directly this time, just because some too sensitive people might get “offended”.

                        When you see something that doesn’t affect you in the slightest and was made for free and given to the community to help, and you complain anyway, maybe you should ask yourself who is “too sensitive.”

                        1. 27

                          Could you please briefly point out what the issue is? Is the problem a lack of depth, some web-technology used, the drawings?

                          1. 16

                            +1 to this request. Speaking as a moderator, there’s nothing obviously wrong with this post to me. If it in fact has some problem, fine, we can address that, but only if we know what it is.

                            It’s almost enough to make me think there isn’t any real complaint, just a personal vendetta… but of course, that’s hard to prove, and really it’s beside the point. Either there is a complaint or there isn’t; if there isn’t, vague insinuations accomplish nothing.

                            1. 8

                              The user already had a comment deleted, this is just a continuation/provocation.


                            2. 3

                              He can’t point it out, because he will be downvoted into oblivion

                            3. 11

                              Haha what? I reread the post after I saw this (I don’t even like Rust man) and couldn’t find anything off-topic, or even remotely problematic. Are you referring to the art, perhaps?

                              1. 8

                                Yes. This user had a complaint about the art used in https://lobste.rs/s/3bbj56/edutech_spyware_is_still_spyware#c_9sqrho as well. In both cases, it’s their personal vendetta against cartoonish drawings of animals with human traits. They might be right that others dislike the art style as well, but it’s certainly not worth complaining about.

                            1. 4

                              Google is not better. Their Crashlytics SDK on mobile sometimes cause crashes. Same thing with AdMob SDK – when someone contacts me that the mobile app doesn’t work, often I’m just sending her an ad-free version – same git commit than previously but with ads disabled – and suddenly app is working again ;(

                              1. 2

                                Why are not doing this for everyone then?

                                1. 2

                                  I’ve already disabled Crashlytics for everyone. I won’t want to disable AdMob for everyone, because I’d like the apps to generate some profit for me. Fortunately I have lots of users, so a few people with disabled ads don’t make a difference.

                              1. 3

                                I’ve chosen btrfs as my default filesystem on my openSUSE installation and now I’m trying to search for some free time to migrate away from it.

                                Sometimes I’m doing mobile development (hobby projects) and btrfs is incompatible with Android emulator, at least on my machine. From some reason it works properly when using qemu through libvirt with e.g. Windows. But Android emulator is very choppy, completely not usable. However, after I’ve moved the guest system image to another partition with ext4, everything is smooth again.

                                1. 2

                                  That’s because lots of random per-file I/O interacts poorly with CoW, you can disable it per directory. Ideally, the vmm would work with the CoW filesystem, or at least disable it for the specific file/directory. This will likely happen only after it becomes default on a major distro.

                                  1. 3
                                1. 33

                                  Someone on Reddit put it best:

                                  Java devs never fail to be parodies of themselves.

                                  This is so spot on.

                                  Java is actually a good language, it’s the ecosystem that kills it for me. By “the ecosystem”, I don’t just mean the tooling (e.g. Java build tools are universally awful AFAICT), but the developers themselves. So much Java I read is just “magic”. Magic annotations, magic dependency injection, interfaces over classes that there is only one of etc. etc.

                                  The author points out very good failures in the way its been architected, but the code in the OP isn’t all that strange looking to me as Java, and that’s a pretty damning statement.

                                  I wish Java had a better audience around it. The Kotlin ecosystem seems better, but I’ve never used it.

                                  1. 25

                                    (edit: my first pass at this came off a little overly negative in a way that I think betrays the seriousness of my point)

                                    I’m not sure Java actually is a good language. My first introduction to Java was as the primarily language that was used in college, and even as a pretty green programmer them (I’d started writing C and C++ a few years earlier in high school, but I was definitely not a good programmer), I found it awfully questionable. In the intervening 15 years I’ve managed to avoid it, until quite recently. It’s been really eye-opening to see how the language has evolved in that time, but not really in a good way. Perhaps it’s because I’ve largely written OOP off as a bad idea that shouldn’t have ever taken off like it did, and is certainly outstaying it’s welcome, but I find that Java, and even the JVM itself, to be a masters class in solving the wrong problem in the most complex possible way. The complexity in java seems to be like glitter, you can’t touch anything with getting covered in it, and once it’s on you you’ll never get it off. Even working with people that I generally hold in high regard as developers, I see that the ecosystem has forced them into patterns and architecture that I think is questionable- except it’s not because to do anything better would be to try to work against every single design decision in the language and ecosystem. There’s simply no reasonable way to write good Java, the best you can reasonably hope for is to write as little java as possible, and hope the absurd complexity giltter doesn’t spread to all of your connected services by way of the blind “the whole world is Java” assumptions that the JVM ecosystem wants to make on your behalf.

                                    I say Java here, but realistically I think that all JVM languages end up falling into the same gravitational well. I’ve been using Kotlin lately, and from what I’ve seen of Scala and Clojure they are all infected by the same inescabable fractally wrong view of the world that is imposed by the JVM, by way of the JVM itself being born from the primordeal ooze of bad decisions and oop-kool-aid that led to Java in the first place. Kotlin in particular suffers from being not only unable to escape the Java ecosystem, but also from generally being a poorly designed language. Everything it adds to java, it adds in such a superficial and impotent way that a slight breeze knocks over the facade and you realize you’re stuck back in the Kingdom of the Nouns all over again.

                                    1. 7

                                      I tend to agree about the java part. The constructs at your disposal requires you to write very very verbose code, even for simple things. But I disagree about the JVM bit. I find it a pretty good runtime system. Although it tend to eat its fair share of RAM, the GCs and the JIT are first class. Overall, you get pretty decent perf without too much thought. Also, Having written a lot of clojure, it’s vastly different from java, couldn’t be further from the Kingdom of the Nouns.

                                      1. 14

                                        The JVM feels to me like it was written for a world that just didn’t really ever happen. It promised cross platform compatibility, that never really materialized since there are only two real meaningful places where the jvm is heavily used these days (x86 linux servers and arm Linux phones). Even where the jvm itself is running on multiple platforms, it’s not running the same workloads across it. We would have been every bit as well off with a toolset that made native cross compilation feasible (go and rust), and probably would have been no worse off even with the old C and C++ cross compilation story. Love it or hate it, JavaScript is what actually fulfilled the promises that java made and never was able to keep.

                                        Other promises that JVM made either never made sense- language interoperability always existed before java, and exists outside of it now. All the JVM did was fracture the environment by making it nearly impossible to produce native code- it’s a vampire if you look at it in terms of interoperability, unless you want to use gcc to compile your java code. The isolation and runtime management is, consistently, 90% of the work involved in deploying any java application I’ve used, and at the end of the day everyone does that work twice now because most workloads are getting deployed in cloud native containers anyway- so the JVM is superfluous there. GC is a pain in the JVM and has been done as well elsewhere without requiring the rest of the baggage of its runtime and jitter.

                                        Looking at performance, I’m dubious that it has much going for it. It’s still not a contender in the same space as C or C++, and in many cases the pain of native interop make it slower than even python because python can rely on native code for a lot of heavy lifting. I’ve even seen fairly well optimized JVM code fail to keep up with reasonably (perf) naive Haskell.

                                        Even with instrumentation, the supposed killer feature of the jvm, I have yet to see anything I can’t get out of a native application with native tooling and instrumentation, and the case is getting weaker by the day as more and more application telemetry moves up and down the stack away from the application itself and into either tracing layers in front of services, or tooling built around things like ebpf that live very low down in the system and allow you to instrument everything.

                                        The JVM is at best a middle-of-the road performance language with a largely superfluous ecosystem. It might have been a good idea when it was created, and I have no doubt a lot of smart engineering went into its implementation, but it’s time we give it up and realize it’s a sunken cost that we need to leave to the history books as a quirky artifact of the peculiar compute and business environment of the early 90s.

                                        1. 3

                                          Clojure’s okay (and still way better than Java, IMO) but suffers from pretty poor error handling compared to other Lisp environments.

                                        2. 4

                                          I really don’t like how Java makes optimization of its runtime overcomplicated, then has the gall to make you deal with the complexity. There is no reason to be manually tuning GC and heap sizes when every other runtime, including CLR implementations, can deal with this efficiently and automatically. They might be complex, unlike the JVM, they’re not complex and making you deal with that complexity.

                                          1. 3

                                            Just curious what you dislike about Kotlin’s design? It seems like you make two points: that Kotlin can’t escape Java and, separately, that it’s poorly designed. I agree with the former, but in light of the former, I find Kotlin to be pretty well-designed. They fixed Java’s horrible nullness issues and even kludged in free functions to the JVM, which is neat. Data classes are a band-aid, but still help for the 80% of cases where they can apply. Same with sealed classes (I’d much prefer pattern matching akin to Rust, Swift, OCaml).

                                            1. 13

                                              My biggest issue is that everything feels like a kluge. Null tracking at the type level is fine, but they didn’t really go far enough with the syntax to make it as useful as it could have been- rust does better here by allowing you to lift values from an error context inside of a function. The language tries to push you toward immutability with val and var, but it’s superficial because you’re getting immutable references to largely mutable data structures without even getting a convenient deep copy. Extension methods are a fine way of adding capabilities to an object, but you can’t use them to fulfill an interface ala go, or outright extend a class with an interface implementation ala Haskell typeclasses, so you’re left with basically a pile of functions that swap an explicit argument for a this reference, and in the process you are conceptually adding a lot of complexity to the interface of an object with no good associated abstraction mechanism to be explicit about it. Even the nature of the language as a cross platform language that can target jvm, llvm, and web asm seems fundamentally flawed because in practice the language itself seems to lack enough of a stand alone ecosystem to ever be viable when it’s not being backed up by the jvm, and even if you did have a native or web ecosystem the design choices they made seem to be, as far as I can tell, about the worst approach I’ve ever seen to cross platform interoperability.

                                              Ultimately the features they’ve added all follow this pattern of having pulled a good idea from elsewhere but having an implementation that seems to not fulfill the deeper reason for the feature. The only underlying principle seems to be “make java suck less”. That is, of course, a bar buried so low in the ground it’s in danger of being melted by the earths core, and I would say they did cross over that bar- kotlin does suck less than Java, but what’s astonishing to me is how for such a low bar they still seem to have managed to cross over it just barely.

                                              1. 4

                                                I share every single one of those sentiments, but I’ve excused many of them specifically because of the limitations of being a JVM language. (interfaces at class definition, no const, no clones)

                                                I’ve almost taken it upon myself to periodically go and correct people in the Kotlin subreddit that val does not make things immutable, and that Kotlin has not cured the need for defensive copies in getters.

                                                I think the idea of making Kotlin cross-platform is totally stupid for those same reasons you point out. All of that is a limitation of wanting to be on the JVM and/or close to Java semantics. Why they hell would you want to export that to non-JVM platforms?

                                                Thanks for the response.

                                          2. 12

                                            I have a completely opposite opinion. Java is not the best language out there, I prefer Scala and Kotlin, but the selling point for me is the ecosystem: great tooling (tools simply work in lots of cases), great platform (lots of platforms are covered, really awesome backward compatibility, stability), great API (it might be far fetched, but I have a feeling that Java’s stdlib is one of the most feature-packed runtimes out there, if not the most?). The “magic” is the same problem as everywhere else; it’s magic until you know the details. Also just because there’s a dependency injection trend in the backend development world, it doesn’t mean that you should use DI in different projects. Interfaces of classes are a Java thing; it wouldn’t exist if the language was more sophisticated.

                                            Maybe I’m comparing Java’s ecosystem to C++ – because with C/C++, the tooling is in appalling state, the standard library is awful and I’m not sure what it tries to achieve at times. So I guess I have a very low standards to compare to :P

                                            1. 3

                                              Java has an incredibly rich ecosystem, that’s true. What annoys me though, is that every single tool in the Java ecosystem is written in Java, meaning you have a ton of CLI programs which take a couple of seconds just to heat up the JVM. Once the JVM is hot and ready to actually do work, the task is over and all that JIT work is lost.

                                              At least C/C++ tooling is fast :p

                                              1. 2

                                                That’s true, JVM startup time is a pain point. But there are several walkarounds for that:

                                                • some tools use build server approach (gradle), so that startup time is less slow ;)
                                                • some tools like sbt (scala build tool) use build server + shell approach, and it’s possible to use a thin client to invoke a command on this build server (e.g. ‘sbt-client’ written in rust). This makes Scala compilation take less time than compiling a C++ application.
                                                • GraalVM native-image is pushed right now, which allows to compile JVM (java, kotlin, scala) application to native code without the use of JRE. This allows writing tools that have non-noticeable startup time, just like tools written in e.g. Go. I was testing some of my small tools with it and it was able to compile a small Clojure app to native code. This tool had same startup speed than a C++ application. Unfortunately, GraalVM can’t compile every app yet, but they’re working on it ;)

                                                Also C/C++ tooling is fast, but C++ compilation is nowhere near being fast. Changing one header file often means recompilation of the first half of the project. Bad build system (e.g. in manually written Makefiles) that doesn’t track dependencies properly sometimes produces invalid binaries that fail at runtime, because some of the compilation units weren’t recompiled when they should be. It can be a real mess.

                                            2. 10

                                              I wish Java had a better audience around it.

                                              That doesn’t seem terribly likely to happen.

                                              1. Java was never aimed at programmers who value power, succinctness, and simplicity - or programmers who want to explore paradigms other than OO (although newer versions of the lanaguage seem to be somewhat relaxing the Kingdom of Nouns[1] restrictions). It was intended to improve the lives of C++ programmers and their ilk[2].

                                              2. Java is frequently used in large, corporate, environments where programmers are considered (and treated as) fungible. “The new COBOL”, as it were[3].

                                              3. The JVM itself allows programmers not falling into (1) and (2) to abandon the Java language itself - Clojure, Scala, Kotlin, and Armed Bear Common Lisp spring (heh) to mind. Most of the best JVM programmers I know aren’t actually using Java. Most of the ‘Java shops’ I’ve worked with in the past decade are now, really, ‘JVM shops’.

                                              My observation is that most - to be clear, not all - people who continue using Java in 2020 are forced to do so by legacy codebases, and / or companies that won’t let them adopt new languages, even JVM languages. I honestly believe this is the proximate cause of the audience problem you describe. (Not the root cause, mind you).

                                              Edited: I’m amused by the fact that the first two, nearly concurrent, replies both reference Yegge’s nouns blog post :)

                                              [1] http://steve-yegge.blogspot.com/2006/03/execution-in-kingdom-of-nouns.html

                                              [2] “We were after the C++ programmers. We managed to drag a lot of them about halfway to Lisp.” - Gosling. http://www.paulgraham.com/icad.html

                                              [3] https://www.infoworld.com/article/3438158/is-java-the-next-cobol.html

                                              1. 5

                                                Java is a horrible language. No mortal can mentally hold on to a class hierarchy where inheritance is more than a few levels deep. Furthermore it is a bad way to add “another layer of abstraction” , because it just paints you more and more into a corner.

                                                (Clojure is a great language, you can add layers of abstraction to solve problems, without just digging yourself deeper.)

                                                1. 3

                                                  But one can write Java programs without abusing inheritance, and even pretty much without inheritance.

                                                  1. 1

                                                    Yes. I agree that Java is a horrible language, but class inheritance doesn’t even make the list of things I find poor about it.

                                                2. 3

                                                  I don’t agree that Java is a good language at all, but I wanted to hard-agree at the distaste for magic annotations and DI frameworks.

                                                  1. 1

                                                    Java is actually a good language, it’s the ecosystem that kills it for me. By “the ecosystem”, I don’t just mean the tooling (e.g. Java build tools are universally awful AFAICT), but the developers themselves. So much Java I read is just “magic”. Magic annotations, magic dependency injection, interfaces over classes that there is only one of etc. etc.

                                                    I don’t agree with this - in my experience, “magic” is “code that integrates my application-specific functionality with a massively feature-rich general purpose framework”. It’s magic in the sense that you need to understand the enclosing framework to understand why those annotations are there and their semantics, but they do real work. Work I’d have to do myself if I didn’t use them.

                                                    You don’t see this much in other languages, but it’s because “massively feature-rich general purpose frameworks” aren’t common outside of Java. The ones that do exist seem to have punted on important architectural decisions - you don’t need a dependency injection framework if your data layer objects are just global values (I’m looking at you, Django).

                                                    I’ve definitely felt this urge before - why do I need all this spring crap? Then I end up re-implementing half of that magic myself and not as well.

                                                    1. 1

                                                      What language has tooling that you like? Curious what you are comparing the Java build tools with

                                                      1. 2

                                                        Rust and Go (at least since Go modules) I find both intuitive and fast. I am still not sure how to properly build a Java application without an IDE.

                                                        1. 1

                                                          $ ./gradlew build

                                                    1. 15

                                                      Clean code is a really good book. Even if it has some examples that are on the edge, and some examples that you don’t agree on, it doesn’t mean that rest of the examples are bad.

                                                      Most of the things from Clean Code is simply a good idea. I’m not sold on all points, but it’s a damaging reaction to “stop recommend” 1000 hints, just because 20 of them are bad (in the worst case). If everyone would use 25% of the hints that Martin suggested, the world would simply be a better place. Even if people would follow the “bad” advice from this book, it still would be a better situation than people inventing their own strange philosophies for e.g. naming things, that happen to change from variable to variable. From my experience, lots of people don’t even consider most points that Martin has proposed. And if there’s a value to the book, then it might be just to tell you what you should think about. Which is a good outcome I think.

                                                      1. 16

                                                        There are so many books out there, it it really necessary to settle for one that contradicts itself? It is such a red flag.

                                                        1. 5

                                                          Are there so many books on the same topic as Clean Code? I only know Code Complete, and then an incomplete, outdated smattering of language-specific ones including Eloquent Ruby, Effective *, and Smalltalk Best Practice Patterns.

                                                          1. 5

                                                            How about The Practice of Programming by Kernighan and Pike?

                                                          2. 3

                                                            I didn’t have an impression that the book contradicts itself.

                                                            I don’t think the blog post does a good job with argumentation. Author’s rationalization after reading a paragraph is often completely different than mine.

                                                          3. 8

                                                            These days I write maintainable code because I have been forced to maintain my own code. Martin’s ideas were a great help to get me started on the journey, and I still draw from them periodically. So yes, I think Martin is great learning material, with the huge caveat that experience is the best teacher and Martin’s ideas are not gospel.

                                                            1. 9

                                                              I have yet to see maintainable code written by someone who has not spent a few years maintaining code they wrote.

                                                              This effect mostly seems to kick in around the two year mark; if you change jobs every two years you may have never seen the long term impact your work had on code health.

                                                            2. 5

                                                              What specifically is good about it? The specific points that this article makes do strike me as egregiously bad code - and moreover, it seems like the book’s dictums are fairly closely tied to the Java ecosystem and its mandatory object oriented paradigm. If I was writing code in Rust or Haskell, what advice in this book would even be applicable?

                                                              1. 5

                                                                Prefer small functions over large ones, prefer consistence when naming things, write tests for your code, prefer to document the app through code/naming conventions instead of comments but remember about adding comments if you need to, remember to maintain the comments as much as the code, think about maintenance aspect when writing code, perfer abstraction over code duplication.

                                                                There are lots of things in the book that are general. Granted, lots of the things are aimed towards Java. But I think think that lots of things from the book are applicable to e.g. C++. Rust is not an exception (no puns here).

                                                            1. 2

                                                              Anybody can refactor some given source. Does Bob Martin actually write original code?

                                                              1. 9

                                                                Not anybody can refactor, and some people simply shouldn’t refactor anything. Lots of people have no idea what to focus on when writing code.

                                                                1. 2

                                                                  Yeah, I guess the way I wrote my comment made it seem quite dismissive, which I regret. Really I was just wondering if Bob Martin writes original code, though I found some on his Github profile.

                                                                2. 2

                                                                  Try refactoring a 10 year old java code base.

                                                                  1. 3

                                                                    Our term of art for similar things is “refucktoring”.

                                                                1. 3

                                                                  It’s great, thanks for asking.

                                                                  I didn’t like the lockdowns due to the virus, but this forced my company to open the full-remote mode. I love it. I can focus on my work, do more than previously, nobody is interrupting me so I can focus on things, I don’t feel I’m wasting my life sitting in one spot in the office. I don’t waste time to commute, so I have more time for myself and my SO, my contact with my teammates has actually improved, because now we focus on organizing it, instead of trusting for it to be an organic process.

                                                                  Having to wear the mask is pretty annoying, and everyone treating the other person as potentially infected sometimes can be too, but I think the annoyance is mostly a result of focusing on wrong things.

                                                                  1. 45
                                                                    • Stream starting.

                                                                    • Tim Cook on stage. Empty theatres. Remote developers, developers, developers! Tim addresses BLM and social issues. For developers, this includes an entrepreneurship program for new black developers. Also talking the ‘rona, because that’s unavoidably a part of this. Because of the pandemic, this means the talks and workshops will be delivered remotely for free.

                                                                    • Craig on stage to talk about platforms. iOS 14. Homescreen changes? Looks like widgets (that expand?), expandable folders, and picture in picture on iPhone. App library at the end of home screen. Shows all apps in 2x2 buckets of automatic categories. Because of the app library showing all apps, you can modify home screen pages to be hidden to simplify your list. There’s also contextual suggestions, recently added, and search. In a category bucket, it’ll show most used apps. Widgets. Today view is shown. Multiple sizes including 2x4 and 2x2. Widgets can be dragged out of today view or inserted from home screen widget gallery. Smart stack has multiple widgets in a chunk and can automatically pick what widget to display. Picture in picture on iPhone, which is movable/resizable, can play while switching apps, and can be hidden away while playing audio. Siri is no longer a modal dialog and takes less time, popping up notifications or apps instead.

                                                                    • Yael to talk more about Siri. 25b requests each month. Handles more complex natural language questions. Audio messages supported. Dictation is now run on device for privacy. Translation app, which can handle conversations (special case UI to make it easier for two people) and runs offline w/ neural engine devices.

                                                                    • Craig back to talk about iMessage. 2x increase in group messaging.

                                                                    • Stacey on stage to talk about iMessage. Pinning messages and animated display of notification. More memoji. Threaded conversations with mentions (and group chat messages can only appear with a mention if you want). Group chat avatars or avatar cloud display.

                                                                    • Craig back to talk about maps and such. Maps. It’s a lot better than its infamous old reputation. UK/Ireland/Canada next. Discovery/routing features?

                                                                    • Meg to talk about maps. Guide feature for recommending POIs. Environment-prioritizing routing options, including cycling. Cycling routing can pick bick lanes and considers stairs/hills/busy roads, and avoid those kinds of things all together. EV routing that tracks in charging location, current charge level, station cable compatibility, and hypermiling. Green zones/congested areas shown. Chinese license plate numbers can be entered in case you’re in the PRC.

                                                                    • Craig back. CarPlay. 97% US availability, 80% worldwide. Wallpaper? Parking, EV charging, food ordering apps available on it. Car keys suck.

                                                                    • Emily on stage to talk about how your car keys suck - buy an iPhone instead. New BMW 5-series will support unlocking it with your phone via NFC. The key is in the secure element and can be disabled remotely, or shared by iMessage (including restricting access with that provided key).

                                                                    • Craig back. It’ll be available on iOS 13 too. They’re going to standardize it. Apparently that’s what the U1 ultra-wideband chip was for. App store. Contextual app store prompting for “app clips” (sounds like that instant app thing on Android?). They can use Apple Pay and Sign in with Apple. Clips go to a section of an app are ephemeral and used only for the context used, or available in recent used apps. Apps can be launched via geofencing, web, maps, NFC, QR, messages, custom circular 2D barcode, etc. Larger apps can create clips for clients. 10 MB or less, native SDK. Can download full apps. That’s it for iOS.

                                                                    • iPad OS. Trackpad and markup/pencil stuff and AR recap from last year. iPad OS 14. Designed for iPad stuff? It was kinda about bigger iPhone apps, but now it’s turned into iPad-focused stuff.

                                                                    • Josh to talk about iPad OS. It also gets widgets. Photos app has a sidebar now, which doubles as a drag container. Other apps are also getting sidebar drag/nav improvements. Toolbar dropdowns (for old Mac OS purists, they can also be hold to select). Music app gets the same changes too for basically a new iPad oriented app vocabulary.

                                                                    • Craig back. The Siri UI change also affects iPad, and other apps like calling get discrete non-modal popups. Search changes. It’s also non-modal too and can be done from any app. Universal search can search across things (including app launching), Siri questions, web search, mail/contact search, etc. Pencil improvements. Scribble? Handwrite into text fields.

                                                                    • Jenny to demo it. Pausing a simple shape drawn at the end will make a more formal version of the shape with same size and angle. Handwriting can be selected like typed text. This is done with on-device ML. Space can be inserted in between canvases. HWR can be inputted directly into system text fields. Handles CJK mixed in with Latin text. Like typed text, it can recognize addresses and phone numbers with data detectors. Can copy HWR as text to paste.

                                                                    • Craig back. Things in iOS will apply to iPad OS… of course. AirPods.

                                                                    • Mary-Ann to talk AirPods. They’ll automatically switch between devices without manually changing with context. Spatial audio. 5.1/7.1/Atmos and beyond emulation? On my wireless earbuds? They’ve apparently got the algorithms for that, that accommodates for flawed real world problems like “people moving their heads/iPad” (using a gyro) so the spatial space reorients it around devices.

                                                                    • Kevin to talk about watchOS. watchOS 7. Multiple complications for apps. Chronograph with tach complication. Customization overhaul. SwiftUI complications. Sharing watch faces, including curated faces, and can pull missing apps from a face. Apps can have readymade faces. Maps on watch. Cycling applies here too. Fitness.

                                                                    • Julz to talk about fitness. Dance workout category. Accelerometer/gyro can be used to determine what part of the body is moving. More including cooldowns, full training, etc. App renamed to fitness to reflect intent. Health. Sleep tracking.

                                                                    • Vera to talk about that. Can help goals, and does it across devices. Wind down will help create a sleep ceremony (experts say it helps?) and “wind down” will calm you down (with DND) before sleep and provide shortcuts for whatever ceremony you need. Haptic alarm for gentle wakeup. ML model? ML model. Uses things like breathing to determine sleep. Most of the sleep stuff is available on iPhone too. It can tell how long you actually wash your hands and if you do it properly and for how long (with gyro/accel/mic to determine). Translation available too.

                                                                    • Craig back to talk about privacy. They apparently take it seriously! Minimize data gathered. Do it on the device as much as possible. Transparency and control about data. Sign-in with Apple is popular and likelier for developers. Now developers can allow users to convert their accounts to sign in with Apple.

                                                                    • Katie on stage for privacy stuff. Approximate location. Erik talking about mic/camera usage in apps and indication of it. Tracking control extended to apps. tl;dr of privacy policy (inspired by nutrition fact labels) of an app on the store for all devices.

                                                                    • Craig back. Home stuff. Devices should be easy to set up, don’t compromise privacy, and enrich other devices.

                                                                    • Yah to talk about HomeKit. Amazon, Google, and others have came together with Apple to come up with standards. HomeKit open sourcing. Home app can suggest events/rules for new devices. Adaptive lighting. Activity zones for cameras (regions). Face recognition using data you already have. Notifies who rings the bell. Apple TV integration.

                                                                    • Cindy talking about Apple TV. Gaming improvements. Multiuser support for games. Xbox Elite/Adaptive controller support. Fitness integration. Picture in picture on TV. AirPlay improvements. TV+ has one 1billion supported devices out there? New Asimov’s Foundation adaption on TV+ for next year.

                                                                    • Craig to talk about Mac OS. Crack marketing team decides the name Big Sur. Design changes? Alan on video to talk about that. Depth, shading, transluency for hierarchy. Symbol library. Content focus, simplify appearance of other things. Changes to control appearance. New sounds. It’s not as flat! Craig will demo it. Looks kinda like iPad OS superficially. Menu and (rounded) dock is translucent. CSD-like toolbars and sidebars. Glazed sidebars. Finder, iWork, Photos, Calendars, Podcasts, etc get changes. Menu padding changes. Menu bar applets are visually tweaked. Control centre on Mac. Applets can be dragged from the control centre to the menu bar. Notification centre is less modal. Grouping. Widgets are on Mac too. Messages on Mac OS improvements, including search, stickers, effects, synced pings, groups, and photo pickers. Maps improvements, including street view and everything else mentioned. Catalyst. Playgrounds on Mac. More control over Mac UI. Menu and keyboard APIs. Updated system controls. System apps are Catalyst, (attempting to) providing a Mac experience, just with UIKit instead. Lots of third party apps! Safari improvements. JS performance improvements. Page load improvements. Battery life remains good. Privacy protection and tracking visibility with privacy reporting. Password breach detections. Extensions via WebExtensions available in MAS. Extensions have privacy repercussions in other privacies, so Safari can provide ephemeral/per-site enabling.

                                                                    • Beth on stage to talk about Safari. Customizable start page. Extensions can be enabled from Prefences. As an example, the recipe filter extension will just focus on the recipe on a page. It can’t do anything yet because it has no permissions though. She allows it to run for one day, and it’s disabled after that. Trackers are shown with privacy report. Tab improvements. Yes, there’s icons again, with tooltip previews! Close all tabs to the right! Translation support.

                                                                    • Back to Craig. Back to Tim. Red letter day for the Mac! TRANSITIONS? They did it! ARM Mac with Apple’s own CPU!

                                                                    • Johny to talk about silicon. They started with iPhone, and have ten generations of their own design. 100X CPU perf improvement. Then iPad. 1000X GPU improvement over ten years. They think because of that, it could scale to Mac. Then they go lower with Watch SoC design. 2b SoCs shipped. Performance/power/thermal balance. Desktops/notebooks have different consideration. Apple thinks they can ship the best balance. It’s not just the CPU, but things like uncore and coprocessors, as well as how good you can make it. ML/neureal coproc. More stuff along those lines. Mac SoCs with unique featureset but common architecture. Tight HW/SW integration.

                                                                    • Craig back to talk about integration and the transition for dev/users. Native apps, baybee! Everything in the stock OS and first-party (including pro apps) will be native on release. Xcode of course can target this with the next version. Just recompile! Universal 2 for fat binaries. Microsoft is porting Office, and so will Adobe. The Apple Development Platform has an A12Z as an iPad would. The previous demos were ARM based too. Word runs on ARM. So does Excel. And PowerPoint (with Metal rendering). Lightroom. Photoshop. It handles big files fine. FCPX runs on ARM with full real-time effects. FCPX also uses the ML chip, and uses it for some effects. Multi-core 4K ProRes running on A12Z. Same optimizations apply. Users should be able to run all apps on day 1, right? Rosetta was available before, and now it’s translating x86 to ARM and apparently fast. Translation happens at install time, as well as handles JITs. Virtualization is supported on ARM Macs, including Linux/Docker (a Debian with Gnome 3 VM was shown).

                                                                    • Andreas talking about the transition and tooling. Maya running on Apple silicon with Rosetta? Games are supported; Shadow of the Tomb Raider with Metal is shown emulated while remaining performant. Parallels shown with Linux. You can run iOS/iPad apps unmodified in a window.

                                                                    • Craig back. Most apps should “just work” and they’ve prepared for this. Porting should be just a few days. Quickstart program. Forums, labs, DTKs, DTS supports, and docs for transition. The new DTK is a Mini with A12Z, 16 GB RAM, 512 GB SSD, with beta Mac OS and Xcode. HW ships this week?

                                                                    • Back to Tim. Courage! Timeline? Devs start this week. Users will get a system at the end of the year and transition will finish in two years. Intel Macs will be supported, and new ones are still in the pipeline. OS betas available today. Public beta (including Watch) in July. RTM in Fall. Consultations and videos available for remote WWDC.

                                                                    • Fin? They did the proper pandemic things making all this too. Fin.

                                                                    1. 10

                                                                      Awesome summary, and I appreciate that you included each presenter’s name.

                                                                      1. 6

                                                                        Thanks for the summary. A couple of interesting things:

                                                                        Rosetta was available before, and now it’s translating x86 to ARM and apparently fast

                                                                        ‘It’ probably isn’t. Rosetta was Apple’s brand for a dynamic binary translator from a Manchester spin-out called Transitive Technology. The company was bought by IBM (who, at the time, wanted a SPARC-to-PowerPC translator to help people who bought expensive hardware to migrate to buying IBM’s expensive hardware). According to rumour, Apple had a separate license for each version of OS X that they bundled Rosetta with and expected to be able to negotiate better terms over time because fewer people would care. After the IBM acquisition, IBM (still annoyed with Apple over the anti-IBM commentary from Jobs over the Intel switch) refused to license Rosetta at all.

                                                                        So it seems quite unlikely that this is the same Rosetta as the previous version, so I wonder what the lineage is. Somewhat amusingly, the x86 on ARM emulator that ships in Windows is descended from VirtualPC for Mac, an x86-on-PowerPC emulator that Microsoft ended up owning when they bought Connectix (which they bought for VirtualPC for Windows, a mostly unrelated x86 hypervisor product.

                                                                        I presume that, given how much code is shared between iOS and macOS, Apple has been testing all of their userspace stuff on both platforms for quite a while and most third-party stuff doesn’t include any assembly code and so will be a straight recompile. I’m curious to know how much the ARM Windows port of Office helped with the ARM macOS port.

                                                                        1. 6

                                                                          I doubt there’s much of a substantial (direct or indirect) lineage between old-time Rosetta and this one, but it makes sense that they’d choose the same name, considering how unexpectedly smooth the last transition went. I remember reading about it and self-assuredly smirking and thinking this was going to fail so badly it’ll almost be funny. Running PowerPC binaries on top of the register-sarved x86, at a time when hand-rolled assembly still popped up pretty often in commercial (and lots of non-commercial) code? Hah. But I could get games to run, on a Hackintosh no less (a leaked vmware image popped up at some point and, with some trickery, you could eventually get that on a physical disk and have it boot, which I did, a testament not so much to my m4d h4x0r sk1llz bot to how much free time I had fifteen years ago…)

                                                                        2. 4

                                                                          Thanks! Though I feel there’s not enough “amazing’s” and “incredible’s” in your summary :D

                                                                        1. 2

                                                                          I was wondering if we could solve this by having pointers and content in email where previous emails are included only as a pointer.

                                                                          1. 5

                                                                            There is the In-Reply-To header, which any decent mail client will use to reconstruct the thread structure.

                                                                            1. 3

                                                                              There is a Message-ID header, at least in theory.

                                                                            1. 12

                                                                              I’m having a hard time understanding why Signal is being treated as a “private” solution, when it requires to submit a real phone number. SIM cards are tightly coupled with real name and citizen identification numbers, which is the ultimate goal of every identification technique. Well, some countries maybe allow buying anonymized SIM cards, but I don’t think it’s legal in lots of countries. Plus, the privacy policy of Signal contains this clause:

                                                                              Information we may share: Third Parties. We work with third parties to provide some of our Services. For example, our Third-Party Providers send a verification code to your phone number when you register for our Services. These providers are bound by their Privacy Policies to safeguard that information. If you use other Third-Party Services like YouTube, Spotify, Giphy, etc. in connection with our Services, their Terms and Privacy Policies govern your use of those services.

                                                                              Does that mean that they share the phone number with multiple third-parties? Maybe I misunderstand something, but it doesn’t sound very “private”.

                                                                              In other news, this article contains so much assumptions that something is bad, and something is good, without giving any rationalization why author thinks this way. This forces me to not treat the article seriously ;)

                                                                              1. 6

                                                                                Does that mean that they share the phone number with multiple third-parties? Maybe I misunderstand something, but it doesn’t sound very “private”.

                                                                                Your phone number is shared with their verification service. Your phone number is not shared with YouTube, Spotify, Giphy, etc..

                                                                                Signal knows you use their service. They do not know with whom you’ve communicated.

                                                                                1. 4

                                                                                  The same reason people recommend Protonmail and Tutanota, which don’t comply with open standards like IMAP and the latter of which makes claims about things being open source when it’s demonstrably untrue.

                                                                                  Hype, spin and assuming people are being fully open when their definition of what constitutes ‘fully’ can vary wildly.

                                                                                  1. 4

                                                                                    I think the phone number requirement makes a lot of sense, especially for email-related services. Abuse is rampant. I worked on a email-based support system (e.g. like ZendDesk) and we had people using scripts to keep signing up new accounts and spam until they hit the rate limits. It didn’t matter that we limited the number of recipients: they would just send loads of emails anyway. They just paid the €5/month to avoid the free-trail rate limits which existed solely to prevent abuse (using a stolen CC?) With really aggressive rate-limiting and limits I eventually solved most of the problem, but people still tried, and it still affected our sender reputation (although within manageable levels). The entire thing was no fun at all, and the more protection you have against abuse like this, the better IMO. This doesn’t just protect the service, but also (potential) scam victims.

                                                                                    tl;dr: spammers are assholes.

                                                                                  1. 2

                                                                                    I’ve always enjoyed running StarCraft from commandline, or from some search box, where I need to type its name in order to run it ;)

                                                                                    1. 2
                                                                                      • Various C/C++ sanitizers: ASan, UBSan, etc
                                                                                      • Earlier than Sanitizers: Valgrind (not working on recent macOS due to restrictions incorporated by Apple, but works on Linux)
                                                                                      • Fuzzers: libfuzzer, honggfuzz

                                                                                      I think those are the most influential tools for me, they’ve shown me that it’s nearly impossible for me to write safe code using C++ or especially C, as well as there is no such thing as easy file format parsing code ;)

                                                                                      1. 2

                                                                                        A lot of the nastiest bugs come from components that are all correct in isolation but interact in a dangerous way.

                                                                                        Well, let’s say people want to build a bridge. They start the construction work from two sides at once, so it will be faster. They want to join those sides in the middle. So after a month of construction they finally join and they discover that they are off by 1 meter, who’s fault is this? The system fault? Earth’s fault? Maybe Isaac Newton is the culprit?

                                                                                        I think it’s the fault of some person who was involved in the construction process. Either designer, or maybe a person who’s job was to verify the requirements are being correctly implemented, I don’t know, but I do know that someone has done a sloppy job.

                                                                                        Saying that it is the fault of the system is a manifestation of incompetence, because if you say this, it means that you probably don’t know where exactly the problem is, don’t even know who’s fault it was, as well as you don’t know how to prevent this fault from occurring again.

                                                                                        1. 6

                                                                                          Well, let’s say people want to build a bridge. They start the construction work from two sides at once, so it will be faster. They want to join those sides in the middle. So after a month of construction they finally join and they discover that they are off by 1 meter, who’s fault is this? The system fault? Earth’s fault? Maybe Isaac Newton is the culprit?

                                                                                          Last year I interviewed a bunch of hybrid trad/software engineers, and my main takeaway was that all analogies by software engineers about trad engineers are wrong. One person didn’t have this exact issue, but had a very similar one. On investigation the root cause was something like “the soil under one particular support compacted slightly differently when it was frozen and it rained”, in which case the next questions were 1) why was that enough to throw things off, 2) why wasn’t that detected, 3) is that something they should add to their process, or was the overhead enough to make it unfeasible, 4) …

                                                                                          Saying that it is the fault of the system is a manifestation of incompetence, because if you say this, it means that you probably don’t know where exactly the problem is, don’t even know who’s fault it was, as well as you don’t know how to prevent this fault from occurring again.

                                                                                          It’s the exact opposite. If you say it’s one person’s fault, you leave all of the systemic issues in place to keep causing problems later. Historically, this approach has failed again and again. For Nancy Leveson’s Engineering a Safer World:

                                                                                          During and after World War II, the Air Force had serious prob-lems with aircraft accidents: From 1952 to 1966, for example, 7,715 aircraft were lost and 8,547 people killed [79]. Most of these accidents were blamed on pilots. Some aerospace engineers in the 1950s did not believe the cause was so simple and argued that safety must be designed and built into aircraft just as are performance, stability, and structural integrity. Although a few seminars were conducted and papers written about this approach, the Air Force did not take it seriously until they began to develop intercontinental ballistic missiles: there were no pilots to blame for the frequent and devastating explosions of these liquid-propellant missiles. In having to confront factors other than pilot error, the Air Force began to treat safety as a system problem, and System Safety programs were developed to deal with them.

                                                                                          1. 5

                                                                                            How do you build a bridge from two sides and make them meet in the middle? Imagine it’s never been done before. How do you ensure they actually meet in the middle?

                                                                                            Well, if you’re good at trying to build bridges, you sit down, ideally with some other smart people with a broad spectrum of disciplines, and you write down everything that could go wrong with the process. You figure out how wrong each thing could go, and you come up with a plan to mitigate each thing. Then in the real world, something happens that you didn’t anticipate (and often literally couldn’t anticipate), you work to understand it, and figure out how to compensate for it. Then the next time someone builds a bridge starting from both sides at once, they learn from your mistakes.

                                                                                            Case study: SpaceX rocket explosion of Sept 1, 2016. A rocket exploded due to a complicated and not super likely series of events that made a composite tank fail. As far as I understand, nobody foresaw this happening… because nobody had ever used composite tanks carrying helium dunked in liquid oxygen at the temperatures that SpaceX was working with. It was a new and unforeseen failure mode. Who did a sloppy job there? The person who wrote the requirements? The person who signed off on them? The person who designed the tank to those requirements? The person who manufactured the tank?

                                                                                            That rocket and payload cost, I dunno, something like a couple hundred million dollars. Compare with, say, a major AWS outage or two. Some of those have probably cost about as much, all told. And you know what? Nobody’d ever built AWS before either.

                                                                                            Things fail. Engineering is a process of planning to minimize failures, and testing to try to catch failures before they matter, and then if something fails anyway, figuring out how it happened to ensure that they don’t fail the same way twice.

                                                                                            1. 2

                                                                                              There is a difference between doing something that hasn’t been done before, and doing something that has a well known production methodology. You’ve assumed just the first case, but I had an impression the article talks about all cases.

                                                                                              It’s true that people make mistakes, even in cases where the methodology is well known. That’s why when a guy from my team makes a mistake in the code, because he didn’t perform some null check, I’m always telling – people make mistakes, let’s do a fix, release update and we’re done. That doesn’t mean the problem wasn’t his fault. It was his fault; we only choose not to make any problem because of it, because mistakes happen all the time, and I’m certainly not an exception.

                                                                                              Contrary to this situation, where a new technology is being worked on, so that the majority of people are not competent in it (this is a normal situation; it’s impossible to be competent in an area that is new) it also will be someone’s fault. Sometimes the supervisor won’t even know who should be doing additional verification because the area still hasn’t been researched that well in order to know what methodology to use, but this only means that the manager is at fault here, because the manager tries to do something that he doesn’t know that much about. In cases of companies that want to be pioneers, this fault and losses generated by the accidents are taken into consideration when building business plans, and sometimes even expensive faults are still acceptable, but I don’t think it’s okay to say that nobody is to blame for any accidents.

                                                                                              As for your question, I have no idea who was to blame for the SpaceX explosion, because I don’t know anything about rockets.

                                                                                              As far as I understand, nobody foresaw this happening… because nobody had ever used composite tanks carrying helium dunked in liquid oxygen at the temperatures that SpaceX was working with.

                                                                                              And this makes the accident okay? I mean, if someone doesn’t think about bad outcomes because the people are outside of their competence, then it’s okay to make mistakes? I still think that there was a person that should think of him/herself as being accountable for the fault. I’m not saying the person should be fired from SpaceX or anything; it might be the case that this person is still the best person for the job and still nobody would do it better. But saying that it was nobody’s fault tells me only that someone doesn’t have enough information to be able to tell what exactly went wrong (e.g. in the production process methodology).

                                                                                              Being wrong about something shouldn’t turn anyone into a black sheep. It shouldn’t put any social stigma on that person, because only the person that didn’t do anything in his life can say that he’s always right. I think that any punishments or stigmas should be conditioned by the answer to the questions: 1) ‘what this person has done in order to minimize the risk’ and 2) ‘what was done in order not to make the same mistake again’, and it shouldn’t be about if it’s the person’s fault or not.

                                                                                              1. 3

                                                                                                I think that we’re both conflating two different things: Whose FAULT something is, vs. whose RESPONSIBILITY something is.

                                                                                                I think that any punishments or stigmas should be conditioned by the answer to the questions: 1) ‘what this person has done in order to minimize the risk’ and 2) ‘what was done in order not to make the same mistake again’, and it shouldn’t be about if it’s the person’s fault or not.

                                                                                                This is exactly what I want, yes. The way I see it, “fault” is worthless for these goals. Saying “it’s my fault” doesn’t really help make anything better. Saying “it’s my responsibility” IS useful, it means someone is going to take action to make sure it doesn’t happen again. “Blame” is pretty worthless for actually getting anything done IMO, it just makes people afraid of failing. Failure is part of life. Blame and fault, as the original article says, “[do] nothing to help us fix defects.”

                                                                                          1. 6

                                                                                            In the issue comments I found repeatedly a proclamation that „All software is political“.

                                                                                            This is generally not true. There might be some „political“ software, but usually software is simply a tool. It is not good or bad* – it can be used for good or bad or neutral purposes, just depending on who and how is using that software.

                                                                                            And there is also software or development style that is explicitly apolitical – Sane software manifesto says:

                                                                                            In order to contribute, it must not be required: … to sign any political, religious or other proclamation or agree with it.

                                                                                            P.S. Yes, free software has some political undertone, or I would rather say ethical, but it is very strictly defined and there are clear boundaries that prevent bending and misusing this term. Free software can be used by anyone for any purpose.

                                                                                            *) now I am not talking about code quality, but about the ethical dimension

                                                                                            1. 13

                                                                                              The inception of the Free Software movement was inherently political, and the recuperation of that movement into a more business-friendly Open Source movement was also political. Licensing software using a FLOSS license is a political act.

                                                                                              1. 2

                                                                                                Yet the success of the open-source movement in relation to the failure of the free software movement (at least, according to their goals) is almost 100% due to the FSF’s politics. Companies would rather use open-source software rather than free software because there’s less legal bullshit to go through. Additionally, companies have been less inclined to license their own software with the GNU GPL and have chosen alternative licenses that are more permissive and don’t place so much burden on the author to “give credit where credit is due”.

                                                                                                I love the FSF, GNU, and the movement it all stands for. But in my opinion, the world has mostly left that concept of “freely available software that you have total control over” behind. Especially in the current “rental” climate where less software is actually owned by a user.

                                                                                                1. 5

                                                                                                  Companies would rather use open-source software rather than free software because there’s less legal bullshit to go through.

                                                                                                  You use company adoption as the yardstick for success here but I would counter that it is entirely irrelevant to the political goals of Free Software.

                                                                                                  (P.S. my use of the word recuperation above was deliberate.)

                                                                                                  1. 3

                                                                                                    Open source is hardly a success. It’s companies struggling over control of software for their own interest (that very often is not aligned with the interest of the community) or bright people working for free for companies and be happy about the theft of time and energy. Corporate adoption and investments for control is their own metric of success but arguagly one that reflects the wellbeing of the commons.

                                                                                                    1. 4

                                                                                                      hardly a success

                                                                                                      What? This makes very little sense. Most of the software running the Internet is open source. Throw a dart at the list of top 100 tech companies, they’ve probably open sourced major libraries that have gone on to spawn entire industries.

                                                                                                      The Linux kernel, ffs.

                                                                                                      I’m confused at your argument. What is it you define as “success?” Adoption? Growth? Longevity? Monetary return?

                                                                                                      1. 3

                                                                                                        Be useful to people, solve problems in the real world (ideally problems that aren’t created other open source software), make the world a better place.

                                                                                                    2. 0

                                                                                                      ‘Free’ and ‘open source’ are synonyms. Companies don’t use open source software instead of free software. Using open source software is using free software. Using free software is using open source software.

                                                                                                      Copyleft and permissive software licenses are all both free software licenses and open source software licenses.

                                                                                                      1. 2

                                                                                                        No, they are not synonyms. Free software does no need to be gratis, nor does open source software imply that you have the freedom to change and distribute that software - even in exchange for money - like free software gives you. This distinction has been made clear so many times by now that it is surprising to see the claim that these two are synonyms.

                                                                                                        1. 1

                                                                                                          No, they are not synonyms. Free software does no need to be gratis

                                                                                                          Nor does open source software.

                                                                                                          nor does open source software imply that you have the freedom to change and distribute that software

                                                                                                          Yes it absolutely does imply that you have the freedom to change and distribute that software. The Open Source Definition requires:

                                                                                                          “The license must allow modifications and derived works, and must allow them to be distributed under the same terms as the license of the original software.”

                                                                                                          This distinction has been made clear so many times by now that it is surprising to see the claim that these two are synonyms.

                                                                                                          It’s been stated over and over again by everyone from the FSF to the Open Source Initiative that, ignoring some very idiosyncratic edge cases, ‘free software license’ and ‘open source software license’ are synonyms. The cases where the FSF approves and the OSI doesn’t or vice versa is generally because one of the them considers it too vague to be a valid license, such as with the Artistic License v1 or some issues with public domain licenses in Europe. Or to put it another way: if you put the FSF people in charge of evaluating licenses under the OSI definition and the OSI people in charge of evaluating licenses are free or not, they’d come to the reverse conclusions. The requirements for something to be a free software license are virtually identical to the requirements for something to be an open source software license.

                                                                                                          RMS: The term “open source” software is used by some people to mean more or less the same category as free software. It is not exactly the same class of software: they accept some licences that we consider too restrictive, and there are free software licences they have not accepted. However, the differences in extension of the category are small: nearly all free software is open source, and nearly all open source software is free.

                                                                                                          1. 1

                                                                                                            “The license must allow modifications and derived works, and must allow them to be distributed under the same terms as the license of the original software.”

                                                                                                            If the original licence says the software can not be used for or distributed by individuals and companies who work in a certain industry - defence is an example which has come up several times, police would be another - that software is not free software.

                                                                                                            1. 1

                                                                                                              Nor would it be open source software.

                                                                                                              Have you ever actually read the open source definition?

                                                                                                              “The license must not discriminate against any person or group of persons.”

                                                                                                              “The license must not restrict anyone from making use of the program in a specific field of endeavor. For example, it may not restrict the program from being used in a business, or from being used for genetic research.”

                                                                                                              1. 0

                                                                                                                OK, if that clause is part of the open source licence (there are many) the distinction gets less clear. This used to be a problem back in the day when ‘open source’ and ‘free software’ started to be recognised as two possibly distinct licence types. It still is for some licences (e.g. [1], “The license above does not apply to and no license is granted for any Military Use of the Licensed Patents.” but they do seem to be getting more rare.)

                                                                                                                [1] https://www.cs.ucdavis.edu/~rogaway/ocb/license2.pdf

                                                                                                                1. 1

                                                                                                                  OK, if that clause is part of the open source licence (there are many) the distinction gets less clear.

                                                                                                                  That clause is a restriction on what constitutes an open source license. It applies to all open source licenses by definition.

                                                                                                                  1. 2

                                                                                                                    Ah, but that is where the shoe wrings. Open source has become a generic term which is applied to any and all software for which the source is not hidden. The OSI has tried - and, as far as I can see, failed - to rein in the term to only encompass those licences which abide to the directions set forth in their licence, other software should be called ‘source-available’ or similar such constructs.

                                                                                                                    1. 1

                                                                                                                      the shoe wrings

                                                                                                                      I love this translation of “där skon klämmer”, but I think a better English is idiom is “there’s the rub”.

                                                                                                                      1. 2

                                                                                                                        It is actually a translation of “daar knelt de schoen”, an idiom which exists in many Germanic languages (the one cited being Dutch), English being one of them. Proverbs citing shoe-related woes have been used for many centuries, Shakespeare and his contemporaries were rather fond of these expressions which can be found scattered around their proze: I feare me theres s shooe wrings her i’th instep, of my yong [sic] Shooemakers making was a way of referring to a pregnant woman in a play from 1540.

                                                                                                                      2. 1

                                                                                                                        Open source has a definition and is still being used according to that definition. I have never seen anyone refer to anything that isn’t open source as ‘open source’ without having many comments pointing out the incorrect use of language and then usually an apology.

                                                                                                      2. 1

                                                                                                        Most developers who write open source (or free, if you will) software either aren’t very familiar with the politics of Free Software, or explicitly reject it. A well-known example of this is Linus Torvaldus, but there are many more.

                                                                                                        Many who use the GPL simply want to ensure people contribute code back, nothing more. I think Free Software as a political concept is not particularly common, even among people who contribute to it, and even less common outside of it.

                                                                                                        1. 2

                                                                                                          Torvalds doesn’t reject Free Software, he rejects the tivoization clause(s) in GPLv3.

                                                                                                          1. 2

                                                                                                            He’s been pretty critical of the concept of Free Software, and sharply critical of Stallman and the FSF, and not just about the GPL3. He’s often said that he mostly sees open source and the GPL has a simple practical matter (“it just works best, and sending back your patches is just basic fairness”), and has also said that he doesn’t really mind that proprietary software exists (which is quite different than the political position of the FSF).

                                                                                                      3. 17

                                                                                                        Nothing is apolitical, because nothing can exist outside of the political (social) climate in which it is created or consumed. Calls to keep politics out of X are political, however, because they distill down to a tacit defense and support of the status quo.

                                                                                                        1. 9

                                                                                                          This argument has no merit, as you could equally apply it to the choice of condiments you put on a hotdog.

                                                                                                          1. 5

                                                                                                            It’s political in a very narrow scope; the one of producing the software. The reverse conclusion that some seem to make is that it is a justification to throw even more politics into software development. It is used as a strong-arming argument that disrespects the intent of the author.

                                                                                                            1. 8

                                                                                                              Calls to keep politics out of X are political, however, because they distill down to a tacit defense and support of the status quo.

                                                                                                              You have to be trolling. Some people are just sick of everything being a political discussion.

                                                                                                              1. 13

                                                                                                                I think the counter here would be that, if you are sick of discussing a political issue, it is likely because the issue does not affect you, which is in some cases due to what might be described as social/cultural/whatever privilege: hungry people don’t often become “sick of” talking about food.

                                                                                                                I’m a straight white upper class American male and I both empathize somewhat with your sentiment and do often get tired of every discussion becoming political (hence why I read lobste.rs 100x as often as the orange site) but I must concede some validity to the argument that my position in society is what lets these political discussions be just “boring” to me instead of terrifying and immediately relevant.

                                                                                                                1. 13

                                                                                                                  I think the counter here would be that, if you are sick of discussing a political issue, it is likely because the issue does not affect you

                                                                                                                  And sometimes, you are powerless to affect it.

                                                                                                                  Racism exists everywhere in the world, but the form it takes in Bulgaria and elsewhere in the world is unlikely to line up with the American discourse. Imagine how you’d feel if people vehemently demanded you pick a side about the Indian citizenship law, and saw your unwillingness to comply as an indirect endorsement of the other side’s position? Because this is what the internet is like for non-Americans, at the moment.

                                                                                                                  1. 6

                                                                                                                    if you are sick of discussing a political issue, it is likely because the issue does not affect you

                                                                                                                    Bear in mind that even activists and volunteers need to decompress.

                                                                                                                    One can’t be 24/7 involved in the same thing or you will burn out. Not every conversation can be about the same topic, over and over again.

                                                                                                                2. 3

                                                                                                                  Nothing is apolitical

                                                                                                                  It’s not true. The action itself can be apolitical at the same time when analyzing the results of the same action can be political. If I stare at a tree because I find it relaxing, it’s not political. But the realization that I’m at the park staring at the tree instead of vandalizing public monuments in a name of some idea, can be political.

                                                                                                                  It’s similar to mathematics. If I eat an apple because I’m hungry, the action itself is not mathematical. But the number of apples in the area I live in will decrease by 1, so it will be a mathematical result only if you use mathematical reasoning when interpreting the situation.

                                                                                                                  1. 3

                                                                                                                    Maybe this would help you understand:

                                                                                                                    … People are different and have various opinions on various topics. But the pure free software ideas are a common interest which leads people from different groups and with different backgrounds to cooperation and shows them the way how to talk each other and eventually build a friendly and respectful community. It is much better than if people from different groups stay in their own bunkers and just bark at each other.

                                                                                                                    Future of the Free Software Foundation

                                                                                                                    1. 2

                                                                                                                      If you want to make something political you can, not matter what it is. Eating a peanut butter sandwich can be political. Washing your hair can be political. Walking to your work can be political. Washing your hands can be political.

                                                                                                                      That does not mean these things are political, only that you choose to make them political. This is a personal choice which does not need to - and often does not - transfer to others who get to make their own choices about what they consider to be political and what not.

                                                                                                                      That last statement is political, it is the freedom of thought and expression which is one of the pillars most of our societies are built on. Think well before you demolish this pillar, it was built for a good reason.

                                                                                                                      1. 0

                                                                                                                        Let’s suppose, for the sake of argument, someone came into your supermarket and demanded you change the labels on the white pepper and black pepper (to, say, retted and unretted pepper, or pepperseed spice and peppercorn spice, or any other term that didn’t mention colours) because the words ‘white’ and ‘black’ are racist and political.

                                                                                                                        You respond ‘no that’s ridiculous, there’s nothing political about white and black pepper’. They respond ‘everything is political’.

                                                                                                                        Ponder that.

                                                                                                                        1. 4

                                                                                                                          You think you’re making a point, but you’re not.

                                                                                                                          1. 3

                                                                                                                            Well, for example, electron recently changed whitelist/blacklist to allowlist/blocklist, and Chromium did the same some time ago.

                                                                                                                            1. 5

                                                                                                                              A blacklist is literally a list of bad things, which are clearly bad because they have the ‘black’ quality.

                                                                                                                              Black pepper is a tasty spice.

                                                                                                                              1. 1

                                                                                                                                Nonsense. Bookkeepers and accountants rejoice when the numbers are ‘in the black’ but shudder to see them go red. Here, black is good, red is bad. Is this a different black from the one used in the blacklist?

                                                                                                                                1. 1

                                                                                                                                  A blacklist is a list of bad things which are bad because the colour black is associated with negativity in our culture, while white is associated with good. That has nothing to do with skin colour. It’s honestly pretty cringe to try to force an association between the word ‘black’ and black people everywhere the word exists. ‘Blacklist’ has nothing to do with black people and black pepper has nothing to do with black people. Black MTG cards have nothing to do with black people. Whitelist has nothing to do with white people, white pepper has nothing to do with white people, white MTG cards have nothing to do with white people.

                                                                                                                                  1. 1

                                                                                                                                    white pepper has nothing to do with white people

                                                                                                                                    No shit.

                                                                                                                                    It’s honestly pretty cringe to try to force an association between the word ‘black’ and black people everywhere the word exists.


                                                                                                                                    ’Blacklist’ has nothing to do with black people

                                                                                                                                    Nothing wrong with disagreeing with the majority of linguists if you’ve got an informed opinion.

                                                                                                                                    Perhaps demonstrating some familiarity with the relevant literature (or maybe even linked a source for this unfounded claim) would help people be a little more charitable in their reading of your ideas.

                                                                                                                                    1. 2

                                                                                                                                      Nothing wrong with disagreeing with the majority of linguists if you’ve got an informed opinion.

                                                                                                                                      It’s been used in the English language for hundreds of years (as far back as the mid 1600s, if I remember correctly), rarely, though its first popular use was in the 20th century in reference to blacklists of union members. It’s a blacklist in the sense that the list itself is black. A blacklist was originally two words (as with many compound words) and its first usages are in a more poetic sense: a ‘black list’ where ‘black’ is used poetically to mean dark or evil. ‘His black list’ i.e. ‘his evil list’. It is not a list of ‘blacks’, never has been. Its use far predates modern American conceptions of race.

                                                                                                                                      Now you might respond by saying that using a term that has its popular origins in the suppression of unionism to be ‘problematic’, but etymology is not the same as meaning. Words do not mean precisely what they were coined to mean, and it would be absurd to expect everyone to inspect the etymology of every word they speak to make sure it isn’t associated too closely with whatever topic has fallen under the gaze of the keyboard warriors on Twitter and is now considered ‘problematic’. There are probably heaps and heaps of completely normal terms people use all over the place that have their origin in something that, under close inspect without the proper context, might seem ‘problematic’.

                                                                                                                                      Should one not use the word bugger? Or hysterical? Are no can do and long time, no see racist? What about uppity or hooligan? Grandfather clause? Call a spade a spade? What about gypsy or Eskimo or American Indian where despite the popular view among white Americans that they’re racist or outdated terms, they’re actually preferred by many of the people they’re meant to describe over Romani (lots of whom aren’t Romani at all) or Inuit or native American?

                                                                                                                                      Maybe instead of being offended on behalf of others, you just leave it to them to raise issues if they are actually offended? Getting offended by the origins of terms that have been free of offensive connotation for decades or centuries because a couple of keyboard warriors on Twitter decided that the best way to solve an issue like systemically racist police violence in the USA is to police what variables people use on GitHub…

                                                                                                                                      Perhaps demonstrating some familiarity with the relevant literature (or maybe even linked a source for this unfounded claim) would help people be a little more charitable in their reading of your ideas.

                                                                                                                                      If you’re going to make such a significant claim you should back it up with sources from the relevant literature. Language is not problematic-by-default. The onus is on you to prove that the term was coined in reference to race if you wish to claim that it is “problematic”. I’m not telling people what to do or calling anyone racist. I’m not making any extraordinary claims. I don’t see why any burden of proof falls on me.

                                                                                                                                      1. 2

                                                                                                                                        its first popular use was in the 20th century in reference to blacklists of union members

                                                                                                                                        Says who? (The wikipedia page for an active political controversy is not a source).

                                                                                                                                        Maybe instead of being offended on behalf of others, you just leave it to them to raise issues if they are actually offended?

                                                                                                                                        Firstly, I’m not offended by it; secondly, what idea would you have whether it was on someone elses behalf or my own if I were.

                                                                                                                                        I’m offended by longwinded, unsourced, nonsensical arguments on an otherwise-good-SNR technical forum.

                                                                                                                                        I don’t see why any burden of proof falls on me.

                                                                                                                                        You’ve asserted, without evidence, that ‘Blacklist’ has nothing to do with black people, which is sort-of the crux of the discussion. Not only are you raising flat assertions without a source, you’ve the gall to demand anyone who points out this is low-effort do the legwork for you. Generating bullshit is much easier than refuting it, and all that.

                                                                                                                                        EDIT: Oh. It’s you, but you’ve changed your username again. I’ll update my killfile, as usual.

                                                                                                                                        For anyone else as uninterested as I am in this inanity, a handy ublock rule is:

                                                                                                                                        lobste.rs##:xpath(//div[contains(concat(' ', normalize-space(@class), ' '), ' comment ')][.//a[contains(@href,'/u/mrr')]])

                                                                                                                                        1. 2

                                                                                                                                          You are a nasty piece of work.

                                                                                                                              2. 3

                                                                                                                                He is making a point though, even if you choose not to see it. You might not agree with it but that does not imply the point doesn’t exist. In other words, a single person or a group does not get to be the purveyor of truth in an open society which allows freedom of thought and freedom of expression.

                                                                                                                            2. -2

                                                                                                                              Excellent. Now these monsters who support the status quo have no place to hide.