1. 30

I created a short survey to gauge opinions around programming and would love to solicit opinions from other lobsters. If you have a couple of minutes, please give it a whirl.


  2. 41

    I filled this out but I think several questions measure multiple dimensions without providing answers along those multiple dimensions. For example, the “distributed version control” question, the closest thing to a “no” is “just copy files around”. But what if I actually want a centralized version control, like svn or rcs or cvs? Maybe I think version control is important but being distributed isn’t.

    The “static type checking” question is similar. There are a range of values between “cannot live without it” vs “convenient as long as most types are inferred”. Does “can’t live without it” mean I’d rather be writing Java than Python or Ruby? I’ll often times take Python over Java if those are my two options when what I really want is Ocaml, and this has nothing to do with if types are inferred, it’s that I don’t like the Java type system and language all that much. Even if I had to explicitly type all of my Ocaml, the actual type systems are distinct enough that there is special value there not captured in the question.

    The Unit testing question as well, my options for how I value unit testing is that it’s the most important thing ever, it’s only useful for the core functionality, not that useful compared to other tools, or a waste of time. But where is the view that it’s “complementary”. Or perhaps that it’s not value for core functionality but actually valuable for functionality a the edges?

    Doing a good survey is hard, this is why professional surveys have hundreds of questions, each question needs to capture a single dimension. I don’t think there is a ton of value to be drawn from the results of this survey.

    1. 22

      Had similar problems. Most of the answers describe a position I don’t really hold. I’d consider numerical scales or ‘very beneficial to not beneficial at all’ rather than colouring the opinions.

        1. 4

          The “concurrent programming” question is annoying…there are a lot of little useful problems that simply don’t require concurrency thinking, but that isn’t adequately captured by the survey.

          The GC question is similar: manual management or slab allocation for lots of little allocations can be a huge win, even though the rest of the application logic can be handled with slow-updating GC just fine (this is especially prevalent in game or graphic programming). There wasn’t an option for that, though.

          I eventually game up on the last page–this survey had too many strawmen in the options. :(

        2. 17

          The results here will just be nonsense if they aren’t segmented based on ‘programming sector’. People writing firmware for a Boeing aircraft in Ada vs a consumer web startup in Ruby aren’t going to have comparable opinions about software. Probably one of the biggest fallacies around giving advice in our profession is that ‘everyone is working on software like you are working on’.

          1. 8

            In the same vein, even my individual answers change between platforms that I work in. For example, ask me about unit testing a rails server and I’ll say “imperative with 90% coverage”. Ask me about unit testing a mobile app and I’ll say “not worth the effort to set up”.

            1. 5

              Exactly… I do primarily web applications (Ruby/Clojure/Clojurescipt/etc) and so GC is not something I would ever even consider doing without. Obviously a different story if you do embedded devices or systems programming though.

              1. 1

                Largely agreed, but I’m not sure how to design a study that deals with that adequately. It would be great to not have to make assumptions about what programming sectors exist. Most programmers have not worked in every sector and it’s easy to forget about those we haven’t got personal experience with, and it would be nice to use a survey to check our intuition against the reality.

                Maybe a free-form field like “how would you describe the type of programming you do, in terms of the technical constraints and the business model?” Then cluster based on distance from the other answers, then try to summarize this field to label each cluster?

                I’m not a data scientist, and shouldn’t really pretend to be. :)

              2. 10

                I’m skipping this because most of the questions don’t give answers that I’m comfortable choosing. It seems like they all are given by pro-X/anti-X extremists, or they try to assume too much and put words in my mouth, or they don’t really cover the entire spectrum of answers. A lot of them seem more opinionated than I’d like, too.

                One suggestion would be removing everything after “but…”, “because…”, or “as long as…” to all of the answers in the languages section.

                1. 9

                  In the methodology section, why does waterfall have a positive and negative response, while agile has those plus a so-so response?

                  1. 17

                    For Waterfall, what I really wanted was, “It’s a straw man used to sell Agile”.

                  2. 6

                    What, never?
                    [ ] No, never
                    [ ] Well, hardly ever

                    1. 2

                      Don’t patronise them, sir – pray, don’t patronise them.

                    2. 5

                      Managed memory via garbage collection: I chose “Convenient as long as the GC pauses aren’t too long.”, but my real preferred memory management system is automated reference counting; the question seemed to be a pure axis of GC <-> manual.

                      1. 4

                        The response to the inheritance question stuck out to me. I haven’t been around lobsters for long at all so it’s very telling of the “programmer demographic” here. The fact that 1/3 of people answered “by now we should all know that was a bad idea” indicates a huge reddit-like zeitgeist awareness (or trend following) to me. (Personally I still think that in certain situations, inheritance is an incredibly useful model for hierarchical structures, e.g. mobile UI work, and I can’t fathom why someone would say otherwise–CMV please.) At the very least it shows that we’re not just a bunch of students or professionals working in Swing government contracting. Fantastic amount of discussion as well.

                        1. 1

                          (x) I use the right tool for the job

                          1. 3

                            That would be far more helpful if accompanied by a mapping of job type to toolset ;-p