14 ms·
No one wants simplicity
- distortedsignal 3y agoThis x5 for security. As someone in software security, I tell people I'm the fourth or fifth priority for any product. Function, Speed, and Simplicity are all ahead of me on the priority totem. I get it, but it's frustrating.
- dschiavu 3y agoThe curse of software "engineering". Well, don't think you can call our discipline engineering at all. If buildings were built the same way modern software gets built, we would never have the Burj Khalifa, the Shanghai Tower or the Tokyo Skytree. We'd probably still be living in holes in the ground, because that's the only fucking 'buildings' we'd be able to build.
- sproketboy 3y ago[dead]
- anderspitman 3y ago> We all claim to hate complexity, but it’s actually just complexity added by other people that we hate — our own bugbears are always exempted, and for things we understand we quickly become unable to even see there is a potential problem for other people
- jkaptur 3y agoOne line that demonstrates the agony and the ecstasy of simplicity: $ man ls | grep "\-\w," | wc -l On the one hand, beautiful, recursive composability of small, universal tools. On the other hand, the tool we're introspecting is 'ls'. If we truly valued simplicity, ls would have no flags - you would pass its output to awk to extract the data you want. A more thoughtful writeup: https://danluu.com/cli-complexity/ https://danluu.com/cli-complexity/
- cb321 3y agoObligatory Worse Is Better Link for those who haven't seen it: https://dreamsongs.com/WorseIsBetter.html https://dreamsongs.com/WorseIsBetter.html Sounds like Richard P. Gabriel never really figured out an "ideal strategy" after decades of trying.. Simplicity may be the kind of thing that feels close but is ultimately impossible due to varying tastes, interests/priorities. You can get far within little bubbles of coherent taste/interest, but then as the bubble expands, entropy (aka some value diversity metric) breaks things on you.. Like a kibbutz vs. capitalism. You're always tempted to think you can have just a little bigger tent/bubble if only...
- sheepybloke 3y agoOne part of this is that everyone wants something that is bespoke. They want their system to unique and custom, which inherently adds complexity. I've worked on lots of projects where a customer likes what we're doing, but has a specific way they want the system to work. This leads to lots of the complexity in products I've worked on.
- abss 3y agoThe main issue is that when you start a new project almoust any approach is "simple enough". The problem is that an approach that is good long term will look like an overkill complexity on the first stages of a project. I have my creations like SwarmESB and swarm communication idea as a good example... could make the microservice systems simpler but only after a level of complexity and then it is too late to invest in a new approach. Therefore such technologies will not be addopted instead other complex workarounds become succesfull..
- twobitshifter 3y agoThe Ineos Grenadier SUV/Truck is about to put this to the test in the automotive space https://www.thedrive.com/car-reviews/2023-ineos-grenadier-prototype-review-specs-price-options-impressions https://www.thedrive.com/car-reviews/2023-ineos-grenadier-pr... Do people want straight axles, reliable engines, and big physical knobs and dials?
- usefulcat 3y ago> The reason that modern web development is swamped with complexity is that no one really wants things to be simple. We just think we do, while our choices prove otherwise. Tangential, but I've repeatedly found this to be a very useful and generalizable insight. If you want to know what's really important to someone (including yourself!), ignore what they say and focus on what they actually do (or don't do).
- renox 3y agoI'm not sure about what is really 'simplicity'.. If I program in assembly languages I don't need a huge compiler to generate the executable so the system is simpler but for the programmer it's also more complex because assembly languages are complex and any mistake is really hard to find.. Same for API, the worse is better debate, an OS which retries automatically in case of interrupts is simpler for the users? For most users yes, for those who care about low latency no!
- deterministic 3y agoWow. Most comments in this thread get it completely wrong. The article is about simplicity of implementation not simplicity of features. Given two different implementations of software, that gives users the exact same features, you will often find that one implementation is simpler than the other. Using less libraries, a simpler build system, less code etc. That’s the kind of simplicity we should strive for. Not software with less features.
- lemper 3y agoi want it, though.
- WJW 3y agoSo what are you going to cut from your current software project then? Or was this a "I want this, but my manager won't let me" type of post? :)
- lemper 3y agoat work? none. I have no attachment to my work apart from the business perspective. non-work, I don't even have a personal computer anymore.
- dustingetz 3y agoif you can’t see it, is it real? the boss is probably right here - simplicity is a mirage, it takes a decade to move the needle (like in science), this blogger’s perspective is thoughts and prayers. I say this as an entrepreneur who has dedicated an actual decade of my life to trying to move this needle.
- DaveFlater 3y ago"The price of reliability is the pursuit of the utmost simplicity. It is a price which the very rich find most hard to pay." — Tony Hoare It is impossible in practice to persuade people to pay the same amount for a simple, reliable product that they would pay for a complex, unreliable one with more features. Reliability is a promise, and they have to trust. Features can be demonstrated now, so less trust is involved (or so it appears). And then the features stop working.
- robviren 3y agoDepends on who your customers are. I have always found breaking up features into a "basic" user and a super user is a fairly good approach. Keep the advanced and complex things on a separate page that requires navigation and keep the 80% use case as the sane default given to most users. The loud few get what they want and the bulk of the users are served reasonably. I have also found consistency to be significantly more important than excellence. Any time someone requests that we take away an option or feature for some good reason I am extremely hesitant to remove as I am confident that a customer will suddenly provide a valid use case for it's existence.
- taneq 3y agoI thought the noveau semi-riche liked complex flashy things, while properly wealthy people tended more towards ultra-high-quality but simple and classy?
- deleted 3y ago[deleted]
- sanitycheck 3y agoIt's definitely not impossible to do that, there are a ton of people (on this very website, I dare say) who'd pay good money for a non-smart TV with the latest panel technology and 4 HDMI ports. However Samsung and LG wouldn't make as much money from those models, and the potential customers for them will probably suck it up and buy a smart TV anyway. So why would they bother?
- 3y ago
- karimmaassen 3y agoSimplicity is not about making complex things simple, it's about making it simple to do complex things.
- jan_Sate 3y agoThis. Let's not ride the hype train and overengineer anything. Just use any simple solution that can get the work done.
- Gualdrapo 3y agoI feel like a point the author is trying to make is that oftentimes "simple solutions" have their tradeoffs.
- WJW 3y agoI read the article as promoting "let's use a simpler solution than that, and cut scope from the work to be done instead". If you are not willing to cut the scope of the problem to the absolute minimum, you are prioritizing something else over simplicity. That something else might be higher profits, ease of onboarding, keeping your boss(es) happy or even things like better error logging and observability. Most software projects, both for-profit and not, have a huge laundry list of things they have rightly prioritized over simplicity. I don't even think the article tried to argue that it was wrong to want those other things over simplicity, just that most people out there only claim to want simplicity but then make another statement entirely with their actions.
- sergius 3y agoLike Perl's: Make the easy things easy, and the hard things possible.
- hliyan 3y agoOr, at least start by keeping simple things simple.
- jmathai 3y agoIt came with age and time for me. I don’t care for bells and whistles nearly as much as I used to. And I would rather pay more for something that does its thing really well and reliably. I’ve learned that I don’t get as much real world value from the extras and they cost me more up front and are an under appreciated burden for the duration I own it. As it relates to this article, the last 3 web applications I’ve built have used PHP, are not SPAs and store data in flat json files (I.e https://fiers.co https://fiers.co - I don’t think you’d be able to tell). There’s some stuff that are hard to do and those things don’t get done because I don’t want the complexity.
- sharikous 3y agoFYI it doesn't render too well on my phone. The image overflows horizontally.
- WJW 3y agoSee how well he cut cope to keep things simple? "Works on mobile" was simple unnecessary complexity :) Only half-joking btw. I thought the article was way more about "cut scope ruthlessly so you can use simpler tools" than it was about "use the simplest tool for the job".
- jmathai 3y agoFTA: > what are you willing to sacrifice to achieve simplicity? I'm willing to sacrifice a website that tries to keep state up to date without requiring a page refresh so that I can avoid all the complexity and bugs which come from it.
- HWR_14 3y agoFor many, probably most, websites this is fine.
- deleted 3y ago[deleted]
- 3y ago
- bullen 3y agoThe problem with the web is the browser, probably the most complex project humans maintain. I chose to make my own native app (that uses HTTP too) and I can now see these same complexities mount. The trick is to say no and stop features.
- AnimalMuppet 3y agoPeople want different things. Someone could build a simple tool to do what I want. Someone could build a simple tool to do what you want. They would be different tools, though. Nobody wants to create different tools for me and you. So they create one tool, and it has to be more complex. As the article says, the same thing happens with business units. Every VP wants something that does what they need (or think they do). And it might be simple to do any one of those. It's not simple to do all of them put together, though. (In fact, I wonder if it doesn't happen more because of different VPs than it does different customers.)
- paulryanrogers 3y agoExactly this. Much like the tale of people only using 10% of Microsoft Word, yet everyone uses a different 10%. Strange the article doesn't address this tension between all the various stakeholders and tension among their priorities. I want the simplest thing that satisfies my need and want, yet no simpler. If others are using it then it'll already be more complex or one or both of us must compromise.
- AnimalMuppet 3y ago> Strange the article doesn't address this tension between all the various stakeholders and tension among their priorities. I thought it did: > Of course we all claim to hate complexity, but it’s actually just complexity added by other people that we hate — our own bugbears are always exempted, and for things we understand we quickly become unable to even see there is a potential problem for other people.
- paulryanrogers 3y agoFair, I was hoping it'd go deeper because even an individual has tension between different priorities that can require complexity. This whole point kind of invalidates the conclusion that no one wants simplicity despite their claims. They really do want simplicity, despite struggling to understand both the depths of what's needed to satisfy their less visible constraints and the needs and priorities of everyone else using the thing. Subconsciously or consciously folks may have a sense of the tradeoffs, which is why they keep choosing more complex solutions. Not because they're being dishonest or are hopelessly ignorant.
- throw1234651234 3y agoA significant portion of developers want to dazzle with complexity. First and foremost, it's a flex and a resume builder - everyone wants to have K8S on their resume (even though it's ancient at this point). Second of all, people are simultaneously lazy - when you tell them to put the customer list in the database, suddenly it becomes a later issue. So you get "solve it in a really complicated way, but because you made it so complicated, barely make it work, and when it breaks, no one will be able to figure it out." This is a pattern I see again and again. I constantly get downvoted here when I suggest that new devs should be able to get up and running within a couple of hours and that should be one of the priorities (at least on the "core" project that they will be working on). And yes, I "get it" - the company I work for just acquired a bunch of other companies with various stacks, on various clouds. But at the end of the day, people are way more worried about introducing a 1000 new libraries and writing ABSOLUTELY useless unit tests where everything is mocked than actually creating one source of truth for the data. As you can see, I am a bit bitter about all of this.
- ryandv 3y agoI remember a time when HTTP was used to transfer HTML _documents,_ and not these "progressive web app" monstrosities. It felt a bit unusual to visit blogs or news sites and be bombarded with megabytes of JavaScript from over a dozen domains. Isn't the focus of these sites supposed to be on the textual, written content? How much JavaScript is actually required to deliver what could have been (if you squint hard enough) a Word document? I mean, that's what HTML documents _were;_ after all, it's called the document object model. And then I remembered that I wasn't the actual user of these sites; no, I was the one being used. The reason all of this JavaScript is necessary is to load tracking pixels, analytics agents, and advertising networks onto the page to generate revenue and data ("the new oil!") for the site's operators. Don't get me started on web developers' penchant for pursuing whatever front-end framework is in fashion these days. I get it, I've written my own monstrosities in highly tortured, purely functional TypeScript with fp-ts with ADTs and monads and Tasks; sometimes it's too difficult to resist from scratching that intellectual itch. But after a few years of bouncing from prototypeJS to jQuery to backbone to angular to react to vue to svelte - goddamn, does it ever end? Is anything really gained from this never-ending, ever-accelerating treadmill of newer and newer frameworks which seem to pop up faster than they can be replaced in extant codebases? All of this at the expense of the end-used, er, end-user. Having spent a little while exploring the metamath site [0] and its associated program, I am stunned at how snappy, simple, and _long-lasting_ the whole thing is. There are theorems here dating from fucking _1994,_ and the site is still being actively updated. There is no framework, only one binary that generates static HTML documents, which are then served to your browser, no need for client-side rendering or XHR or advertising or cookie popups, or hell, even JavaScript entirely. But I am just shaking fists at a sky that will never fall, thanks to the shoulders of the distributed Atlas of hordes of developers keeping this digital house of cards standing. [0] https://us.metamath.org/mpeuni/mmtheorems.html https://us.metamath.org/mpeuni/mmtheorems.html
- shaftoe444 3y agoYou might like https://no-js.club/ https://no-js.club/
- Tade0 3y ago> Is anything really gained from this never-ending, ever-accelerating treadmill of newer and newer frameworks which seem to pop up faster than they can be replaced in extant codebases? It slowed noticeably after React took over the market. Svelte and SolidJS are the first entries since 2013 that offer something new. Meanwhile large organisations often use Angular and have been since its introduction. But to answer the question: yes. Svelte in my view is one example of how complexity is slowly but surely dialing down thanks to the lessons that were learned along the way - for the first time in almost a decade you're getting a legible stack trace and this is a huge, unexpected boon associated with the approach used there.
- danabrams 3y agoI’m reminded of Alan Kay’s observation that software is a pop-culture. Simplicity is great, how can we combine it with the 17 other frameworks we saw on HN this week and have to use?
- owlstuffing 3y ago[flagged]
- io84 3y agoEnd users often do want simplicity but face a choice between products all optimised to extract value, which is different from giving them what they want. Sometimes that optimised path is simplicity, especially if it’s a new class of product. The result is delightful but rarely lasts as the market matures.
- hellokitty33 3y agoSimplicity is the utmost sophistication. But nobody notice your hard work. To keep your job secure and well paid, the better strategies are by introducing tons of complexities into the system which look good to those who's not maintaining it.
- 32gbsd 3y agoI don't agree with this at all. It's some kind of eat your own dog food thinking. These web complexities exist because the web+browsers is simple - it's a host platform. The group's creating the complexity make it their jobs. The web is still simple. Allot of these complex web things don't exist in C/Java because the people who create it are not clever or too lazy to go to an actually complex platform to honey pot Devs. Their business model would fail.
- avgcorrection 3y agoSimplicity has many fathers while complexity is an orphan. No? This just seems like a hopeless thing to discuss because everyone says that they want simplicity (or at least: not complexity) but then nobody will admit to being the root cause of some specific kind of complexity; if someone has made something “complex” then it was because they needed something to work with something else that was complex (pragmatism).
- ilc 3y agoI told my boss the following during my interview: "If I'm doing my job right, you'll see me come up with solutions so obvious and clear, you'll wonder why they took so long." It is hard to come up with really good answers to questions. To make sure that the obvious, is really correct, etc. I've given code reviews where I've told people to remove 100's of lines of code and use a module we already use. My way is not the easy way today. My way is the easy way over the years.
- deleted 3y ago[deleted]
- api 3y agoIMHO the problem is that people don't realize the cost of complexity in terms of labor and cognitive load. Complexity is extremely expensive and the cost tends to increase exponentially rather than linearly. It also greatly increases the odds of bugs, vulnerabilities, and other defects.
- sanitycheck 3y agoIf it was simple, they wouldn't be paying us for it. The people who want simplicity don't need experienced professionals to do those simple things. So we don't tend to hear about them, and we don't get to do them. I've been asked to do things so simple I don't even want to go to the trouble of negotiating a contract, I just recommend an off the shelf solution. I've been asked to do complicated things that should be simple, so I've recommended doing the simple thing. They just ask someone else to do the complicated thing instead. If someone reading HN is involved, so is complexity. The best thing we can hope to do is wrangle it into isolated and manageable little chunks.
- jonahx 3y agoThe article is talking implementation complexity. Say a client asks for features A, B, C, D which reach the bar of complexity where someone from HN has to get involved. Now two things can happen, and in both cases the same feature set is delivered: 1. All of those features are implemented as a server side web app, with little to no JS a simple CSS stylesheet, and each page is under 100K and loads almost instantly. There is also a simple caching strategy (but not necessarily an obvious one) that speeds the application up further, and allows it scale. The DB design is good, proper indexes have been added, the queries have been thoughtfully planned, etc. 2. The features are implemented as a SPA, and a large framework has been pulled in. Many UI components also pull in other large dependencies. A CSS framework has also been added even though only 1% of it is used, and no attempt to tree shake the CSS or JS has been made. The page size is over 3MB. No DB optimizations or caching has been added, etc. Note this is far from a straw man. 2. is by far the most common approach, even among "professionals".
- sanitycheck 3y agoOption 2 would of course be a SSR React MPA these days, not a SPA, so we have to worry about NPM supply chain attacks server-side too. Option 1 can be done by one sensible person with intermediate PHP/Python knowledge, and maintained fairly easily and cheaply forever. They're different jobs. You can take the interview for that option 2, and you can push for doing option 1 instead. What will end up happening is that they employ someone else. (I speak as someone who spent a couple of months in the mid-2000s mostly writing a partial XPath implementation in Flash ActionScript, to be used in a single product to interface with one other 3rd-party system. It was a stupid idea from day 1 and definitely not mine, yet that was the job! The insanity is not new.)
- gizmo 3y agoSimplicity is like performance or good design. It's valuable but it takes a disproportionate amount of effort. But it's worth it regardless if you want your product to become hugely successful because software popularity follows a power law curve. It can take 5x longer to make a product 20% simpler and 30% faster. But that might result in your product becoming 10x more popular. Power law dynamics are very counter-intuitive that way.
- osigurdson 3y agoI do think simplicity is good but it is interesting how complex nature is while working so well.
- agentultra 3y ago"Simplicity is a great virtue but it requires hard work to achieve it and education to appreciate it. And to make matters worse: complexity sells better." -- E.W. Djikstra If you want simplicity you have to do hard work. It doesn't come by simply removing libraries. Some of that may be incidental complexity and you will get better performance from it. However the core problems themselves, the essential complexity of the problem: to make a solution that solves it in a simple way requires thinking. And if there's one thing I've learned in my career: people hate thinking. Businesses tend to prefer quick solutions and will pay whatever cost to have it now rather than later. Elegant, simple solutions require time and thought. That is expensive and slow. Since businesses pay our salaries we do what we can and we slap on a library or use a framework and move on.
- mihaic 3y agoThanks for finding the perfect quote for what my thoughts were as well. I'll also add that simplicity also comes from a lot of experience, since the most dangerous developers now seem to be the ones with minimal skill, that don't have the track record to understand that they can't predict what the future will hold, and should better just solve what's required while keeping their options open.
- begueradj 3y agoYour comment is also a quote by itself
- jjoonathan 3y agoThe road to hell is paved with products that pursued simplicity but ultimately couldn't afford it. * Just Doesn't Work * Your simplicity becomes my complexity (fussy compatibility, batching creates latency, etc) * "One-button" interfaces where you have to learn a morse-code dialect and timing to access the necessary features * Bonus points: the software is laggy and the one button is mechanically unreliable, compounding the difficulty of getting the timing correct * Useless error messages that make simple problems complex * Similar: Necessary complexity (e.g. radio reception, authentication, updates) hidden behind a featureless spinning wheel for maximum time wasting when you can't tell what the holdup is
- ravenstine 3y agoThough I've found that I'm far more of a digital minimalist than most people, I don't entirely agree that complexity == slow. Today's web technology is perfectly capable of doing very dynamic and complex things without being slow. The reason for slowness, while entangled with complexity, is almost always founded upon poor decision making; such poor decisions are usually the result of bad leadership, inexperience, laziness, programmer dogma, and of course the business putting too much pressure on developers to rush things out. What you get out of these conditions is an app that "delights" the user, but takes several seconds to merely load because someone thought it was a great idea to load all the user's records on the frontend at once, and is laggy because a crapload of elements are being inserted even when they aren't visible. As far as the dynamics of the web app, lagginess or weird behavior is often caused by the developer not actually understanding the runloop or the process that leads to painting things on the screen (ex. how merely observing a property of the DOM or changing something seemingly innocuous can cause a redraw). > Of course we all claim to hate complexity, but it’s actually just complexity added by other people that we hate Yes and no. Of course we prefer complexity we intimately understand to complexity we don't understand that well. That doesn't mean all complexity we don't like is just a matter of "RTFM, bro" or "hit the ground running, bro." For example, I've come to believe that most OOP principles lead to unnecessary complexity most of the time. When I see complexity caused by OOP, it's not that I don't understand it because someone else wrote it, but because it's a pattern that I believe adds more complexity than is necessary. I know this because I've gone back to code I've written using OOP and immediately became confused, whereas my more functional code is usually easier to follow and has fewer gotchas. It's a matter of taste, as many people prefer OOP, but it doesn't just boil down to someone else having written the code.
- didibus 3y agoI like the concept that there are accidental complexity and essential complexity. Essential complexity is that of the problem you are solving itself. How complex the use case itself is. Accidental complexity is how more complicated your implementation of it make things. This is the one people want to keep away, and favor simplicity. If you remove scope, you're removing essential complexity by making the problem itself simpler. To remove accidental complexity you have to find a solution to the same problem that adds little more complexity over it. People want to be able to deliver essentially complex use cases, while adding as little accidental complexity over it. But doing so is hard, hard things are hard to achieve, and so most of the time we end up with a lot of accidental complexity added, because it's easier that way. Not because people don't want simplicity.
- nonethewiser 3y agoThis is a very important distinction. I think it stands to reason that an overall industry trend towards more complexity must be due to essential complexity. Could you even have an enduring trend that is not due to essential complexity? Wouldn't people get better over time, or the accidental complexity lose out to non-accidentally complex?
- couchand 3y agoA better term is "non-essential complexity", since "accidental" implies that it wasn't intended. The reason it's a durable trend for non-essential complexity to increase is that there are common and powerful forces that push for increased non-essential complexity. The prime example is short-term technical debt taken on to speed the release of something new. It's not accidental, the team intentionally chose to (temporarily, hopefully) take on the added complexity.
- ttymck 3y agoNot to be rude, but these terms are pretty firm at this point. If it helps, think of "accidental" as "incidental". It's not referring to any actor's intent or lack thereof. Frankly, you're introducing accidental complexity by trying to refer to it as "non-essential complexity" ;)
- watters 3y agoI find that the vast majority of assessments like this are rooted in the mistaken belief that there are common, well-understood, and widely shared meanings for words like "simple" and "complex". The post isn't observing a lack of desire for simplicity, they're observing a very common case where people evaluate "simple" relative to their own familiarity with tools or techniques rather than a comparison of perceiver-independent properties of the tools and techniques vs their alternatives.
- frou_dh 3y agoThis is also evident in the extremely overused phrase "simple yet powerful" that software libraries/tools/etc use when pitching themselves. Everyone apparently thinks their own inventions are Simple Yet Powerful. https://github.com/search?q=%22simple+yet+powerful%22&type=Code https://github.com/search?q=%22simple+yet+powerful%22&type=C...
- nottorp 3y agoLet's take cars. Is it "simple" to have one tablet on the dashboard for all controls? Or having physical buttons for commonly used functions is actually the "simple" option?
- rawgabbit 3y agoThere are two people involved in this scenario: the car driver and the car manufacturer. For the car driver, physical buttons are simpler (less cognitive load and safer to operate). For the car manufacturer, a single tablet is simpler (less manufacturing complexity and cheaper). EDIT. I forgot with the Right to Repair issue, there is a third person, the neighborhood general mechanic. With physical controls, the mechanic is more likely to be able to repair the broken switch/electrical relay. With the tablet, the mechanic cannot.
- guntars 3y agoThe simple option is no dashboard at all. The AC can be set at the service center.
- feoren 3y ago
- d357r0y3r 3y agoThe average HN user has some idea of what is simple and intuitive. This has very little to do with what the average non-technical web user thinks or feels. I've made many decisions in my career that boiled down to: we're not going to do what the users want in this case because the complexity of maintaining that feature is not worth the value it provides. And many times, that's true. Sometimes, it's not true. At Netflix, it's common for engineers, especially new engineers, to say, "Who even uses dubs? Just use subtitles." The answer turns out to be "at least 50% of people when watching content not in their native language." There is a floor on app complexity that naturally results from trying to build something that many people want to use. HN User #82983 may not see the point in a web-based note taking app because he just puts all his notes in a `notes.json` file. But, that app has many users who love it, and the developer doesn't want to tell them to kick rocks just because it would corrupt their precious codebase.
- tasuki 3y ago> The average HN user has some idea of what is simple and intuitive. "Simple" and "intuitive" are rather orthogonal concepts. See eg Lisp: an objectively simple language which many find unintuitive. WordPress I guess might be considered intuitive, but is not simple in any way.
- kazinator 3y agoSomething is intuitive if it jibes with your preconceived notions. When you experiment with it, you form certain hypotheses about how it will react or how by what means to get a certain behavior. If those hypotheses are usually true, then it's intuitive.
- Supermancho 3y ago> "Who even uses dubs? Just use subtitles." The Netflix subtitles and dubbing for foreign media are both so bad, we just don't watch any of it. My friends and family are not the only ones. I'm pretty sure we're a dark demographic.
- 3y ago
- nonethewiser 3y agoSimplicity usually has a large tradeoff. Complexity tends to mean "we accept a greater set of responsibilities" than the simple version. You might get 66% of the power for the simple version. Which could be a great value if it means you need 50% of the staff, expenses, etc. But you have to be OK with being handicapped in exchange. You will have to say "We can't do that," or "We have to tell the customer 'no'" which will never fly on the business side, and often not engineering. More often than not I think it boils down to this. Saying no to growth, basically. Which might even be the right choice sometimes. And sure, sometimes people just over-engineer things completely unnecessarily. But that's not why there is an enduring problem of choosing complexity over simplicity.
- foul 3y agoSimplicity is a word with a lot of meanings, in OP I'm witnessing a million poor souls trading low time-to-market, immediateness for users, for maintenance over the years on a few thousands moving parts.
- gitgud 3y ago> …when a problem arises with some of the complexity you’ve added. Is your first instinct to add even more stuff to fix it, or is it to remove and live with the loss? This is a double edged sword. Removing is generally dangerous and can cause things to break, while adding is generally safer… which might explain growing complexity in most software systems I suppose engineers need to be brave and ruthless to remove code and fight growing complexity…
- CapitalistCartr 3y agoComplexity and simplicity have a duality. Cars of sixty years ago were much simpler, but required more complexity to own and operate. More skill, more discipline, more maintenance. New cars are FAR more complex, and are far simpler to operate.
- vonwoodson 3y agoWhat is simplicity? Each micro-service in and of itself is simple, but the network of message passing is complex. Ok. So, a monolith is simple, until it’s been maintained for a decade or more and has been patched and re-patched by generations of engineers who didn’t really ever have the ability to maintain the original simplicity in the face of feature creep and practical development issues. Ok. Maybe the problem isn’t simple. Or worse, there is a simple and easy to understand general solution that makes “everyone else” think they can do better, but the reality is that the problem is chock full of edge cases and special considerations. Leading to endless criticism and “bike shed”ing. —— An aside about what engineers want. I do feel that the desire for a “simple” or “elegant” solution to problems is as out dated as The Enlightenment itself. We seem to want to force order onto a disorganized world and exalt and marvel at the rare situation where it actually works out that way. But, it seldom does work that way. I can understand that the article seems to be focused on “unnecessary complexity” introduced by large frameworks for creating seemingly simple websites… but, this sounds a lot like folks complaining that Java code is less efficient and/or larger than assembly. Like, of course you can write “simple” code for your project, but there are many concerns that engineers hold in high regard beyond simplicity: correctness, reproducibility, maintenance, to name a few. And, we cannot be calling ourselves engineers if we don’t adhere to the most basic engineering principles of “standards”. That last one especially rings for me, if ever problem requires a scientific exploration than we’re not doing engineering work, we’re doing research. So, the use of frameworks, even “bloated” ones, brings us much closer to standardization than one-off boutique, yet (possibly) simple, solutions. —— Anyway, back to complexity: A perfectly fine website may require a 30-second load time… try walking to a store and finding the good you want and standing in the checkout line and missing your bus and having to carry the thing all the way back home and opening the box to find out that it’s broken and hauling it back to the store and then they tell you that that was the only one and then having to wait 4-8 weeks for a new one to be ordered and delivered and repeat the process all over again. Perspective is important on what “complexity” even is.
- neilk 3y agoSurvivorship bias. The current set of people who elect to work on web frameworks don’t want simplicity. Everyone else does, including the people who never entered the field because it is now incomprehensible.
- iptq 3y agoI think this article confuses "simplicity" with "less code". Often times when we talk about simplicity, it's about overall conceptual design, and on the note of dependencies, it's often _more_ simple to use something that does the job and brings in some more dependencies than it is to aggressively try to prune and end up costing more maintenance burden.
- neuromanser 3y agoYou might be confusing ease with simplicity. It's /easier/ to use something that pulls in more dependencies rather than write that bit myself; complexity of my software goes up. It's just entropy.
- crabbone 3y agoI cannot speak to the modern Web development, as I can only have a glimpse over the shoulder of someone else doing that every once in a while. But, I see a similar problem with development environment configuration and management. It's common to have multiple configuration files for multiple utilities that are supposed to do something in development environment: run tests, lint source code, spawn a mock-up of the system being developed, perhaps some VCS automation and often all sorts of integrations with other tools used in the project. Projects become cluttered with various "dot-files" with various configuration formats, and because those tools need to cooperate somehow, you also see bits of configuration for one tool embedded (while escaped) in configuration for another tool, and sometimes even multiple layers of escaping. There are usually straight-forward alternatives that simplify the process, make it more uniform. My explanation for why those alternatives aren't used is vanity. Users of projects with unwieldy configurations pride themselves on knowing and using a bunch of (unnecessary) tools, they like to appear savvy to their peers by discussing advantages of and new developments in these tools. And because the explanation is so simple and so unflattering, few will dare to acknowledge it. It's also usually the case that one would need at least some years of experience to accumulate all the useless knowledge of development infrastructure tools, and so these "opinions" about tools will often come from more senior programmers in the group, often driving the junior programmers to unquestionably accept the unnecessary complexity of their environments as status quo and come up with all sorts of rationalizations for why it's normal to have this many cross-referencing configuration files and various infra tools. I've lost count of arguments I've lost when suggesting a simpler automation solution which didn't use (an unnecessary) tool. Here's just one example: A project aims to deploy a Python application with external dependencies (packages) in containers. Using pip to install stuff in containers was problematic because it took forever (due to solving dependency constraints, downloading from PyPI, installing a bunch of stuff irrelevant to the target application s.a. scripts for dependency packages, or tests etc. finally, poor network utilization). I suggested having a CI job which pulled vetted versions of packages on-demand, then have it strip those packages of unneeded cruft, put them in a tarball and use that for building containers. You had to watch the guy who was a level above me in work hierarchy and was somehow responsible for CI get red in the face and start making saliva bubbles as he was getting ready to destroy and ridicule my "insane" idea... all because it didn't use pip.
- owlstuffing 3y agohtmx for the win.
- max_ 3y agoI really wonder why htmx hasn't caught on. Everyone should be using it at this point.
- owlstuffing 3y agoOh, it’s catching on
- owlstuffing 3y agoSometimes tools are deceptively simple. Small examples magnify benefits. However, in the large problems become intractable. But the sunk cost fallacy is there to prevent change.
- sharas- 3y agoTrue but why? "Plea for lean software" by wirth https://cr.yp.to/bib/1995/wirth.pdf https://cr.yp.to/bib/1995/wirth.pdf explains how complexity sells. Playground IT attempts to explain the "psychology" of that complexity: https://bitslap.it/blog/posts/playground-it.html https://bitslap.it/blog/posts/playground-it.html
- hliyan 3y agoMy god, that first article is from 1995, and almost 30 years later, it is still true.
- ants_everywhere 3y ago"Conservation of complexity" is a useful concept in my experience. You can shuffle the complexity around, but usually you can't eliminate it. In practice, most software solutions I see that emphasize "simplicity" are really putting the complexity elsewhere, typically on the user. More complex solutions have more features because the user needs to get stuff done. The simple solution doesn't have those features, so the user now needs to either do more manual work or rely on additional tools. The simpler tool has made the user's life more complex. My pet theory (that I just made up) is that what you really want to do is start with something ugly that gets at the real shape of the solution, and then simplify it over time. So "simplicity" is a refinement process like moving from the rough cut of a sculpture to the finished version. But I'm skeptical of simplicity as an up-front design requirement. If you value simplicity so highly that you're never willing to have ugly complexity, then you miss so much of the design search space that you're unlikely to find a good local maximum.
- layer8 3y agoThere’s accidental complexity and essential complexity. The former can in principle be eliminated. The web tech stack is brimming with accidental complexity.
- ants_everywhere 3y agoThat's a Fred Brooks distinction, and not one that's (AFAIK) used outside of software consulting literature. In his essay, he basically uses "accidental complexity" to mean complexity from the past and "essential complexity" to mean "current complexity". He also says all software complexity is essential: > The complexity of software is in essential property, not an accidental one. Hence descriptions of a software entity that abstract away its complexity often abstract away its essence. This is pretty close to what I was saying. There are, of course, more standard notions like Kolmogorov complexity. You could argue that the essential complexity of something is its Kolmogorov complexity. But I don't think anyone means that when they talk about essential complexity.
- nickjj 3y agoI think there's different contexts around simplicity and what your goals are. For example, yesterday I was learning about VPNs in more detail and got WireGuard installed on Debian. It took 3 hours to get it working with no knowledge of WireGuard or how VPNs really work beforehand. Then I came across PiVPN which is a user friendly front-end for WireGuard (or OpenVPN) which works with or without a Raspberry Pi and I got that working in literally 5 minutes. I'm happy I took the 3 hours to better understand how all of the pieces come together but I'm way happier using PiVPN in the end because the interface to use it almost can't be easier given how much complexity it's hiding away.
- sjducb 3y agoThere’s a difference between complexity that’s inherent to the problem, and complexity that’s added by developers who have drunk architectural cool aid. This is an example where all of the complexity is caused by rigid adherence to the most popular architectural patterns of about 10 years ago. https://github.com/EnterpriseQualityCoding/FizzBuzzEnterpriseEdition https://github.com/EnterpriseQualityCoding/FizzBuzzEnterpris... It looks completely ridiculous to modern eyes, but during peak OOP it was just how you should do it. If you like simplicity then your fizz buzz implementation would be a few lines.
- doctor_radium 3y agoIs there really a complex version of that algorithm? Or perhaps that's the joke?
- russfrank 3y agoWhat? No, this was always supposed to be a parody. Did you find this 10yrs ago and think it was serious?
- sjducb 3y agoI’ve worked on code bases like this. It is a parody, but it’s not too far from reality. Reading my original post i probably shouldn’t have said it’s how you should do it. I mean that lots of engineers created loads of pointless complexity with OOP
- dav_Oz 3y agoA bit ironic that the same quote of Dijkstra appears on both comment sections. He is also infamous for: >[...] software engineering has accepted as its charter 'How to program if you cannot.'" [0] (1988) The context is that CS has to tackle two "radical novelties" which aren't reflected accordingly in real world applications and education: (1) Deep conceptual hierarchies: >From a bit to a few hundred megabytes, from a microsecond to half an hour of computing confronts us with the completely baffling ration of 10^9! The programmer is in the unique position that his is the only discipline and profession in which such a gigantic ratio, which totally baffles our imagination, has to be bridged by a single technology. He has to be able to think in terms of conceptual hierarchies that are much deeper than a single mind ever needed to face before. Compared to that number of semantic levels, the average mathematical theory is almost flat. [EWD1036-7] (2) Large-scale digital device: >It is possible, and even tempting, to view a program as an abstract mechanism, as a device of some sort. To do so, however, is highly dangerous: the analogy is too shallow because a program is, as a mechanism, totally different from all the familiar analogue devices we grew up with. Like all digital encoded information, it has unavoidably the uncomfortable property that the smallest possible pertubations - i.e. changes of a single bit - can have the most drastic consequences. [For the sake of completeness I add that the picture is not essentially changed by the introduction of redundancy or error correction.] In the discrete world of computing, there is no meaningful metric in which "small" changes and "small" effects go hand in hand, and there never will be. [EWD1036-9] [0]https://www.cs.utexas.edu/users/EWD/ewd10xx/EWD1036.PDF https://www.cs.utexas.edu/users/EWD/ewd10xx/EWD1036.PDF [EWD1036-10]
- myth2018 3y ago> For another, the ability to control how a checkbox animates when you check it is of course a valid reason to add another 50 packages and 3 layers of frameworks to their product To be fair, this sort of complexity usually results from "UX" requirements. Just think about what it takes to materialize those damn figma designs. Google's Material Design is not a simple "skin". When it comes to business applications (forms, reports, requirements strongly influenced by end-users and evolving in ways hard to predict), my most successful experiences consisted of multi-page apps + vanilla js for validation. My last project in this field failed though. The client was infected by the figma virus and I failed to compatibilize this methodology with the UI fluff they so fiercely demanded.
- commandlinefan 3y agoAlways, always, always - when I'm faced with a new project using a new technology, I have two choices: 1) spend an indeterminate amount of time reading documentation until I actually understand what I'm doing, and have nothing to show for the time I spent gaining a deep (or at least decent) understanding. 2) Just jump in and start coding, bugging people to look at error messages for me, google when that doesn't work, skim the documentation when that doesn't work, cut and paste examples when that doesn't work, but have something to "show" at the end of the day which is far more complex, slow and unpredictable than a well-thought-out solution would be. Every year of my 30 year software development career has been spent under software management fads that insist on the second approach because it provides an illusion of productivity and predictability. I actually had some hope when XP came out in the late 90's that the tide was turning here, but XP became Agile, which was "meet the new boss, same as the old boss".
- blablabla123 3y ago> 1) spend an indeterminate amount of time reading documentation until I actually understand what I'm doing, and have nothing to show for the time I spent gaining a deep (or at least decent) understanding. Tough to explain to management or colleagues sometimes. (On the other hand everyone seems to "know" it's the right approach because even today just looking up something on SO is not seen as the highest standard)
- commandlinefan 3y agoI usually end up doing it anyway and taking my "lumps" for the week that I spent learning but not producing. Get frustrating when the #2 crowd starts demanding that I drop everything and help them since I'm now the "expert", though.
- sheepybloke 3y agoI've found that even if you start with #1, you end up doing #2 anyways, whether it's because the documentation wasn't complete or you didn't realize what you were trying to build until you started building it. I always start with #2, since in my mind, it often encompasses #1. I've also found #1 leads to analysis paralysis.
- captainbland 3y agoComplexity and simplicity are... Complex. Brainfuck is simple in its own design but using it to do anything in particular is not. Some Java code bases are borderline patronising in their apparent simplicity but are actually built on many layers of complexity which is then hidden. So when you say you want "simplicity" I have to ask what you mean by that. Where do you want simplicity and where can what you think of as simplicity arise as complexity elsewhere? I think there are more nuanced trade-offs than unqualified notions of "simplicity" and "complexity" don't capture very well.
- kerkeslager 3y agoTwo major problems with this: 1. It's a very naive idea that our actions can always be construed as evidence of what we want. The fact is, humans aren't purely rational beings, and we don't always do things that lead to what we want. Particularly, short-term dopamine-rush type desires can override our more fundamental wants and even needs. The person who wants to lose weight gives in to a short-term craving for a cookie, the guy who wants a relationship gives in to a short-term fear of rejection and doesn't approach the girl, the person who wants to save money buys the cigarettes to deal with their stress. The idea that anyone is immune to this is arrogance, and it's uncompassionate to not allow for this in our understanding of others. 2. Simplicity is defined in a lot of ways, many of which don't make much sense. For example: > A lot of developers want simplicity in the same way that a lot of clients claim they want a fast website. You respond “OK, so we can remove some of these 17 Javascript trackers and other bloat that’s making your website horribly slow?” – no, apparently those are all critical business functionality. This is assuming simple == fast, but that's not in evidence. One might plausibly improve speed here by loading the 17 Javascript trackers asynchronously after the visible parts of the page have loaded, thereby creating the visual impression that the site is faster, which is likely what the client means when they "claim they want a fast website". By any reasonable definition this is more complex, but it's faster by the definition the client is likely using. In optimization this is super common: quicksort is faster but more complex than bubblesort, hash tables are faster but more complex than lists of key/value pairs, etc. "Fast" is a really poor approximation of "simple" in this context. Really this is an example of really poor listening on the part of the author. They're not taking the time to understand what the client wants to be faster, and are instead incorrectly telling the client that they need to remove core business functionality in order to do that[1]. [1] As a side note, I've managed my entire career to avoid working for companies that have 17 Javascript trackers installed, and in all likelihood you can too. If you don't like working on sites that have trackers installed, then I think it's more mature to be honest about that with both yourself and your clients, rather than setting up artificial roadblocks like "this can't be fast because of trackers" which is passive-aggressive if you're saying it just because you don't like the trackers.
- bradley13 3y agoSome what related: cookie banners. What value do those optional cookies really generate, and is it enough to be worth annoying all of your visitors? After all, if they had only "essential" cookies, they could skip the banners. Do businesses ever consider the cost of maintaining and serving huge, dynamic web pages, when simpler ones would do? What savings in hardware (or cloud services) and staff time would be possible?
- waffletower 3y agoThe Apple ecosystem is somewhat insulated from this logic, though I find myself wanting more complexity than I am offered, particularly from Apple's cloud services.
- AlbertCory 3y agoLook up Sunk Cost Fallacy. No, you can't remove all that code. Think of all the person-months we sunk into it! There's almost nothing harder, organizationally, than taking something out once it's in.
- steno132 3y agoSimplicity sucks. Functionality rules. Reliability: I don't want a single host EC2, I want a multi-AZ Kubernetes cluster. Security: I don't want a EC2 behind a firewall, I want a zero trust architecture. Performance: For a auth service, I don't want a boring Spring Boot app, I want a performant Rust server.