Live data from Hacker News

Ask HN: Is Accidental Complexity Growing Faster Than Essential Complexity?

news.ycombinator.com

41–50 of 60 posts

Re: Ask HN: Is Accidental Complexity Growing Faster Than Essential Complexity?

#41
post #38

Well, a theory is that Agile is responsible for both. While its short devlopment cycles help deal with essential complexity (you understand better the customer's problem because you have more interaction with them), it also implies incremental coding which often increases the accidental complexity. As an example: After a short development cycle, you created a database schema where each Client class has a single addre…

Your simple example of associating a Customer/Client to an Address is a great one - it could be that a really simply approach is required, or you may actually need the powerful features around such things that some high end ERPs support.

In a previous job I spent a lot of time trying to get a shared understanding of what "customer" actually meant (this was initiated by realizing that the Customer Loss Ratios that execs wanted were really nonsense). This eventually turned out to be a non-trivial problem.

Re: Ask HN: Is Accidental Complexity Growing Faster Than Essential Complexity?

#42
post #38

Well, a theory is that Agile is responsible for both. While its short devlopment cycles help deal with essential complexity (you understand better the customer's problem because you have more interaction with them), it also implies incremental coding which often increases the accidental complexity. As an example: After a short development cycle, you created a database schema where each Client class has a single addre…

that sounds more like a symptom of forgetting to include refactoring in your agile loop, than an inherent issue with small iterations.

Re: Ask HN: Is Accidental Complexity Growing Faster Than Essential Complexity?

#43
post #28

I'm just getting to the point in my career where I've seen this happen a couple times. I believe it's cyclical. OO came and complicated everything and that died down. WYSIWYGs came and complicated everything, those have died down. Huge frameworks came and complicated everything, and largely died down. SPAs and Microservices came and will soon die down. I think every few years of new blood introduces a critical mass o…

OOP is definitely not dying down - outside of the startup bubble it's still the predominant way code gets written. Silicon Valley may be building everything in Scala and Haskell these days but the rest of the world is still built in Java, PHP and C#.

Re: Ask HN: Is Accidental Complexity Growing Faster Than Essential Complexity?

#44
post #38

Well, a theory is that Agile is responsible for both. While its short devlopment cycles help deal with essential complexity (you understand better the customer's problem because you have more interaction with them), it also implies incremental coding which often increases the accidental complexity. As an example: After a short development cycle, you created a database schema where each Client class has a single addre…

that sounds more like a symptom of forgetting to include refactoring in your agile loop, than an inherent issue with small iterations.

Yes, in this tiny example, it could be avoided by adding a simple refactor in your second iteration.

In general though, the customer may ask you some iteration that he doesn't realize imply a complete rewrite of the code. Like:

"now I want the same thing, but I want it available 24/7 with no downtime".

Or "Now we have a great text editor, we want to add live collaboration".

"You know what would be great: that we could see what changed between 2 versions of the spreadsheet".

Re: Ask HN: Is Accidental Complexity Growing Faster Than Essential Complexity?

#45
I have noticed several developers deliberately introduce accidental complexity for the sake of job security. Just to make it really really hard for a new person to do any thing with it , they create a hostage situation where you have to do a full gut of his or her work and redo it. This is more evident in a situation where the teams are geographically distributed and the main team (typically in USA) feels insecure that their jobs are going to India or some other country where software maintenance is cheaper. The problem of accidental complexity is very serious for large enterprise software companies who have aging products typically on a Microsoft stack so those engineers who have spent a decade coding and maintaining it tend to be happy with a crooked way(hacks and workarounds - Undocumented of course) of doing things which gives them an unfair advantage. To conclude; accidental complexity is a political tool introduced by developers deliberately of reasons best known only to them

Re: Ask HN: Is Accidental Complexity Growing Faster Than Essential Complexity?

#46
post #44

Earlier quoted context omitted.

that sounds more like a symptom of forgetting to include refactoring in your agile loop, than an inherent issue with small iterations.

Yes, in this tiny example, it could be avoided by adding a simple refactor in your second iteration. In general though, the customer may ask you some iteration that he doesn't realize imply a complete rewrite of the code. Like: "now I want the same thing, but I want it available 24/7 with no downtime". Or "Now we have a great text editor, we want to add live collaboration". "You know what would be great: that we coul…

true, and it's hard to work around unreasonable customer requirements. In the ideal circumstance you would have that conversation and explain that having 100% uptime guaranteed is basically impossible and aiming for e.g. 6-sigma uptime requires high ongoing costs - but I'm sure we've all experienced that "I can have it both ways" attitude.

Re: Ask HN: Is Accidental Complexity Growing Faster Than Essential Complexity?

#47

I honestly don't think it's any worse than it has been before. Back in my youth it was "components". If you can encapsulate functionality, then you should be able to compose it like tinker toys. So let's build these "reusable" components which act like black boxes. We'll nail up the API to the wall, and use some kind of versioning scheme to ensure that it's always backwards compatible. We can even build frameworks th…

In retrospect the 1990s components craze feels rather modest compared to what's happening now though, even if you allow for stupid ideas like CORBA IDL which hardly anyone ever used.

Right now it feels like every single tiny aspect of devops or JavaScript compilation/bundling or UI layouting alone has become more convoluted than the entire 1990s software stack.

I realize that we are doing a lot more with software now. But comparing only stuff that we used to do back then as well, like creating line of business applications, analysing some data, or create single user productivity apps, I can only shake my head in disbelief at the incredible loss of productivity.

I believe much of it is driven by a desire to architect every little app as if it had to scale to Facebook or Google size tomorrow, use Web technology for tasks that it is completely unsuitable for, and define "right tool for the job" in such a granular fashion that we end up using at least three database systems, three programming languages and scores of other distributed thingies in every single project. Just look at those "our tech stack" posts that come up frequently. It's insane every single time.

Now it's microservices. What used to be components with well defined interfaces sending SQL to an RDBMS in the 1990s has become a swarm OS processes with networking, service discovery and HA infrastructure in between. To keep it running you need some sort of cat herding devops and monitoring system. The possible failure states are beyond the capacity of human cognition.

But it makes total sense if you're a huge corporation that has an entire team working on each of those services. For Amazon it could indeed reduce coordination effort, increase accountability and make the system easier to scale. For a team of 5 or 10 people it's pure insanity to put a network between two "services" that don't absolutely have to scale independently.

We're scaling out everything instead of scaling up, even though scaling up is hugely more efficient up to a scale that 99% of all projects never grow into. In some cases (particularly in data analysis), we're paying 60% margins to cloud hosting companies for clusters that could be replaced by a single laptop using a simpler architecture.

The Web is such a great thing for all the new things it enables that we simply couldn't do at all in the early 1990s. But I really have to ROFL every time someone says "right tool for the job" and then goes on to layout a data entry form using CSS.

Here's my prediction: We're going see clusters of AIs running on top of AWS GPUs to optimize line of business apps for AWS pricing structures that no human being is able to fully grasp any more. And all of it will be set up by highly paid consultants sold by armies of salespeople.

Here we have an explanation for the productivity conundrum that has economists scratching their heads. So much more sophisticated technology and hardly any productivity growth. How come?

Re: Ask HN: Is Accidental Complexity Growing Faster Than Essential Complexity?

#48

I honestly don't think it's any worse than it has been before. Back in my youth it was "components". If you can encapsulate functionality, then you should be able to compose it like tinker toys. So let's build these "reusable" components which act like black boxes. We'll nail up the API to the wall, and use some kind of versioning scheme to ensure that it's always backwards compatible. We can even build frameworks th…

Yes, but "components" as a concept actually works. Why do you think we keep seeing attempt after attempt to bring the concept into the browser UI ?

Software development with components as building blocks maps well to our mental model of how you build things and is extremely productive. Despite the amount of grief that drag and drop GUI builders receive for being too simple, not being explicit MVC, etc., you won't find a better way to allow new developers to learn how to use a tool and be immediately productive with smaller projects. The Delphi and Visual Studio IDEs had it 100% right in this regard. That's why you see so many LOB applications from the late 90's, early 2000's still kicking around that used Delphi's VCL/Visual Studio's WinForms. They got out of the way and allowed people with in-depth business knowledge to create actual solutions. In the long run, isn't that the most important measure ?

I will agree with you on ORMs, though. There's never been more of a case of "putting a square peg in a round hole". Sometimes, the best you can do with disparate systems is to just talk the language of the system that you're interfacing with and stop trying to make it be something that it isn't. Put another way: if your "avoidance" code ends up being 50% more complicated than your "direct" code, and prevents the developer from understanding how the whole interaction occurs, then you've committed a grievous error in architecture. There are ways to make such interfacing easier without making it be completely different. For example, with SQL one of the most difficult things to deal with is result set binding/retrieval, and this was solved rather early on with classes/components that eliminated the complexity of doing so with APIs like ODBC. We should have stopped there.

Re: Ask HN: Is Accidental Complexity Growing Faster Than Essential Complexity?

#49

I honestly don't think it's any worse than it has been before. Back in my youth it was "components". If you can encapsulate functionality, then you should be able to compose it like tinker toys. So let's build these "reusable" components which act like black boxes. We'll nail up the API to the wall, and use some kind of versioning scheme to ensure that it's always backwards compatible. We can even build frameworks th…

Yes, but "components" as a concept actually works . Why do you think we keep seeing attempt after attempt to bring the concept into the browser UI ? Software development with components as building blocks maps well to our mental model of how you build things and is extremely productive. Despite the amount of grief that drag and drop GUI builders receive for being too simple, not being explicit MVC, etc., you won't fi…

I use an ORM with a popular web framework (Eloquent/Laravel) in the PHP space.

What I've always done is use the Eloquent AR approach for simple stuff where it fits well but actual complex querying is done with 'raw' PDO/SQL since frankly writing complex compound queries using the ORM is more wordy and less understandable.

Re: Ask HN: Is Accidental Complexity Growing Faster Than Essential Complexity?

#50
post #11
post #8

It's always been a problem. Premature optimization may be the root of all evil, yeah, yeah, but that quote is sort of a waste of breath as premature optimization is not that big of a problem. Over engineering is the great disease of the software profession. I suppose premature optimization is one source for it, but more common is premature generalization and excessive levels of abstraction. Other major sources includ…

I'd say overengineering and premature optimization are nearly synonyms.

I'd say premature optimization is one form of over-engineering, and not the most common form today. It was more common back when computers were a lot slower and people had to think about performance all the time, but now architectural over-engineering in all its forms is much more popular.
Post reply on HN