5 ms·
In my relatively short time (~20 years) in the software industry (in the "enterprise software" corporate development world on the MS platform), it is my persona
by mistermann 15y ago
In my relatively short time (~20 years) in the software industry (in the "enterprise software" corporate development world on the MS platform), it is my personal perception that it now takes nearing 10 times the LOC &/or classes &/or complexity in general to implement the same functionality now, using modern "improved" software architecture and design patterns, than it used to writing code the "old" way we did things when I started out.
I'm deliberately very conscious of keeping an open mind and trying to discover just what it is that I don't "get" about the way things are done these days. I look at some of the incredibly complex software implementations of really very simple functionality these days, and for the life of me I just can't understand why people write things to be so complex.
Now and then I just can't restrain myself and I'll ask "why didn't you just do it this way" (often with a proof of concept implementation) and the normal response is blank stares, and a changing of the subject shortly thereafter. This is not just with individuals, this happens in groups, and no one (so it seems) feels anything is out of order. Not surprisingly, implementing new features takes far longer than things used to, at least according to my perception.
So, unless I am out of my mind, a 10x improvement could easily be realized (at least in the world of "enterprise" software), just by unadopting some of the practices adopted in the last decade or so.
- slewis 15y agoCan you provide a concrete examples?
- mistermann 15y agoOk, here's one extremely simple example.... Say you have a screen where you have to show sales for an individual customer. One way of doing this is, within the screen that requires this data, querying sales by that customer using the dynamic sql feature provided by the ORM you are already using. One line of code, and it exists in the source code exactly where it is consumed at runtime. Another way of doing this is writing a stored procedure that returns the same data and accepts customer name as an argument. Now, this SP has to be exposed through <n> application layers before the UI can ultimately call it. So now, you have a very specific (and obscure) stored procedure, that has to be exposed in <n> layers of application tiers. Now imagine you need sales for an individual customer, but now only for products from a particular manufacturer, and imagine the two ways that could be implemented. Rinse and repeat for every other distinct data retrieval use case you have. This is just one type of an implementation style that can be made excessively complex. Now throw some new design patterns that you just read about into the mix. Now, on top of your <n> app tiers, you now get several additional wrapper classes on top of all this, so a simple select from your database ends up with a call stack 12 levels deep with 6 levels of indirection. And if you suggest perhaps there's an alternate way, you're an outcast. At the very least, one would hope you could have an open-minded discussion about the relative merits of the two approaches. But this is just my experience, YMMV.
- slewis 15y agoThat's a good example and it does suck. Sounds like enterprisey java-land that we HNers love to hate on so much.
- pavel_lishin 15y agoDo the added LOC/complexity/classes make it easier to change the software later? As I understand it, all of those things aren't there to make it easier to start; they're there to make software easier to maintain.
- mistermann 15y agoThat is typically how the design is "sold", but in practice I've found that either the anticipated changes are never required, or are such that the "flexible" design doesn't work for the changes that are eventually needed. Meanwhile, you have to live with this same complexity everywhere in your system; wrapping your head around the simplest implementations is very time consuming, onboarding new developers is unnecessarily slow, making minor tweaks to production apps no one has touched for 2 years is slow and dangerous.
- loup-vaillant 15y agoI'm pretty certain that more code is more difficult to maintain, period. Before you modify anything, you have to find the relevant piece of code, understand it, and understand all the dependencies' interfaces (or even part of their implementation, if the abstractions leak). I can't recall specific experimental result, but it seems, well, obvious, that all the above will be more difficult if there is more code to examine. Now you could argue that you could shrink the size of the code that one have to examine before making a modification, by increasing total code size. I don't believe it. Increased modularity means more code re-use in the first place, and therefore a smaller program.
- johndcook 15y agoAgreed. I imagine most unnecessary code is justified by saying that it will make the code easier to maintain, even though it usually has opposite effect. It pays to be very skeptical of your ability to predict the future.
- SomeCallMeTim 15y agoI've experienced this myself in the "religion" of OOD (in which I admit I used to be a fervent believer). I once showed my brother a Ruby script I'd written with lots of clean encapsulation and a pile of reusable code -- and then he showed me how he would have hacked it together in 1/10 the code by NOT trying to design it to be "extensible." There's obviously a balance that you can strive for -- sometimes it IS best to design code to be reused. But in this case, unless my code were reused something like 20 times, I would have ended up with NET fewer lines of code by simply taking the NON OOD approach. And fewer lines of code means fewer opportunities for bugs. At this point I try to mix OOD with other paradigms, taking advantage of the strengths of each. Sometimes OOD IS the right answer still, but honestly most of the time it isn't. And OOD is verbose compared to other paradigms, especially when you're using a paradigm-agnostic language. (I suspect if you tried to code in Java this way it would fight you at every step, for instance.)
- felipemnoa 15y ago>>and then he showed me how he would have hacked it together in 1/10 the code by NOT trying to design it to be "extensible." Hacks like this do come back and bite you in the rear big time when latter on you want to extend it. Unless you are planning to trow it away or never modify it, it is a really bad idea.
- Scaevolus 15y agoPrograms have inertia roughly proportional to their size. Extending a small program is almost always easier than a large program-- except for the special case where the large program was designed with the specific extension you're making in mind.
- astrodust 15y agoYou sound like a person who's never had to debug a hairball of a Perl program that looks more line-noise than source code. You can do just as much damage by being too concise as being too verbose.
- ralph 15y agoI'd echo that view, also with twenty years of (Unix) programming behind me. The start of the slippery slope seemed to be object-orientation; yes, it can be ideal in some areas, helps re-use if done well, but since the majority of source is of average quality or worse it often seems to just add obfuscation, layers to wade through, contortions to fit the solution to the OO model the language provides, and poor names because so many need to be created that it becomes tedious. Contrast with Go's interfaces. Design patterns have also had an overall negative effect IMHO. Useful as a lingua franca for theoretical discussion they've again been over-adopted and the vocabulary has become so large, and sometimes imprecise, lessening their usefulness, that it sometimes seems like a geek version of the management-speak for which we criticise the pointy-haired. "Controlling complexity is the essence of computer programming" — Brian Kernighan. I often find the above add more complexity than they're worth.
- baddox 15y agoSee Donald Knuth's thoughts on the "menace" of reusable code: http://www.informit.com/articles/article.aspx?p=1193856 http://www.informit.com/articles/article.aspx?p=1193856.
- T-hawk 15y agoThe difference is in creep of functionality and expectations. So much stuff that wasn't even on the table 10 or 20 years ago is now expected so inherently that it's not even set out in the requirements. All those extra classes, complexity, and layers of abstraction do have purposes. We can continue talking about the Microsoft stack; my experience is there too. Yes, in older days you could knock together a report with ten lines of database code and a form in Visual Basic or even Access. But expectations change. Your fat client VB Win32 app isn't good enough in a world where everyone expects to have every piece of functionality accessible with no client installation, using a web browser. Now you're rewriting it in ASP. Now you have to deal with sessions (which VB gave you for free just by virtue of the fact that the program ran continuously in memory), concurrency, logging, IIS hosting, and loads of other complexity. The functionality gains are huge over your VB program: easy access for multiple distributed users. It's just not so visible since it's just an expectation of the platform. Five years later, now your standalone ASP pages are losing out to slicker competitors. Now every good site has on every page a banner and breadcrumb trail and sidebar menu and search box. That's not something that ASP does, unless you fake it with piles of server-side includes inserted into every page. So you move to ASP.NET with its concepts of master pages and HTTP pipeline modules and hierarchical controls. These give loads of functionality over and above older ways of doing things, even if you use only a small part of it. Multipliers of effort now exist in places and degrees that weren't previously possible. Now your business wants federated single-sign-on with a partner web site and company. This wasn't even conceivable for a desktop Win32 app twenty years ago. But now you can implement it by invoking a few WIF library calls from the correct layers of abstraction. Sure, it'll take longer and more complexity than your single login box in your VB desktop application. But it's flexible and scalable in ways previously unimagined. Or think about the back end. Twenty years ago, that was an Access or Sybase database where 5000 rows was a lot. Now modern database platforms scale past five billion rows, on any number of servers across a farm, with all sorts of automated procedures for live backups and encryption and failover and sharding and whatever else. Maybe you're thinking of SQL Server Reporting Services? Yeah, it seems like it takes a long time to implement that compared to a one-off report with some charting control. But you get whopping loads of functionality along for the ride: pagination, filtering, printer formatting, linkage to CRUD actions, ability to clone the report for editing. You don't think about the functionality because it just comes as expected with the platform. And yes, some of the complexity will leak out into your application code ("no, don't page-break between the transactions for stock sale and cash credit.") But paying the price on an apparently slower or overengineered implementation really can give you highly leveraged multipliers of effort. Recalibrate your notion of "same functionality" and you'll see why the software industry has gone where it has.
- CoolGuySteve 15y agoI know exactly what you mean. The only time I ever got an answer, I was briefly working at a large bank and it was something along the lines of reducing 'touch-points'. The theory being that the more you have to alter the code later, the more likely you are to introduce new bugs. I think it's kind of bullshitty to write 1000 lines of code with the expectation that they'll be better written now then later when you have a clearer view of the requirements, but there it is. The whole mess with design patterns and their indirection machine gun reminds me of this move: http://1.bp.blogspot.com/_zzQgqacqhjI/Sf-oiHCviUI/AAAAAAAAATg/ImX20RrwBYM/s320/Handstand+on+a+skateboard.jpg http://1.bp.blogspot.com/_zzQgqacqhjI/Sf-oiHCviUI/AAAAAAAAAT... Look, only one touchpoint! Much more reliable now.