12 ms·
People who disagree aren't trying to make things complex
- pcunite 8y agoI heard somewhere, "People are not against you. They are just for themselves."
- ilaksh 8y agoA big part of this is that programmers have different programming worldviews. Many people seem to be unaware that worldviews are not perfect rational easily modifiable constructions but are instead foundational structures that thinking builds upon automatically. Programmers are about as unlikely to easily change their programming worldviews as they are to change their political beliefs. Which is not to say that programming worldviews can't change, it's just that by their nature it takes a strong effort to change then and the changes are usually gradual over time. Or something completely irrational changed them. For example if a programmer needs to find a new job and the team has a different approach to programming, this social circumstance may necessitate that he adopt a new viewpoint. I think that people are less rational than they think they are. Which is not to say that they can't be rational, it's just that other preformed factors besides logic have a strong influence over our perspectives on a particular topic. So we can certainly discuss things productively but we should be aware that people can't change their religion easily. And no matter how smart or rational everyone has strong beliefs because that's just how our brains operate. One consequence is that when trying to have rational discussions it is necessary to try to dig in to identify all of people assumptions, since there is a good chance of of the other person's programming beliefs may play a big role in their thinking and you may not even be aware of it.
- 0xdeadbeefbabe 8y agoHave you seen the mkdir world view? It's the one where all the code is spread out over as many directories as possible, and leaf directories typically have no siblings just yet and one child.
- noobiemcfoob 8y agoIs this a particularly egregious worldview that should not be tolerated?
- Roboprog 8y agoTolerated, but not enjoyed. Gotta live (work) in a Java world.
- 0xdeadbeefbabe 8y agoYes it rarely works out well, but mostly I just wanted to focus on an actual worldview instead of good vs. bad.
- taneq 8y agoI think this is a special case of the 'simpler is better as absurdum' approach, where you only ever write 1-3 line functions, each in their own file, because they're 'simple'. Of course, this really just moves the complexity to the composition of these functions and destroys locality of reference for anyone trying to read it.
- userbinator 8y agoI've found that this is true particularly when working in OO styled languages --- there seems to be an innate desire to minimise microcomplexity at the expense of greatly increasing macrocomplexity. It's like writing a book where each page contains one word. Each individual piece is "simple", but taken as a whole it's much more difficult to understand.
- lodi 8y agoI like this analogy: it's like writing about a difficult or nuanced subject using only "simple English"; each sentence is superficially simple, but the work as a whole is much more difficult to make sense of.
- Nasrudith 8y ago
- dmreedy 8y agoThis is a great comment, and very succinctly put. Somewhat incidentally, but I believe this is a large part of why, to me, software development is not an engineering discipline. At the end of the day, engineers (I think; not actually being one myself) have to answer to physics. The 'possible model space' is relatively constrained, and everyone is working under, roughly, the same set of assumptions, rules, and standards. This kind of constraint allows for higher degrees of rigor, because there often is a 'right way' to do things, or an empirical set of tests to verify the quality of an idea. Software is, on the other hand, only slightly more constrained than mathematics in its most basic form. We can introduce artificial constraint by monopolizing a domain with certain ideas that have proven robust and reliable (in the same way that we've decided that, in general, you turn a screw clockwise to tighten it), which in turn allows for the introduction of some engineering-style rigor and standards, but there's nothing really stopping you from stepping back and saying, "well I want to do it this way instead", in the way that an Engineer is prevented, by physics, from saying, "well, I think we should just alter the density of air so that we don't need to worry about lift for these airplanes we're building; they'll just be buoyant!". By and large, you can do that kind of thing in code; you're building the world within which you're going to solve the problem, and you can arrange that world as you see fit (by and large) to make certain aspects of the problem easier (often at the cost of making others harder), in the same way a mathematician does. And if you've got one kind of world you really like, because it works well with how problems decompose in your head, it can, to the parent's point, be really difficult to understand why another representation might be just as useful to someone else's particular brain arrangement. Not trying to make value judgement here, though I do envy and admire engineering rigor. Just a (likely naive) take on a fundamental difference.
- jgtrosh 8y agoWhen you're fighting for speed on your code, it ends up feeling like what you're describing of that engineering world. Your techniques have to adapt to what is actually happening in the lower layers. When you're fighting for ease of use, you can't make your users forget their preconceptions, you have to adapt to these externalities. I think sometimes engineering and software development have different degrees of freedom, but the difference isn't as clear cut as you make it.
- ionforce 8y agoI feel like most of the strife caused at work is different value judgements on things. So I've been trying to tease out truths vs value judgements. 1 + 1 will always equal 2, no one debates that. AWS offers both Postgres and MySQL, no one debates that. But which one is better, that will be informed by possibly irrational value judgements ("Postgres bit me once, never again!") I think people are irrational in terms of their inability to admit where their biases are ("Postgres bad") vs things that are largely factual ("we can choose between these vendors").
- Bjartr 8y ago> 1 + 1 will always equal 2, no one debates that. Challenge accepted. * In boolean algebra, 1 + 1 = 1 * Over the field Z2 (the integers modulo 2), 1 + 1 = 0 * In binary, 1 + 1 = 10 * In a language that allows overloading +, 1 + 1 = usually 2, but potentially almost anything else In conclusion, context matters
- trainingaccount 8y agoWot no vectors?
- marcosdumay 8y ago|1> + |1> = 2 * |1> =/= |2>
- mclehman 8y agoTo be fair, in Z2 the equivalence class of 1 + 1 is still equivalent to the equivalence class of 2.
- animal531 8y agoAnd of course 1 + 1 + Solar Flare = N
- candiodari 8y agoI've seen this very often. People are absolutely consumed by avoiding their previous mistakes. Sometimes those are even searched-for almost-made-up mistakes rather than real ones, like in postmortems for successful projects. And then BIG changes are implemented in the process. Usually in the worst possible place: in the planning of the process in the first place. If a project succeeded, and finished, your adjustments towards future projects, of course, should be tiny and minimal. In practice people make sweeping changes ("level 3 testing needs to be planned in before we even make the software design" boomed the senior architect). And yet one lesson you quickly learn in machine learning is that whilst making adjustments that are too small ... does pretty well. You can be off by a factor 10 and while sub-optimal it works (and often, the further you get the smaller the adjustments should be). By contrast if your adjustments are 1.1x what they should be you are stuck. You will never get where you're going. Never. That's a complete failure and you should expect to do worse and worse over time with such a strategy. So a smart person should almost always err on the side of not adjusting a behavior. Certainly from one project to the next, making more than 2% adjustment is absolute lunacy. This never works in learning algorithms. Never (0.1% is the largest generally used value). That would mean that for every software engineer in your team there should be ONE day difference EVERY 2 MONTHS from one project to the next. That's 2%. Even that is an absurdly large change, far greater than wise. But I've never even once seen a software team that doesn't start with making 20% (one day a week different) adjustments between projects. And I've seen people make much bigger changes than that, generally not with better results. And the thing they're proud of is that they avoided a previous mistake ... a mistake they solved ... often much quicker than the delays caused by the adjustments ...
- stcredzero 8y agoProgrammers are about as unlikely to easily change their programming worldviews as they are to change their political beliefs. Programming worldviews are political belief systems. They're just as subject to bias and groupthink. They can be just as free from empirical grounding. It's just that their context is somewhat abstracted away from the real world.
- shuntress 8y agoI completely agree with your comment but since we are on the topic of worldviews and assumptions I just want to point out that women program too. My assumption currently is that you do not switch pronouns arbitrarily and as a result were not just as likely to send "social circumstances may necessitate that she adopt a new viewpoint" when writing about an abstract individual programmer. I know it is annoying to have this brought to attention but my world view includes the notion that small actions like this can have a profound effect at scale. >social circumstance may necessitate that he adopt a new viewpoint >when trying to have rational discussions it is necessary to try to dig in to identify all of people assumptions
- btilly 8y agoMy experience of writing that switches pronouns arbitrarily is that it continually draws attention to the ratio of men and women in programming, which makes the lack of women more obvious. I first noticed this in an advanced physics course where in deference to the presence of a lone woman in the course the professor consistently said "he or she". Except that it was a conscious attempt and served to draw attention every time to the lone she who clearly looked uncomfortable. This is why I prefer to use singular they instead. It is less annoying, less likely to make people uncomfortable, and can easily be seen to include people no matter what their gender happens to be. It even includes those whose gender is ambiguous in some way. It is a small thing, but my world view is that small improvements like this add up to create a more generally welcoming atmosphere.
- randomdata 8y agoThe dictionary definition of singular they is, quite literally, “he” so you haven’t really improved on the concerns some have with he in using they.
- ilaksh 8y agoThere is a problem with the English language. There is no commonly used neutral pronoun. The closest thing is "they" but I think some people consider that incorrect grammar or something. he/she or switch back and forth is awkward.
- rdiddly 8y agoOne consequence is that when trying to have rational discussions it is necessary to try to dig in to identify all of people assumptions, since there is a good chance of of the other person's programming beliefs may play a big role in their thinking and you may not even be aware of it. Amen to this, and by the way, it doesn't even have to be in the context of a discussion about a particular issue, let's say issue A. You can blunder into someone else's kneejerks unknowingly, on a whole other topic called issue B, and they will MAKE it be about issue A.
- kokokokoko 8y agoThese are great points and I wanted to add a couple more I've found over the years. Software development often has an almost infinite number of ways to accomplish the same task. Maintainability is as much, if not more, about correctly predicting the future uses and requirements of the software as it is about the initial coding practices and design patterns. Working on older systems that are being used in ways that they were not originally intended is often uncomfortable for a developer. All but the most junior developers tend to have some painful memories of battling legacy software. These add up to a situation where it is incredibly difficult and vague to determine the correct path. Both because there are so many ways to accomplish the task and because there are so many unknown future contingencies that ultimately determine how maintainable the software will be. Combine that with the painful memories most developers have from nightmare projects and you have yourself a recipe for emotional disagreements all around. The grand irony is that, very often, once a developer becomes fully aware of this concept, they lose that internal fire and vigilance required to constantly seek out better ways to solve problems and their skills wane.
- nomel 8y ago> The grand irony is that, very often, once a developer becomes fully aware of this concept, they lose that internal fire and vigilance required to constantly seek out better ways to solve problems and their skills wane. Any hints to guide one back to the path of passionate problem solving?
- wesammikhail 8y agoWork on bigger problems that are a lot harder to solve. You cant mitigate for reality, but what you can do is offset its shittyness but taking on a project/task that yields results that are big and great enough to justify dealing with shitty systems/ heuristics to begin with. Just my 2 cents!
- shrimpx 8y agoI concur. In other words try to be on the "edge" where you're not looking at the same old patterns you've seen before, but are always attacking something relatively unknown. In my experience, senior people who always target their domain and level of expertise are bitter and jaded.
- stcredzero 8y agoOne consequence is that when trying to have rational discussions it is necessary to try to dig in to identify all of people assumptions A coworker of mine who once worked at Symbolics used to call this, "Applied Philosophy."
- shrimpx 8y agoGreat comment. Sometimes I find conversations/debates between programmers get lost in irrencoilable levels of abstraction that are driven by status. E.g., the new data scientist looking to make a mark is desperately calling for "streamlined dataflows throughout the system" while an experienced builder is wondering wtf this means in terms of actual code written, and can't get the other person to spit out anything concrete -- because they have nothing concrete to spit out, but they de facto insist that what they're saying is sensical and valuable.
- akvadrako 8y agoCoincidently, people (and other beings) also have different worldviews in every context and not acknowledging this leads to endless pointless arguments. It would be cool if the participants of every discussion (programming or otherwise) labeled their worldviews explicitly, so we could at least know what we're dealing with. For example on here with a tag by our usernames. Old religions used to serve that purpose at least to a first approximation - we really could use some words to describe the new ones.
- macca321 8y agoI keep thinking about making a site like the political compass but for programming opinions. Probably with a tinder swipe left/right to agree disagree.
- barberousse 8y agoThis is a particularly thorny issue as a Junior Developer. There's the issue of the Junior reaching beyond their britches, but there's also the issue of Seniors being set in there ways.
- brabara 8y agoAs mid level developers, how can we resolve this impasse?
- jarjarblanks 8y agoNot sure this is a job for a mid level developer? Sounds more like a manegement issue.
- dwaltrip 8y agoThere is no ultimate solution. Just continual efforts to make things better, gain deeper understanding, remove unnecessary complications, and improve overly simplistic solutions. If you were simply making a joke, forgive me =)
- brabara 8y agoNo joke at all, sadly I see this day to day.
- deleted 8y ago[deleted]
- brabara 8y agoAs someone who has read Moby Dick front to back I can agree with this argument. I had a colleague once, really bright engineer but not as steadfast as I was at the time. I suggested he read this amazing novel and he instead opted for the book on tape. During a long drive he almost died from boredom. Literally! He almost fell asleep at the wheel. While he disagreed with me that manually reading the book was the optimal approach he was not trying to make things more complex. He was merely trying to take the easy way out. This grave mistake almost cost him his life. Consider this tale next time you are thinking about not putting in some work!
- googlemike 8y agoThis comment feels like a markov chain wrote it. Do you really find parallels between this anecdote and reality? What if we presented an anecdote of the opposite to you, would you change your worldview entirely? If not, why should anyone who reads this?
- brabara 8y agoI don't think the point of most comments are to change someone's worldview entirely (unless of course they are disputing religion or something on that level). Perhaps they might help to mold it over time but if a single comment can change the way you view the world I think your view was too simplistic to start.
- 0xdeadbeefbabe 8y agoAlexa, tell me a story.
- brabara 8y agoYou can say "Alexa, read me Moby Dick".
- 0xdeadbeefbabe 8y ago
- kyleperik 8y agoI agree that the idea of "simplicity" can become convoluted. But some of his specific examples I strongly disagree with. Like others are saying, it comes a lot from your worldview on programming. Coming from someone who was involved in an extreme Microsoft Stack (which I definitely get from the vibe of the writer here, either that or Java?) and gone away from that, I can say simplicity wins. It really just depends on how simple the given language allows you to be, and what that looks like. In my personal opinion the Microsoft Stack really traps you in a box. Not a bad stack, but you can't really translate the "patterns" you have to use there into a lot of other stacks.
- dahart 8y ago> What if there is no "complexity trap", just disagreements about how best to design programs? While I think this post asks reasonable questions, and has some healthy skepticism, the complexity trap is very real, in my experience. After 20 years of professional software development, I can safely say I've watched literally tens of millions of dollars wasted over-engineering solutions to problems that were anywhere from smaller than advertised to did not actually exist. I also freely admit that I personally tend to deep dive on cool/elegant/fast/small solutions where my time to achieve the optimal program is never recouped by running the program. There absolutely is some under-engineering too, I've done some, and seen some in the wild. But on the whole my samples are that over-engineering is the dominant problem. That might not be true for people who hire contractors; from that point of view, getting less than you think you paid for is probably the most common experience.
- Raidion 8y agoWell, I feel like the environment of the job coupled with the developer causes over-engineering, rather than true technical concerns. I'm fairly young for my new role and architecting (from the ground up) some fairly big systems. I'm really struggling not to over complicate problems and I think it's really easy to do for a couple reasons. The selfish architect I'm working very hard not to be would rather have his work be complex. This builds ego if it works and you can always argue "it's a complex problem" if it doesn't. He'd rather face the shame of maintaining software that's overengineered as that's a very low visibility cost. No one bats an eye at estimates to update an existing system if it's needed. On the other hand, failure to account for a use case you deemed 'a bit complex for MVP' is super visible, even if it's a miscommunication between product and development. This selfish guy doesn't have eyes for business needs, he just falls in love with solving a problem, when he starts to elaborate on capabilities that it could have, product manager will just nod and say "oh yea, that might be nice", so you over-engineer to make sure that pathway is open, even if the product lady forgot about that possible feature before she left the meeting. He's also afraid of showing up at a meeting saying we solved the problem with a boring tweak on an existing implementation and having someone show him up by asking questions about why he didn't just use a software platform or language that felt foreign and complex when he read a few articles about it on reddit. Idk, felt good to vent some of this stuff, but those are the things I have to make sure I'm aware of, otherwise I'm just gonna build shit to the ceiling.
- austincheney 8y agoI deliberately try to make things complex, but not more complex than they actually are, though apparently this is received as a matter of perception. It commonly boils down to risk or performance versus convenience. As a senior developer I notice that juniors will sometimes do everything in their power to over-simplify a given problem. This is more often due to insecurity than accident or technical ignorance and while their motives are often unintentional (non-cognitive) the actions are often exceedingly deliberate (cognitive decisions). When this occurs the developer isn't changing the problem. They are changing themselves and their approach to the problem. Unfortunately, this is evidently reflected in the quality of work. Pointing out this shortcoming can result in conflict because the offending party's actions, even though often unintentionally motivated, are deliberate and thus the criticism may be received as unnecessarily too precise or picky. Again, its all about risk or performance in the product versus the individual developer's confidence displayed as a convenience.
- cabaalis 8y agoI have the opposite experience. I think a senior should focus not on identifying the complexity of a problem, but identifying the complexity of the proposed solution. What are the bottlenecks? What possible situations wouldn't fit into the proposed schema? Would a table of 1k records that have a seemingly large number of columns suddenly become 10m records because you decide to use an EAV? To mitigate issues, is a solution full of contracts and complicated dependencies the right answer? Or is the right answer to not use the ORM for that one particular call and just write a parameterized SQL query or proc that gets the job done? That kind of insight upfront only comes from experience, which is what a senior has to offer most of all.
- nowarninglabel 8y ago>I deliberately try to make things complex I see this often with someone who has made it into a senior role and then is attempting to ensure job security through complexity. Reflecting this on to junior developers further reinforces that said developer has adopted (usually subconsciously) a fear-driven approach.
- 8y ago
- justicezyx 8y agoThis article reads into the replies article and hand picked a few points. While actually the article agree on the article it referred to. But the wording has been in a way that is argumentative, which is rather immature imho.
- james_s_tayler 8y agoSoftware is art, fashion and politics.
- 0xdeadbeefbabe 8y agoNo it's about right and wrong. That's why software is fundamentally binary.
- james_s_tayler 8y agoThat's what people make it about. It's classic misdirection. You know, the 20th century American sci-fi writer Robert A. Heinlein in his 1953 novel Assignment In Eternity wrote "man is not a rational animal; he is a rationalizing animal." And Aristotle said that man was a political animal. I deduce from that that "man is not a political animal; he is a politicizing animal." That's why we get arguments and debates around there subjects and they become so heated. The truth of the matter is the only way it's possible to compute the answer to any given programming debate is to implement all suggestions in parallel universes and see which one doesn't cause World Was III inadvertently. You can't compute the answer, so you go off hueristics of what's a) what's popular in the wider community (fashion) b) what's popular in your local community (politics) and c) what's popular with you (art). I need to write a full article on this viewpoint at some stage.
- quickthrower2 8y agoWho decides if something is right or wrong? Have you never heard a developer debating "is this a bug? is this a feature?"
- lemmsjid 8y agoUsually software design debates (such as this one) are not about the state of a software application right now (the 0's and 1's), but about how quickly it can change, how well it can be understood, and how amenable it is to debugging. None of those are binary concepts. Not to mention that software applications can have many states to reason about. And many (most?) applications are undecidable, and hence resistant to analytical closure.
- 8y ago
- avip 8y agoCouldn't read because of the terrible font but I'm sure I disagree with all he says.
- anonytrary 8y agoI read your comment expecting to see something like Papyrus, but it was just Georgia and Times New Roman. What's the fuss about?
- kgwxd 8y agoSo, we should just "agree to disagree" and stop trying to demonstrate how one approach might be much better over another? How can anything ever get better? The Complexity Trap didn't accuse anyone of actively trying to make things complex, nor did it imply any "moral failings" on anyone's part, it just gave examples of how common practices can cause accidental complexity. It also dedicates an entire section to defining "complexity" as used throughout, so there's no ambiguity there.
- lmm 8y ago> So, we should just "agree to disagree" and stop trying to demonstrate how one approach might be much better over another? How can anything ever get better? No, we should try to make things better. But framing these choices as "complexity" doesn't seem to be helpful. The choices are tradeoffs but they're not a deliberate choice of complexity for the sake of some other value; at most they're choices between different kinds of complexity, and maybe not even that much. > It also dedicates an entire section to defining "complexity" as used throughout, so there's no ambiguity there. And yet I used that same definition but came to opposite conclusions when applying it to the original author's examples.
- goflyapig 8y ago> deliberate choice of complexity I also don't see anything in The Complexity Trap that accuses anyone of that. I think that's a misreading. Rather, I think The Complexity Trap argues that many developers have a poor understanding of what "complexity" means, so they end up increasing it even when they think they are decreasing it. Specifically, I think the point it tries to make is that complexity doesn't equate to verbosity, and simplicity doesn't equate to terseness. That's why it starts by defining complexity in terms of coupling. Your article seems to agree that DTOs are more decoupled because you refer to it as "cargo cult decoupling", yet you still argue it's more complex. So you aren't using the same definition. Having said that, I do agree with you that blind "decoupling" is definitely not always the answer, and some things should be coupled. When a change in one thing should always cause a change in the other, purposely coupling those things in code can decrease complexity. But I wouldn't say coupling your public API to your internal model by generating the former from the latter is one of those cases. It's something that's done for convenience and terseness, at the expense of complexity. (It's more complex because changes that would otherwise be simple refactorings could cause breaking changes for consumers of your public API in ways you would not expect. For example, you won't be able to use automated refactoring tools safely without carefully thinking through the consequences in your head.) Depending on the project, trading complexity for terseness/less boilerplate might be the right decision. But it should be done consciously.
- alexandercrohde 8y agoI have to pretty much reject this post wholesale. True the post it's disagreeing with picked weak examples. But other than that pretty much all of its overall points were actually very accurate. The original article was not about json/scala/etc. It was about this: To summarize, we have to deal with a lot of accidental complexity these days, for multiple reasons. First of all, we adopt techniques and abstractions without analying and evaluating their costs and their usefulness in our specific situation. Moreover, we love solving technological problems.
- lmm 8y ago> True the post it's disagreeing with picked weak examples. But other than that pretty much all of its overall points were actually very accurate. That's what I initially thought. But how can the overall points possibly be right if they lead to exactly the wrong conclusions in most or all of the specific examples? At best the part you quote is vacuous and unhelpful for actually making technical decisions.
- alexandercrohde 8y agoJust logically, a point can never be disproven with bad examples. Bad examples may be unpersuasive, may bore the reader, but they don't make a true point false. As best I can tell when you call his point "vacuous" you mean you think it's too abstract to be practical. I disagree. What I take a away from his article is: - Before you build something, ask yourself "Is this REALLY a technical problem? Or is it better solved non-technically?" - What are the costs, especially complexity, of this change? Weigh those against the benefit. Seems concrete and useful to me.
- lmm 8y ago> Seems concrete and useful to me. It sounds useful. But Westheide followed this methodology, presumably put time and effort into it, and yet made completely wrong technical decisions. So I don't believe the method can possibly be useful; he'd've got better results by saving his time and flipping a coin. (Put another way, this methodology doesn't outperform a placebo)
- just_myles 8y agoWhat a read. I agree, often times we overlook the obvious solution and tend to go for a more complex one. The approach should always be simple. I don't know why anyone would ever think otherwise. If the issue is complex in nature, you can still start with a simple solution before you dig into the weeds. I swear, sometimes people just love to work extra.
- btilly 8y agoSince this seems to be the place for personal views, my views, after 20 years of experience, is that people do not notice the complexity of anything that they have digested as normal. As a result doing anything other than what they are used to seems very complex to them. Whether that other thing is actually complex to a neutral third party is situation and observer dependent. I have seen this with procedural programmers struggling with OO code. OO programmers struggling with functional techniques. Programmers of all kinds seeing a new framework. Programmers used to more structured code trying to fix shell scripts. React developers encountering code using older JS libraries, and developers comfortable with older libraries encountering React. And so on and so forth. In all cases the common denominator is that the programmer is uncomfortable with the new way of doing things. And the first reaction is, "What's wrong with this code?" And "It's messy and complex" is one of the easiest conclusions to draw.
- deleted 8y ago[deleted]
- hartator 8y agoHa, it has been my reverse experience in all the examples cited. When learning functional, I had a haha moment as I was coming from OO. When learning React, I had another haha moment as I was coming from regular JS libraries. There is an objective truth that is there or not.
- ilaksh 8y agoI'm pretty sure a big part of intelligence is a type of compression. Once you are familiar with certain things, your brain automatically compresses and decompresses those patterns so you don't have to deal with them consciously much. You would not notice the same amount of complexity. Having said that, things like cyclomatic complexity do exists. Although smaller units that are simpler on their own, do mean there are more to mentally reassemble into the larger whole.
- userbinator 8y agopeople do not notice the complexity of anything that they have digested as normal ...which is why examples of "minimal complexity" code often provoke feelings of extreme unease and horror; one nice example is https://news.ycombinator.com/item?id=8558822 https://news.ycombinator.com/item?id=8558822 where the functionality:code ratio almost seems impossible at first glance. I have seen this with procedural programmers struggling with OO code. To be fair, a lot of OO code tends toward overengineering and premature abstraction.
- otikik 8y agoI can't if it's the typefaces, the interlining, the space between paragraphs or a combination of those, but that page was so unpleasant to read that I had to use Firefox's "reader view" to do it. I have no opinion whatsoever on the the text, but the presentation was so hideous that I thought it was worth mentioning.
- undershirt 8y agoIt's the negative line height—you can see by selecting multiple lines of text that the rows actually overlap each other.
- munchbunny 8y agoSpot on. The lines are too long and too scrunched together. I could feel myself involuntarily squinting to read it.
- deleted 8y ago[deleted]
- Myrmornis 8y agoJudging by the initial half-second of chaos on page load there's certainly something complex about the javascript this person is using to communicate these words.
- lmm 8y agoI used to have the content hidden before the javascript styled it, but people on this very site complained that they couldn't read my pages without javascript enabled.
- Myrmornis 8y agoCool, that sounds annoying :) I didn't mean to be issuing criticism on a trivial side-issue. I kind of thought no-javascript pedants stopped being listened to in 2014.
- deleted 8y ago[deleted]
- coldtea 8y ago>Having business requirements that interleave pure operations with effectful ones - "if the request exceeds one of our free account limits then check the user's subscription is still active in this external service" - is normal, like it or not. Isn't that what the "imperative shell" is about?
- jondubois 8y agoNo programming approach is perfect but some programming approaches are better than others. I started programming with a statically typed language for many years and then I went back and forth between dynamically and statically typed several times in my professional career. Once you've developed good programming habbits (which statically typed languages can help you to learn), ultimately, dynamically typed is better. Dynamically typed languages are simpler, faster to write, easier to change, easier and faster to test and debug, focus on raw logic instead of semantics, interact with external services more easily (JSON is the most popular data interchange format and it doesn't carry type information), integrate better with unrelated systems (no type conflicts when integrating different projects). Functional programming is really nice for some things but ultimately, you need to store state somewhere and often you don't want to store all the data in your entire system inside a single monolothic store or database - Often, you want data to be close to the logic which operates on it; having a global data store is often just as bad as using global variable names in your application; it can lead to conflicts (forces you to think about data in a system-wide way; not accounting for data from external systems) and makes it hard to track where the data is used within the system.
- rienbdj 8y agoI came to the opposite conclusion. Working on a dynamically typed project feels slippery... whenever you make a change it is difficult to know what will end up broken. I agree that deserialization can be a pain up front, but for the long term stability and assurances it is worth it.
- LandR 8y agoSometimes complexity is needed. I've worked on too many projects where it's just do whatever is easiest at the time to get it working ASAP. This works, for a while, but eventually that code base that no one really put any thinking into around design turns into a tyre fire. Maintenance becomes hellish, extending it becomes hellish and error prone. Finding and resolving bugs become excrutiating. So when people go for a more complex solution up front, it might not be complexity for complexities sake, they might actually be able to forsee issues in the future and want to avoid them. I wish more software development projects employed front loading the effort, either in terms of design / architecture / employing some sort of code analysis / quality control etc or even just thinking. Especially thinking. If the result of that thinking is more complexity, then it's fine. You're introducing complexity early, everyone can get used to it because it's going to make your lives in the future easier.
- jeklj 8y agoUntil there is some reliable way of comparing the complexity of two things, when people say something is “complex” what they usually mean is that they don’t like it or it’s unfamiliar. Or better yet, your complexity is incidental, mine is essential. I was forced to make it complex, you did it because you’re not trying hard enough! As Rich Hickey’s dictionary reminds us, to complect is to entwine together things better left separate. If you aren’t using the word in this sense, if you aren’t identifying the specific concepts which are complected but should be separated, you’re using fancy words to say you don’t like something. I’ve noticed we tend to do that, a lot. I’m very wary of doing this in my own thinking, personally. It’s okay to just not like something, and it’s more honest just to say so than to use objective-sounding words in an attempt make it about something other than one’s own taste.