1. 2

    Honestly, I don’t see why this post is resonating with people so much (which it clearly is!) Most of the author’s technical points are incorrect, or fail to acknowledge the objective superiority of the newer solution. And most of his issues appear to be self inflicted.

    No one is saying you need all these fancy new build tools and package managers for brochureware sites. But they are extremely handy when building actual applications.

    1. 9

      objective superiority of the newer solution

      Is that so? Even though it were somewhat different topics (Object Oriented Programming, Syntax Highlighting, etc.) a lot of things that people used to call objectively superior turn out to be “subjectively superior” at best if one actually bothers to look at it in an objective way.

      Other than that I am inclined to claim that it’s really hard to define superiority of software or even techniques. Few people would argue about the superiority of an algorithm without a use case, yet people do the same thing with technologies and call them better, without mentioning the use case at all.

      I think a problem of our times is that one loses track of complexities and anatomies of problems, seeing only a very small port of a problem. Then we try to fix it and on the way move the problem to another place. When that new problem bothers us enough we repeat the process.

      This looks similar to looking for something like the perfect search or index algorithm for every use case, even disregarding limits such as available memory. It’s good that people love to go and build generic abstractions. It’s of extreme importance in IT, but it’s easy to end up in a state where progress kind of goes in a circle, when disregarding limitations and trying to find a “one size fits all”.

      In web development this would be a framework for both real time, non real time, for rest based microservice architectures, but also supporting RPC, real time streaming, as well as being a blog engine and what not, while both being very low level, going down to the HTTP or even TCP level and a blog at the same time, making all of that equally easy.

      This sounds great, and it’s certainly not impossible. However, it still might not be the right way to go and someone will always find some use case that they don’t see covered well enough. Something that isn’t easy enough for their use case out of the box and something that can be done in a more easy way by simply writing it from scratch, maybe just with some standard library.

      I don’t say that projects like that are bad. However, since they get reinvented over and over I think it would make sense to instead of trying to invent tools for everything it might be worthwhile do strive for completing or extending the tools to pick from.

      And I think that is what’s starting to happen more and more anyway. I even would say that the frameworks we see today are a symptom of it. The set of tools is growing and instead of being multitools like they used to be a decade ago (therefor also not working well with others) they nowadays seem more to be like tool belts, with many already available tools in them.

      Or to say it in more technical terms. Frameworks nowadays (compared to a decade or so ago) are less like huge libraries forcing you into a corsett, but more software or library distributions with blueprints and maybe manuals on how things can be done.

      1. 7

        No one is saying you need all these fancy new build tools and package managers for brochure-ware sites. But they are extremely handy when building actual applications

        Except that I see people say that all the time. I see them say it at work. I see them say it on social media. I see them say it at conferences. There’s always some reason why that fancy new tool is needed for the static site they are working on. They need it so they can use LESS or SASS for the CSS. They need it so that they can use react to build the html statically before they serve it… (Yes. I’ve really heard someone say that.). They need it because that one metrics javascript tracking library is only available from npm and they can just use that other build tool to ensure it’s in the right place.

        This post resonates with people because while they understand that it should be the way you say it is. They can see people saying clearly silly things with a whole lot of unreasonable excitement everywhere they look. It’s so prevalent that when they see someone in web-dev saying something so eminently reasonable they can’t help but stand up and applaud. It’s not a problem with the technologies themselves. It’s more of a problem with the way the culture looks to the people observing it.

        1. 1

          Except that I see people say that all the time.

          Have an example? I’ve not seen that. I’ve seen lots of tutorials showing how to do $simpleThing with $complexTool, but that’s just because small examples are necessary. I’ve not seen any claims that $complexTool is required for $simpleThing.

          1. 2

            It might be a matter of emphasis. But when the only examples you can find for your responsive static brochure site are the examples you reference above then it sends a perhaps unintended message that this is how you do those things. I can’t point to specific examples around in person conversations for such things for obvious reasons. But in a way you make my point for me. It’s the reason why when you go to many sites that should be just html css and small amount of javascript you end up downloading MB’s of javascript. From the outside looking in it certainly appears that as an industry we’ve decided that this is how you do things, so why fight it?

      1. 5

        This is a fine introduction to an article, but it stops right when it gets interesting. :-/

        1. 3

          Thanks! I’m working on the next one which will go into a lot more detail. Trying to balance the TL;DR nature with going into enough detail so I decided to start with more of an overview before getting down into business. I appreciate the feedback, I’d appreciate knowing if you like the more detailed version coming next week.

        1. 16

          Software has become easier…in certain ways.

          I think this is worth reflecting on a bit.

          In the late 90’s when I installed Linux for the first time, this was back when setting up X11 had a big warning that if you got your monitor refresh rate wrong you could damage it, I managed to install the OS, build my own kernel, and get the whole graphics stack running, and connect to the internet…without using the internet. I only had one computer and it was busy being barely functional while I was doing this. I then went on to write Hello World in C, which required putting a few lines into a .c file and using gcc to compile it. Pretty straight forward.

          I recently started trying to make a frontend project using TypeScript, React, and BlueprintJS. Discounting the hours I spent trying to figure out which frameworks to even use, I could not have accomplished my Hello World without around 1000 dependencies in NPM and stackoverflow. While I’m getting there, I’ve found the experience really challenging. Error messages are bad. Components make all sorts of silly assumptions. Even just how things fit together is really challenging to discover.

          I’m not saying installing Linux that first time was easy but I don’t feel that things are easier now. The author tries to say that business logic grows very complex. But this doesn’t match my experience. Instead I find that the complexity is just getting things to work because every framework is huge. Most Hadoop jobs I see are dead simple but they are 3000 lines of junk to get the ten frameworks one needs to count words to play well together. I’ve spent more hours just trying to get a Java dependency to work in my system than writing the code for that feature I’m using the dependency for.

          I think the author is right in that many developers today just do things where the reason isn’t backed by any kind of evidence or even makes sense after a few minutes of thought. Microservices are like this. I’ve seen a lot of places go hog-in on microservices without appreciating that their system is simple enough that maybe they could get away with 2 or 3 big services, or even one if they really wanted, and dramatically underappreciate the cost of microservices. Microservices have created an entire industry of solutions to fix a problem that many people impose on themselves for no particularly good reason.

          What I’m saying is that we need to head back in the direction of simplicity and start actually creating things in a simpler way, instead of just constantly talking about simplicity. Maybe we can lean on more integrated tech stacks to provide out of the box patterns and tools to allow software developers to create software more efficiently.

          I don’t think the author gives an operationally useful definition of simplicity. It sounds like they want a big platform that has all sorts of complicated stuff integrated into it, an idea that I don’t think is very simple. A more “integrated tech stack” usually just means you push all of the complexity into one place rather than reduce it. While a bit extreme for me, I think it’s unfortunate that Handmade hasn’t picked up more steam.

          I think it’s important to note, as well, that IME, a lot of software complexity is out of ignorance. Many developers just don’t know what simplicity is or how to achieve it. If you’re a JavaScript developer all of the examples you’ll run across are huge. Angular 2 installs 947 dependencies on a blank project. React installed 200 something. Maybe Go is the best example today of simplicity? Maybe all developers need to go through a six month course where they solve all problems with UNIX pipes.

          1. 3

            I agree with your assesment, I think there are a couple of different factors at play.

            To be fair, package systems, dependency management, dll hell has been a problem for a loooong time. One of the axis this difficulty splits on is richness of the standard library. For example, c programs on linux have libc linked in at runtime which offers a fair bit of functionality but requires a lot libs for anything else. Go programs compile a significant runtime library into the final exe that includes a whole lot of functionality. Go has a very rich library built in. Javascript has near zero standard library, and no real module system. Hence npm and dependency hell++.

            One thing that stands out to me today is how prevalent network backed package managers have become; maven, npm, heck debian and yum too. I also attempted to install linux back in the day, but I failed, because without a network connection, I coulnd’t use anything or research anything not on the disks I had available. Today, with a network connection you have access to all the dependencies and information you need. Most all languages and platforms have dependency managers and repositories available. In other words, (some) things are so much easier now.

            Which all contributes to the eternal september we find ourselves in today. The barrier to entry is a lot lower, which is a good thing. Every year there are more and more fresh/green developers, and fewer and fewer old experienced developers. Those of us who fought to do anything in the old days are growing few and fewer. The new generation didnt’ suffer like we did, and that’s ok. I think they suffer in different ways, as your lament about web development shows. The reality is, a lot of the cruft in javascript land is solving real problems, as much as I hate to admit it.

            It all brings to mind this quote from Alan Kay (~2004):

            Computing spread out much, much faster than educating unsophisticated people can happen. In the last 25 years or so, we actually got something like a pop culture, similar to what happened when television came on the scene and some of its inventors thought it would be a way of getting Shakespeare to the masses. But they forgot that you have to be more sophisticated and have more perspective to understand Shakespeare. What television was able to do was to capture people as they were. So I think the lack of a real computer science today, and the lack of real software engineering today, is partly due to this pop culture.

            1. 2

              FWIW, I agree with the overall gist of your post. However…

              Angular 2 installs 947 dependencies on a blank project. React installed 200 something.

              The @angular/core library has one hard dependency on tslib. React has a total of 16 direct and indirect dependencies. If you use a starter kit or one of the cli tools, they will install many more, but that’s because they’re depending on entire compiler ecosystems.

              1. 2

                I’ve seen a lot of places go hog-in on microservices without appreciating that their system is simple enough that maybe they could get away with 2 or 3 big services, or even one if they really wanted, and dramatically underappreciate the cost of microservices. Microservices have created an entire industry of solutions to fix a problem that many people impose on themselves for no particularly good reason.

                I can’t read this without hearing “I want to work on cool things” over and over. That’s what everyone says, right? I want a job where I can work on cool things. And every chance that’s presented to shoehorn in a cool solution to an otherwise simple problem is taken. Isn’t this exactly what we saw with “big data”? Where a company’s “big data” could fit onto an couple of expensive hard drives, but everyone wanted to use Hadoop or write their own distributed code? Hell, I fell into this trap all the time a few years ago.

                Another aspect of this is that we as programmers are really, really bad at estimating how efficient an approach is and how demanding a problem is. It’s why wise performance people (alliteration^2!) always shout at you “if you haven’t profiled it then you don’t know how fast it is!” And they’re right. And of course they’re right. What we work with, as you’ve noted, is horrendously complicated. But it sure feels great to stand back and say “well, a microservices approach would be a great fit here, and help us tackle our volume/latency/whatever requirements (that haven’t been measured), because partitioning the problem is more efficient (an unestablished claim), and our service will be more reliable (if it’s engineered correctly, maybe, again unestablished)”.

                Because acting like we know is just so much fun. I submit that this should be the definition of an “architecture astronaut”.

                Maybe “mechanical sympathy” exists, but if it does, it is hard won intuition born out of experience and lots and lots and lots of experimentation and measurement.

                Hell, I could set @peter off on a rant about this for—literally—hours.

              1. 18

                I really love legacy, and have been working on a DOS application that is in use since 1986. I helped to patch the blob to solve clock frequency issues around 2005, and virtualized it completely in 2015 (now allowing the app to reach files and print over the network!)

                I really hate legacy, and have found enormous amounts of garbage and myself struggeling not only with the incomprehensible and untangible structure of bloated software architectures, but also with consequent motivational problems. I even had to disappoint the customer, who invested a lot in me: despite the promising progress, fixing it for real would cost way too much.

                Sometimes I like to tell junior programmers some war stories, especially when they complain when working with the code of others. I romanticize what I call “software archeology,” and declare my love of unraveling the mysteries hidden behind the unknown. This I do for two reasons: I hope to motivate them beyond the point of misery (the trap, in which you believe you can not deal with the problem, and give up) and I hope to give them another perspective, as follows.

                Legacy is something to be proud of. It is the work of a precious generation (be it 30 years or 6 months ago), which dealt with perhaps completely different circumstances. Respect their work, just as you wish others will respect your own. Instilling this picture, that legacy is something great and is what you ultimately hope to produce, might result in work that one can be proud of: work that builds upon the great work of others, and tries to improve upon it!

                1. 4

                  “Your code could be legacy some day!” is a legitimate motivational phrase, in my opinion. There’s often a lot wrong with legacy code, but that’s because you’re often looking at it from a very different perspective. Understanding the original authors’ viewpoint is important. You might call it “code empathy”.

                  1. 1

                    I have made similar experiences with dealing with legacy. It’s easy to complain about certain design decisions, but really, sometimes it just seemed like a good idea at the time. Much can be learned from legacy code, too. Tricks that nobody uses today, space and memory optimization and such.

                    Grab a copy of some 70s or 80s source code and go to town with it sometime. Bring it into the 21st century. Enjoy the journey.

                    1. 1

                      Realizing that legacy code is code that did served well it’s purpose, is part of our path to professionalism.

                      But IMHO, this should not stop us to rethink things.

                      Most of complexities of modern software (and most of it’s flaws) come from legacy decisions that we didn’t challenge.

                      And I’m not only talking about JavaScript in the browsers, but even about things like dynamic linking, root users, using HTTP to deliver computations and so on…

                      All useful things, when they were thought. But today we can do it better.

                      1. 1

                        You know, I did get a pretty uplifted feeling reading that. The respect point is both incredibly spot on, and incredibly not the norm.

                        1. 1

                          Yes! I often really enjoy working in fifteen year old legacy code for exactly that reason. Sure the abstractions may not be great, but it is useful code that has served the company well all that time. My main job when working in legacy code is to not break what it gets right.

                          1. 1

                            This is all fine, but what turned me off a bit wrt consulting is a high frequency of modernizing legacy.

                            The code did not appear in a vacuum and there are always some of the original forces in place; budgets and schedules and such. Tradeoffs have to be made, and often these include not taking the upgrade path all the way to the latest version.

                            This leads to boredom, although the customers are always super and their domains where they work different from each other. It also raises the barrier to invest time in the latest and greatest, since the bulk of it would have to be done out of passion on free-time hobby projects.

                          1. 5

                            Would be nice to see a before and after…

                              1. 2

                                Interestingly, Preset omits all the Normalize fixes for MS Edge, which seems surprising to me.

                                1. 1

                                  Ah, I thought the parent meant a before/after comparison of old resets versus this new rest. Not a before/after comparison of the reset applied to a page.

                                2. 1

                                  Sure! Here’s a before/after: https://imgur.com/a/QjZl2

                                  And they’re online at:

                                1. 1

                                  I didn’t see a graph unless I used a browser without adblock, so the image may be hosted on a network that adblockers don’t like.

                                  1. 3
                                    1. 2

                                      Perhaps “visibility” is the culprit?

                                      1. 1

                                        This could well be. I’m using both Adblock and Ghostery and it’s very possible there’s some weird interaction there.

                                  1. 1

                                    If you’re using Node, Husky and lint-staged are nice additions. Husky sets up git hooks to execute any npm scripts with a matching name (e.g. precommit). Lint-staged passes only the staged set of files along to any linter or other check you’d like to run in your precommit hooks.

                                    1. 3

                                      No, lint-staged is another example of poorly thought out solution that is popular in the node ecosystem. lint-staged doesn’t run the linter against what is going to be committed, instead it runs the linter against the file as it is on disk. Their ‘solution’ for this is to run git add at the end, disregarding if the developer hadn’t staged everything!

                                      The solution I came up with at $WORK doesn’t automatically fix the code int the precommit hook because if I modify the staged version of the file, it is not trivial to determine what modifications belong to the staged chunks and which don’t. I only reject files that don’t pass the linter and print the linter report.

                                      When prepending : to the filename git show prints to standard output the staged version of a file. Node is good at handling streams so writing a script that runs ESLint/prettier/stylelint against the staged versions of the files is a less than a 100 lines of code. The gist of the idea is:

                                      #!/usr/bin/env node
                                      
                                      const { promisify } = require('util');
                                      let { exec } = require('child_process');
                                      exec = promisify(exec);
                                      const ESLintCLIEngine = require('eslint').CLIEngine;
                                      const cli = new ESLintCLIEngine({});
                                      const formatter = cli.getFormatter();
                                      
                                      function lintFile(filepath) {
                                        return exec(`git show :${filepath}`).then(ret => {
                                          const report = cli.executeOnText(ret.stdout, filepath);
                                          if (report.errorCount > 0 || report.warningCount > 0) {
                                            const errorResults = ESLintCLIEngine.getErrorResults(report.results);
                                            console.log(formatter(errorResults));
                                          }
                                          return report.errorCount === 0 && report.warningCount === 0;
                                        });
                                      }
                                      
                                      function lintFiles(filepaths) {
                                        return Promise.all(filepaths.map(lintFile));
                                      }
                                      
                                    1. 3

                                      I can’t comment on Silicon Valley, but I am quite aware that I have certain political opinions that are not safe to express in my (fairly typical) work environment.

                                      My politics are a mix of strongly “liberal” and strongly “conservative,” with few positions in the middle. For example, I favor a robust government healthcare guarantee, and also oppose abortion. I can mention these in passing to coworkers. But there are others I can’t. They happen to be “conservative” positions, but I don’t see it as a bias against conservative ideas in general. It’s more those specific issues.

                                      1. 3

                                        To be fair, abortion really isn’t a topic for work conversation anywhere outside of a medical setting, policy institute, or the like.

                                        1. 1

                                          I don’t disagree. I was using that as an example of something where merely noting one’s position in passing would be considered acceptable, while there are other topics (which I won’t list here) where even mentioning a difference from prevailing opinions would be ‭crossing a line.

                                          1. 4

                                            Big PHP fan, huh?

                                        2. -2

                                          I favor a robust government healthcare guarantee

                                          It’s only “robust” or a “guarantee” as long as the government hasn’t run out of other people’s money, which it eventually will (e.g. after having confiscated so much that being productive just isn’t worth it anymore).

                                          1. 2

                                            How far does it go? Roads? Police? Military? Air traffic control? Food safety? Education? What things are valid use for tax dollars?

                                            And every Western nation (and Japan) except the US has some form of universal healthcare and spends less per capita. If you’re worried too much of your money might go to helping others, you should be all in favor of systems that have dozens of examples of spending less of it to get more.

                                            As for “being productive”, I can at least provide my anecdotal experience from helping found three startups now: getting competitive, or even decent, healthcare coverage for our employees was by far our biggest challenge on the recruiting side. How many companies have not been founded because someone couldn’t risk losing their healthcare?

                                            1. 1

                                              “Eventually” has (frequently) been hundreds of years. I’m not expecting to outlive the state where I am (Australia) although the situation elsewhere seems more precarious.

                                              Here people have remained productive despite taxes close to 50%. I’m philosophically pretty libertarian, but specific implementations of states differ and my local one has worked well for some time in spite of some of the corruption being a bit obvious.

                                              1. 0

                                                Governments that control their own currency (e.g. the US) can create more of it, which is what the Fed does. That money hasn’t been taken from anybody else; it’s literally been created out of thin air. [Mind you, doing this too much can trigger runaway inflation, which would reduce the value of everybody else’s money.]

                                            1. 14

                                              A logo vulnerability for a local exploit without privsec for a software with a small market share, running on a system with an even smaller market share. I’m always interested about writeups, but I doubt the landing/marketing page was required.

                                              1. 14

                                                Yes but think about context: they’re working with GIMP. 😜

                                                1. 1

                                                  I think I’m missing the joke here.

                                                  1. 3

                                                    I think the joke is that since the vulnerability is in an image editor, that of course they had to make a logo for the vulnerability using the image editor.

                                                2. 5

                                                  I think being picky about the distinction between “logo deserving vuln” and “just a CSVCVE [1]” is silly, because whatever we were doing before to communicate security issues and get end users to pay attention wasn’t working at all. I don’t know if this is better, but at least it’s different.

                                                  [1]: I am currently working on a CSV issue… blah

                                                  1. 4

                                                    Its worth noting that the page says that no one from the Gimp team seems to take them seriously. The publicity that this site will get might help that change.

                                                    1. 1

                                                      Did you see what @hanno responded to this on twitter?

                                                      There were some comments criticizing me for making such a buzz about FLIMP. But one day later we have default HTTPS downloads for GIMP and people start working on merging patches & fixing stuff. It worked.

                                                    1. 16

                                                      I was just getting into GTD with Emacs org mode when I discovered Bullet Journals: http://bulletjournal.com/

                                                      With bullet journals, you keep everything in a small notebook in your pocket. It’s satisfyingly analogue, and less complex than GTD. I don’t do any of the fancy colouring or artistry. My journals are raw and scrawly, and don’t require batteries or a screen.

                                                      For everyday tech notes and writing, I still use org mode. But my personal and work stuff is now all tracked through bullet journals: a small pocket-sized Leuchturm 1917 for personal stuff, and a lined Blueline record book for work. I’ve been doing it for four months now, and it’s pretty decent. I think it’s worth a look-in if you would like an easy system to start with.

                                                      1. 5

                                                        I can’t enough good things about tracking my work with a bullet journal. I’ve been at it for almost three years and really appreciate the monthly (or weekly, as desired/needed) culling of unnecessary tasks.

                                                        1. 4

                                                          I love the bullet journal approach, especially how it is specifically intended to be customized and improved upon. I discovered it about 3 months ago, and it’s the only productivity system I’ve ever used that I’ve managed to keep using for more than a couple of weeks.

                                                          I personally use a dotted Moleskine notebook that is just small enough to stick in my back pocket so I can keep it with me everywhere I go.

                                                          1. 2

                                                            I use org-mode very heavily, but I don’t really like being tied to a computer 24/7. Given that you have experience with both, do you think there is a way to integrate Bullet Journals with org-mode? For now I have a pocket notebook that I will sometimes use to write lists of things that eventually just get transcribed to org-mode.

                                                            1. 1

                                                              After about a week of using a bullet journal I think org-mode serves a different but complimentary purpose. I’m using bullet journal for daily life tasks like dentist appointment and weekend plans with friends; org-mode for software, anything I do on the computer etc.

                                                            2. 2

                                                              Those who like bullet journals, but dislike the daily rewriting ritual / table of contents focus, should check out “final version perfected” by Mark Forster.

                                                              http://markforster.squarespace.com/blog/2015/5/21/the-final-version-perfected-fvp.html

                                                              This really helped me get out of a rut, and reboot my GTD workflow. Mind you, that happened in ~2012 or so, and only for a short period. I’m a full-time GTD person, and have been for a while. And i use org-mode and emacs to manage it.

                                                              1. 1

                                                                Been using a bullet journal here now for about 5 months, and absolutely agree! Mine’s not pocket sized, and I’ve recently teetered between using it for only work, or for work and other personal things. Seems to work best for just work, and I hadn’t thought of just getting another yet. Might give that a go!

                                                              1. 4

                                                                Don’t worry, this won’t be one of the I wake up at 4AM every morning and go for a 20km run… -‘inspirational’ posts

                                                                Hey in the summer I wake up at six and go running 7km! (In the winter I still wake up at six but go skiing instead)

                                                                This resonates pretty strongly for me, I’m a bit older (25), I’m not a woman, I havent studied abroad and I generally dont stretch much (but I do use an exercise ball for a chair)

                                                                But i also issued uni (after trying it). I did an actual collegiate level adults program instead of a bootcamp. I think the important parts of was she said was a balanced / healthy work / life and continous learning.

                                                                The continuous learning wont shore up an actual degree for most companies and you might have trouble finding permanent employment, but I’ve found that people very rarely look at your education when yhey’re hiring you for a specific contract, so theres a lot of potential in contracting / consulting.

                                                                1. 1

                                                                  “Hey in the summer I wake up at six and go running 7km! (In the winter I still wake up at six but go skiing instead)”

                                                                  What a way to hit the ground running in the morning. You’re living up to your user name. :) I’m more a gradually get going guy. I might try your method sometime in the future just to see what effects it has.

                                                                  1. 2

                                                                    It took a while to get a habit going and it left soon after it started getting cold, but it was really worth it. Morning exercise is still the best treatment to adhd I’ve yet to find.

                                                                  2. 1

                                                                    But i also issued uni (after trying it).

                                                                    Did you mean “eschewed?” I’m guessing so, but that confused me enough that I’m not positive. :)

                                                                    1. 1

                                                                      Definitely haha

                                                                  1. 4

                                                                    Is this a feature people actually want? I work remotely and can say it’s not that useful to share an IDE session, but full-screen sharing (especially with voice chat) is a lifesaver. At least once a week we share our screens to flip between a browser window, a terminal, AND the IDE to demo something or replicate a bug.

                                                                    I think it’s ironic that in the video they start off in Slack and share a link that you have to paste into VS. Slack itself has voice+video chat with screen sharing+control built in so there was no need to leave the app.

                                                                    1. 6

                                                                      Is this a feature people actually want?

                                                                      YES. I work 100% remotely, and a lot of my work is mentoring newer developers by pair programming thorny problems with them. Screensharing is kind of okay at this, but sometimes saying, “On line 39, you need a closing paren. No, not there, back 6 characters. No. 6 characters.” is a little too challenging.

                                                                      Slack itself has voice+video chat with screen sharing+control built in so there was no need to leave the app.

                                                                      I’ve used ScreenHero in the past (the product Slack bought to power their system). In some ways it was better than screensharing. In other ways worse. I work on a Windows computer while most of my coworkers are on Macs. Even if we use the same editor, I’d have to use the Mac keyboard shortcuts in order to do anything useful.

                                                                      If I understand this correctly, the Live Share feature allows you to use all your local shortcuts, etc. and just transmits the effect over to the other user’s editor. The difference between remotely using someone else’s editor, and having my local editor transmit changes over to them is HUGE.

                                                                      1. 4

                                                                        Is this a feature people actually want?

                                                                        That’s a good question. This has never been on my list of wants.

                                                                        It’s kinda cool that both developers get to use their own key bindings.

                                                                        Maybe if you were pair programming, and you had two developers next to each other with their own keyboard/mouse/monitor, then having your own keybindings would be great.

                                                                        – jorge.

                                                                        1. 2

                                                                          It’s something that I’ve been wanting since I used it in Eclipse a while back. It’s not really useful for professional collaboration, but it’s excellent for one‐on‐one teaching—no switching between windows or awkward vocal instructions. Also, it tends to be easy on bandwidth and avoid the sort of video artifacts that screen sharing brings.

                                                                          1. 1

                                                                            There’s a group of computational linguists at the University of Tromsø who swear by Subethaedit. They make everyone get Mac’s so they can run that. I’m guessing it has to do with constantly onboarding new phd students, getting them quickly set up in their dev environment, as well as collaborative article writing (though https://www.overleaf.com/ is now a better alternative for that). They’re always annoyed at having to use less capable editors like Etherpad with non-mac-users …

                                                                            See also: https://www.reddit.com/r/emacs/comments/7d6hv0/real_time_collaboration_in_emacs/

                                                                            1. 1

                                                                              I use tmate whenever I need to remote pair; it lets you share both the editor and the terminal (of course; really I’m just sharing Emacs with terminal buffers inside it, but anyway) and it shows the exact same thing to both participants, whereas most buffer-centric sharing solutions I’ve seen had you enable sharing on a per-buffer basis, so you had to talk thru “OK, now I’m switching to this other file” over voice whenever you changed focus.

                                                                              The slack-style screen sharing isn’t nearly as nice for my purposes because it’s read-only, whereas with tmate the other person can make edits easily.

                                                                            1. 20

                                                                              Interestingly, you can replace the technical content of this post with almost anything related to good human behavior. That’s because at it’s core, the post is arguing against deontological ethics (the idea that whether something is good is determined by whether it adheres to a specific set of rules). However, I find the argument against the terms “good” and “bad” misplaced.

                                                                              As an alternative, you might try viewing things through the lens of virtue ethics, which argue that “good” and “bad” are useful terms, but are always relative to some particular goal. In human behavior overall that goal might be called “human flourishing.” And in the case of code, that would be something like “achieving it’s organizational purpose without causing excess detriment.” Or more concretely, “taking online orders with an acceptable failure rate.”

                                                                              Edit: The virtue ethics view is thus that any time you call something “good,” it means good for some particular thing, even if we aren’t always explicit about what that thing is.

                                                                              1. 3

                                                                                Thank you! Another entry for my “why programmers should study humanities” list.

                                                                              1. 16

                                                                                I don’t see “hate speech” the issue there.

                                                                                The most was just not on subject and derailing the subject towards something else. It was no discussion of the app at hand. The following thread needed 4 replies to get somewhat into the range of something usable. Also, I didn’t see it as a good critique of “minimal”, as that was pretty clearly referring to the user model of the app.

                                                                                I’m a bit split on outright removing it, but I’d be happy if that behavior were a little less popular here.

                                                                                1. 28

                                                                                  I think pointing out a dependency or framework for a posted project should always be on topic. It’s definitely relevant to my decision to investigate further. If there are a lot of electron haters such that “electron; stay away” gets upvotes, then so be it. It’s not necessary for the electron lovers to engage in every such thread.

                                                                                  1. 13

                                                                                    It’s not worth anyone’s time to read a comment entirely consisting of “electron; stay away”. If people dislike it, fine, write a long criticism and link it, but a disdainful three-word brush-off is terrible rhetoric only useful for making newbies feel bad and starting flame wars.

                                                                                    1. 26

                                                                                      “It’s electron” is all the info I’m looking for. I don’t need a fully articulated 1000 word copy pasta for that.

                                                                                      1. 1

                                                                                        And I’d delete copypasta. I said link.

                                                                                        1. 34

                                                                                          With all due respect, I don’t think you should delete anything on this site until you gain more confidence of the community to exercise good judgment.

                                                                                      2. [Comment removed by author]

                                                                                        1. 5

                                                                                          Because despite the fact that I (and others?) used that downvote option, quite a few others apparently feel okay with upvoting (self-identified!) hate posts.

                                                                                        2. 19

                                                                                          I would find such a comment useful. I’m not remotely interested in using any electron-based software, so to find that out at the same time as I’m looking at the page means I can close the tab and move on faster.

                                                                                          1. 8

                                                                                            I think if a flamewar were to break out, that would be the time to delete the comment (and thread). Or preferrably put on your moderator hat and just ask to keep discussion constructive.

                                                                                            I implore the moderation team to continue to use a light touch approach to removing content.

                                                                                            1. 2

                                                                                              It’s not worth anyone’s time to read a comment entirely consisting of “electron; stay away”.

                                                                                              On the plus side, it only takes an instant to read it!

                                                                                        1. [Comment removed by moderator pushcx: don't make "hate posts"]

                                                                                          1. 4

                                                                                            And Direct3D. But for an electron app it really is minimal: only 145.3 MiB on disk.

                                                                                            1. 5

                                                                                              A “minimal X app” generally means an app with a simple and straightforward interface, not an app that fits in 64kb.

                                                                                              1. 3

                                                                                                I mean, you sort of need a browser to render markdown.

                                                                                                1. 3

                                                                                                  Isn’t the point of markdown the ability to see ‘formatted’ text without rendering it as HTML? I’ve never really understood the value of these markdown editors, given that the most complex thing in MD seems to be lists

                                                                                                  1. 4

                                                                                                    What makes you think you need a browser for simple text formatting?

                                                                                                    1. 8

                                                                                                      Markdown has full support for inline HTML.

                                                                                                      It’s even so central to the language that it’s literally the second section in the original markdown document

                                                                                                      1. 3

                                                                                                        Never saw this, but I guess that comes from all the different markdown flavors.

                                                                                                        But ok, use electron for this and call it minimal, I don’t have to care if I don’t use it.

                                                                                                        Edit: But using some webkit view from gtk or qt would make it less of a problem for me as someone who packages software for a linux distribution. Packaging electron apps is just not feasible because we need patches for it to support musl libc and building it over and over again for each electron app is just wrong.

                                                                                                        1. 4

                                                                                                          I find your comment particularly infuriating.

                                                                                                          Your original post was a lowbrow dismissal of someone’s work couched with irony to provide plausible deniability. Even then, you knew it wasn’t the right thing to do.

                                                                                                          You then showed that you hadn’t even bothered to understand the field before dismissing the project.

                                                                                                          You then did another lowbrow dismissal comment, but then followed it up with an edit, in which you suggested:

                                                                                                          1. the developer take a hard dependency and rewrite their entire software in one of two perennially buggy, flaky, fast-moving and platform-locked desktop linux frameworks, just because it would make your life as a linux software packager easier

                                                                                                          2. it’s impossible to package electron apps because you have to do work to compile it and that makes you sad

                                                                                                          I’m trying to imagine scenarios under which you could express more entitlement or lack of respect for people who actually do work, but they’re not coming to me. Additionally, if the job of packaging software is too hard for you, maybe stop doing it.

                                                                                                          1. 6

                                                                                                            After your edit this is a much more informative post than your top level one dissing the project. Perhaps you could lead with something more like this next time?

                                                                                                            1. 3

                                                                                                              To my understanding, though, there’s no good quick solution to package GTK and QT applications to OS X/Windows, which - to my understanding - is one of the main reasons people pick electron?

                                                                                                              1. 1

                                                                                                                Edit: But using some webkit view from gtk or qt would make it less of a problem for me

                                                                                                                I maintain the OpenBSD port for ghostwriter, it’s pretty minimalistic and uses qt5 webkit view.

                                                                                                            2. 2

                                                                                                              There are much nicer ways to make a technical point than this. Please use one of them in the future.

                                                                                                        1. 3

                                                                                                          Make sure you read the comments. There are several errors in this post, but they do get corrected below.

                                                                                                          1. 7

                                                                                                            While this is a good read, I do think that the author is misinterpreting Uncle Bob. The original Tools are not the Answer post specifically says that he supports using these tools:

                                                                                                            I think that good software tools make it easier to write good software. However, tools are not the answer to the “Apocalypse”.

                                                                                                            His point, as I understand it, is that more tools cannot solve a lack of discipline because it takes discipline to actually use those tools. And right now most developers don’t even use the simplest tools available to help ensure correctness. If a developer isn’t disciplined enough to write a unit test, why do we think the same developer will be disciplined enough formally prove the correctness of their program?

                                                                                                            I stood before a sea of programmers a few days ago. I asked them the question I always ask: “How many of you write unit tests on a regular basis?” Not one in twenty raised their hands.

                                                                                                            Uncle Bob blames this problem on a lack of discipline. I think that’s partially correct, but also ignores that developers are embedded into dysfunctional contexts that often punish discipline or reward fast completion more than correctness.

                                                                                                            1. 5

                                                                                                              I agreed with him on that point. Discipline is the most important factor. It doesn’t matter what it’s motivation (eg money, principles). The best returns come from a mentality that constantly tries to improve the process of writing solid code or the code itself. Such a mentality naturally seeks out methods such as unit testing, code review, or even formal methods. Without that mentality, they’ll half-ass their QA or just leave it off altogether. This is what we see a lot in both proprietary and FOSS software.

                                                                                                              1. 3

                                                                                                                I think Uncle Bob also ignores that the vast majority of software is not written using best available practices. Cloudbleed could have been prevented by not using C to write a parser.

                                                                                                                1. 1

                                                                                                                  I’m not sure how he’s ignoring that? Seems to be the very thing he’s complaining about.

                                                                                                                  1. 10

                                                                                                                    He pretty explicitly says that in one of his recent posts:

                                                                                                                    defects are never the fault of our languages. Defects are the fault of programmers. It is programmers who create defects – not languages.

                                                                                                                    1. 3

                                                                                                                      Shit, there’s a bug in my Brainfuck code! Oh well, time to sit in the corner and think about what I’ve done…

                                                                                                              1. 12

                                                                                                                I disagree with this post. I’m also a professional and my time is valuable too. However, two of the three suggestions they made are taking significant time away from me and my team for evaluating a candidate that potentially can’t even write code to solve a simple task. Part of an interview process is to filter out people before it gets to that point, so we’re not wasting employees time.

                                                                                                                1. 10

                                                                                                                  I think coding challenges are optimised for candidates who are looking for a job. I’ve been in that boat once, and when you’re actually looking for a job your “valuable time” is of course bet spent trying to get said job (by doing coding challenge or whatever else).

                                                                                                                  Most of the time, though, I’m being recruited. I’m not going to do a coding challenge for a recruiter.

                                                                                                                  1. 1

                                                                                                                    Taking an entire day to work with them (unpaid) still strikes me as really weird.

                                                                                                                    1. 1

                                                                                                                      Think of it as a great way to find out if these are people you would want to work with every day before you actually have to do that.

                                                                                                                  2. 8

                                                                                                                    I disagree with this post. I’m also a professional and my time is valuable too.

                                                                                                                    I have the same problem with it as a hiring manager– how do I screen out socially capable but inept developers– and I share the author’s opinion when I’m the candidate– this tells me nothing about why I want to work for you. Each side wants the other to make an unequal commitment so it amounts to a single round game with that candidate. As a candidate with a choice of games, I don’t want to play this one and it signals disregard for/trivialization of the candidate’s investment and work history. For the hiring side, this plays out multiple times and there is investment in posting, screening, reviewing, etc. so regardless of this round my total investment is higher but not visible.

                                                                                                                    So what have I personally done? When I’m the candidate, I refuse to do the coding challenge and say, like the author, check my repos and talk to my references (unless the problem catches my interest, then I might). I have that luxury. When I’m the employer? Up front I explain how it works and what timeline they can expect as part of a 15-minute phone screen for basic info with someone technical. Then I arrange a round of 45-60 minute calls: a technical call with someone on the team and a social/technical call where I try to get them to talk with me about their work in detail and many of the non-code aspects of their job, habits, tools, designs, etc. They’ll probably have a call with my manager or another peer. Then, if I’m satisfied but not sure, I bring them in or have a video chat and they do a quick coding test. This wastes less of their time, makes my commitment visible, and seems to work but it is not a scalable process.

                                                                                                                    1. 7

                                                                                                                      I have a portfolio and some github projects. This is where most of my hiring emails come from. So when a company doesn’t spend the time to check that out, and they want me to implement some trivial thing that doesn’t generate value for them, I don’t have time for them either.

                                                                                                                      I’ve had companies pay me to be a consultant for a week before giving me an offer, which was a nice way to learn about who they are. On the other hand, sometimes companies give me job offers now before I know anything about them, and I have to pump the brakes and talk to more of them before I feel comfortable going into something long-term.

                                                                                                                      1. [Comment removed by author]

                                                                                                                        1. 6

                                                                                                                          They didn’t ask for the hiring managers time, they asked for developers time. Either way, these people have other job responsibilities too and their time is important to defend.

                                                                                                                        2. 1

                                                                                                                          …evaluating a candidate that potentially can’t even write code to solve a simple task.

                                                                                                                          In the post, they talk about how they have a blog, numerous GitHub repositories, etc. At that point it should be obvious they can code. The interview then should be more about “fit” or whatever, IMHO.

                                                                                                                          1. 5

                                                                                                                            They aren’t the only candidate we would interview and in my opinion, it is better to have a consistent process. If every candidate had a similar level of public presence to evaluate then maybe that would be different.

                                                                                                                            1. 7

                                                                                                                              So, again IMHO, at that point you’re basically throwing out someone with passion and talent due to bureaucracy. If I come to you with decades of experience/conference talks/published papers/lots of open source software to review/whatever…and you ask me to spend 30 minutes doing trivial work, you’re basically implying that I’m lying to you and/or that your company cares more about process than people.

                                                                                                                              Again, this is IMHO.

                                                                                                                              1. 7

                                                                                                                                I’m saying that you’re not the only person applying for the job and I need to treat everyone the same, so we’re not giving preferential treatment.

                                                                                                                                1. 3

                                                                                                                                  I know, but…maybe you should give preferential treatment to people who are obviously better candidates. :)

                                                                                                                                  1. 9

                                                                                                                                    Some of the best engineers I know have zero public presence. Some of them are extremely humble and don’t like public flashiness. Some of them have families and maintain a strong work-life balance with non-tech stuff. Never assume those with a strong public presence are giving the world the whole picture. You still want to drill into the parts of their personality that they don’t highlight.

                                                                                                                                    1. 4

                                                                                                                                      Why does having a public portfolio make someone an obviously better candidate? What makes a candidate obviously better? Arbitrary social metrics? Ability to speak quickly about technical topics? Ability to talk bullshit without it sounding like bullshit?

                                                                                                                                      How do you know a candidate is obviously better without having them go through the same process and pipeline?

                                                                                                                                      1. 3

                                                                                                                                        How do you know a candidate is obviously better without having them go through the same process and pipeline?

                                                                                                                                        If the code in their GitHub account is as good or better than what would be tested by my coding test, why subject them to that? Ask harder questions, ask questions about the things that the coding test wouldn’t cover (including “soft” things that would judge a good fit), etc.

                                                                                                                                        Why does having a public portfolio make someone an obviously better candidate?

                                                                                                                                        Which surgeon would you rather have? The one nobody’s ever heard of, or the one who has published articles on the relevant surgical procedures, who goes to conferences to learn more about surgery, who obviously is passionate enough about medicine that they would study it even if they weren’t getting paid?

                                                                                                                                  2. 8

                                                                                                                                    There are, unfortunately, a lot of liars out there. I won’t say that industry hiring practices are anywhere near ideal, but as an interviewer it was astonishing how many people with great optics were incapable of coding. Someone would speak with great passion about all their projects and yada yada, and id be fairly convinced they could do the job, then I’d ask the most basic question imaginable. Splat.

                                                                                                                                    I guess it helps if you choose to believe the test isn’t meant for you, but for all the other pretenders.

                                                                                                                                    1. 7

                                                                                                                                      Even more surprising to me is that people who can’t actually code are somehow able to sustain careers as developers. It started making a lot of sense to me why good developers are in such high demand after I had the opportunity to do some interviewing and found that a frustratingly large amount of applicants can’t actually code, even if they look great on paper and are currently employed as developers.

                                                                                                                                      I think it’s incredibly risky to hire a developer without seeing code that they have written, be it from open source contributions or a coding test if necessary.

                                                                                                                                      1. 3

                                                                                                                                        Onsite nerves can kick in. It sure as hell did for me. I hate white boarding and I lockup. Totally brain freeze. That said, if it’s a basic one like writing a loop…well, they somehow lied their way into the onsite. Thing is, a take home coding challenge can weed out those people pretty fast. If they do that and come in and fall flat on their face before the whiteboard I don’t totally discount them. Anyway, there’s no perfect solution. There is always the potential to hire someone that is great at coding interviews and then sucks at real world problems.

                                                                                                                                        1. 2

                                                                                                                                          This is exactly my company’s experience. Half of the candidates would just bomb out on the C++ test even though they have studied it at high school/college/university and worked with it at their job for 5-10 years. How?!? Because they were either doing Java, not C++, or they were actually managing a team that did C++ and never had to touch it themselves (Well since leaving school at least).

                                                                                                                                          1. 1

                                                                                                                                            What I don’t understand is why this is so hyper-specific to developers. You never hear UI designers talking about processes like this.

                                                                                                                                            1. 6

                                                                                                                                              Really? I’ve heard UI designers talk about it a lot.

                                                                                                                                  1. 6

                                                                                                                                    As I wrote a few years ago, now Agile Scrum is the new RUP.

                                                                                                                                    In a field that is still at stone age (computer science), RUP and Agile (and Scrum, and Lean and… what next?) turned from rational approach to a well defined set problems to marketing segments for consultants and consultancy firms.

                                                                                                                                    They are tools to sell books, training courses and workshops.

                                                                                                                                    1. 2

                                                                                                                                      Eh. I don’t know. I’m not sure why (Agile/Scrum/Lean/etc) can’t be both a rational approach as well as a niche for consultants to market themselves in.

                                                                                                                                    1. 4

                                                                                                                                      What exactly is the takeaway from this rant? “Read warning messages”? “Keep your software updated”?

                                                                                                                                      I get that the author’s reason for writing was to tell off the complainers, essentially saying “it’s your fault for trusting library authors; it’s not the library authors’ fault for breaking your application.” But isn’t that logic twisted? If a library maintainer introduces a bug, obviously it’s the library maintainer’s fault. The question is whether the application developer has a Plan B for this type of situation.

                                                                                                                                      If “have a Plan B” is indeed the intended takeaway, I wish the author would say that clearly, rather than the blame-shifting approach of “you are incompetent because you trusted open source.”

                                                                                                                                      1. 4

                                                                                                                                        The takeaway is: Always pin your dependencies (possibly except dev env). We used shrinkwrap for this, now npm provides a lockfile, same for yarn.

                                                                                                                                        1. 4

                                                                                                                                          The takeaway I read into it is that if your production build process has the ability to install different versions of a million different dependencies than the ones that you previously tested on (for instance because it uses npm install and semver ranges and doesn’t lock things down), then you will at some point get screwed by that fact.

                                                                                                                                          You should have the ability to deploy the exact same code (including deps) that you test. You should have the sense to only do this. You should have tests, and they should not suck. If you do this, you won’t be the guy who said “this caused me hours of fumbling while prod was on fire”, you will be one of the people saying “my build broke, I changed the version pin, it’s OK for now”, which is better.

                                                                                                                                          If you want to be even more careful, then you don’t use ranges at all; you choose your dependencies, you maintain your own copies (so that no one else’s outages or pwnage spill onto you), and you don’t upgrade anything without having someone competent review the changes for any possible effect they have on you. Because code is so malleable, we as programmers make it a habit to replace the support columns in the basement with the newest high-tech design every time we repaint the cabinets in the kitchen… and then every now and then the house falls down in the process.

                                                                                                                                          1. 1

                                                                                                                                            Yeah, companies of any meaningful size relying on flaky redistributors like npm has always felt… odd

                                                                                                                                            1. 1

                                                                                                                                              because it uses npm install and semver ranges and doesn’t lock things down

                                                                                                                                              FYI, npm 5 and later generates a lock file automatically, so you’d have to specifically go out of your way to do this now.

                                                                                                                                            2. 2

                                                                                                                                              I don’t think that logic is twisted at all.

                                                                                                                                              There is an implied contract in open source that the maintainer(s) of a project promise constancy of some amount of functionality: that regressions are to be avoided and fixed and even that extensions and intentional changes are broadcasted and controlled. The implied contract holds because there’s an expectation that the maintainer(s) want the project to be successful as measured by the number of people who trust them enough to download and use the project.

                                                                                                                                              But that contract is just implied. For all you know, any one of your dependencies is actually has secret goals of being an art project to see how programmers respond during crisis. Or, more to the point, a con.

                                                                                                                                              The only way a bug or regression or breaking change is the “fault” of the maintainer(s) is if this implied contract holds.

                                                                                                                                              So it’s not so much whether or not you have a Plant B as much as whether you realize that you don’t have actual counterparties in the maintainer(s) who have given you a large amount of functionality you rely on. Whether you, as the responsible party for a service upon which you probably do have a contract for continued existence, support, and provision of services to your customers, are managing systemic risk appropriately.

                                                                                                                                              The obvious solution is to lock down dependencies and reduce “counterparty” risk on open source projects you use. More systemically, however, the solution is to be cognizant of assumptions like these and realize that they’re squarely upon the shoulders of the application maintainer.

                                                                                                                                              If that’s not good enough, then consider making a contract with the open source maintainers. You’ll probably need to pay them.

                                                                                                                                              1. 2

                                                                                                                                                This “implied contract” thinking is one of the strangest I’ve seen since joining BigCo. People will ask “is the project well maintained?” and don’t seem to think that the alternative is we write it from scratch – as a tech company, we write a lot from scratch and maintain all that. I’d much rather be forced to maintain a project for our use if upstream goes away then have to write from scratch and maintain!

                                                                                                                                                1. 2

                                                                                                                                                  To be fair, there are lots of cases in modern development where the alternative to taking on a dependency isn’t rewriting the whole thing from scratch; it’s being moderately inconvenienced and writing slightly more code. You use a big framework because one small corner of it makes something you’re doing easier. If it didn’t exist, you would reinvent that small corner. The biggest risk is that you reinvent it with more bugs or a worse interface.