Comment by javajosh | Hacker News Reader

Comment by javajosh | Hacker News Reader

The bigger point is that all programming is meta-programming in the sense that input traces different paths through your concrete statements based on context - which is nothing more than a fancy word for reduction over previous inputs (and it's useful to consider "program statements" to be inputs). A concrete input requires a concrete set of statements to process, selected out of the universe of possible statements. In the OOP style we have a specific way to organize those statements, which defines the "coordinate system" of our combinatorial problem.

Strongly-typed languages like Java or C# really obscure this simple truth, in my opinion. What the OP is talking about is one specific way that it can be obscured. Which is certainly true as far as it goes. But it's not going far enough!

The real problem is that OOP is totally under-constrained for end-user applications. (Although it's perfectly adequate, I think, for modeling formats and protocols).

The only really good way to do applications is as dynamic functions, because there is self-similarity between your program statements and the way you organize them, making your combinatorial problem far more straight-forward. Plus, if you do it right, your function set can fit into on-die cache, and you know enough about your inputs so that you can allocate a fixed, small memory space for any combination of statements are required for a given input (or gracefully error out when your assumptions about input are violated - ideally without even unloading your code).

I think you over-estimate the share of combinatorial problems in software.

There’re a lot of them indeed. But outside niches like compilation and text parsing, they are far from majority.

Some problems are bandwidth-bound, like photoshop: if you have 1GB image, you have to process the complete data set no matter the combinatory.

Other problems are IO bound, like databases: if user wrote a query that need to do sequential scan over a table, you’ll have do to that I/O.

For both classes of problems, OOP is just fine.

Another thing is, OOP is better at explicitly managing the state. If you design an app your way, viewing your code as reduction over previous inputs, I expect you’ll struggle implementing state management functionality like undo/redo stacks, and saving/loading your stuff in these formats and protocols.

The combinatorial problem is universal. In OOP we organize our processes using objects. Classes (collections of methods, which are collections of statements) are runtime-invariant.

In the steady-state, your process handles input as a method invocation (the main(String[]) of a CLI program or the handleRequest(req) method of a servlet, for example). In both cases, the thread associated with the input travels through your code, going deeper, then shallower, deeper again (the depth is the stack frame count).

Each time we go deeper (each time we conditionally invoke a method) we are solving a combinatorial problem across our own code-base. We are effectively crafting, at runtime, a unique program (concrete list of statements) to deal with this input. We don't normally learn OOP this way, or think of it this way, but it really is what we are doing. But there are some benefits to thinking in this way.

For example, what is an interface? Like all indirection, it's like lubricant. It decouples one set of statements from another, and makes it easier to substitute (or slide) out the second set. And a factory? Well, it produces bundles of statements that conform to an interface. But since we are strongly-typed, the factory is only selecting from a finite set. (In fact, the factory pattern is a perfect example of how OOP practitioners are doing combinatorics all the time, but we don't know it, and we do it crudely.)

> In OOP we organize our processes using objects

We organize our state using objects.

Many programs have to deal with complex mutable state. The extreme cases are OS kernel state, or game state in an AAA videogame. For such programs, OOP is the only approach allowing people to reason about what’s going on inside these things.

If you don’t have complex mutable state, other approaches might become more practical. One example is compilers; their state is mostly immutable. Another is pure computations without state, especially symbolic computations, like what happens in Maple.

> the thread associated with the input travels through your code, going deeper, then shallower, deeper again

In many programs, input handling is minor part of overall software complexity. Sometimes, most of the code don’t even run on the input thread.

> decouples one set of statements from another, and makes it easier to substitute (or slide) out the second set.

Interfaces abstract away arbitrary stuff (statements, data, hardware devices, etc.), providing strongly-typed API to use that stuff, and hiding complexity of the implementation. In some case (COM interfaces), the statements you’re selecting were written in another language, are implemented in another DLL being loaded on demand, run in different process that starts up on demand, or for DCOM even run on different machine.

> since we are strongly-typed, the factory is only selecting from a finite set

In C#, some class factories take your strongly-typed interface, take other parameters you pass to the factory, and implement the interface in runtime. Because there is infinite set of possible class-factory parameters, that makes the set of statements infinite as well. BTW, this approach is often used in .NET RPC libraries, like WCF.

If you opened your mind only a little further you would see what I am saying, friend. All call chains are input driven. Attach a debugger to anything you've made and stop the program - at the top, is an input. The tick() methods in a AAA game are handling input - the input of a ticking clock. A long-running process, by definition, does not change state without input. "Process organization" means how the memory associated with the (operating system) process is divided - and that memory includes both (mutable, transient) object state and (immutable, invariant) program code. Your comments about code generation are pedantic, and I will ignore them, since only a very small fraction of code written in Java, C#, or any other high-level OOL does dynamic code generation, or even reflection (and for the very good reason that it breaks the invariants assured by the OOP paradigm).

Unfortunately, OOP doesn't allow people to reason about complex systems, primarily because call-chains are totally unconstrained. An object can contain references to any other object held by the process, and this reference list is dynamic at runtime. In the presence of instantiation indirection it's even worse, even the concrete type of those references is unknown except at runtime.

There are code smells, and then there are architecture smells. One big architecture smell is when the incidental complexity of a solution vastly outstrips the intrinsic complexity of the problem. I have never (and I've been doing this a very long time) seen an OOP code base less than 10x the complexity of the business problem it was built to solve. It's sad to me that instead of asking why, they keep blaming the programmer/architect and inventing new complexity to mitigate old complexity.

> only a very small fraction of code written in Java, C#, or any other high-level OOL does dynamic code generation, or even reflection

The overall fraction might be small, however vast majority of software still contain substantial amount of code that does. Most serialization and DB access libraries do. For C#, this includes all framework-provided serializers (XML, data contract, etc.), the ubiquitous Json.NET, and my own one: https://github.com/Const-me/EsentSerialize

> OOP doesn't allow people to reason about complex systems

Respectfully disagree, ‘coz I have never saw complex systems that aren’t OOP. Even most compilers are OOP, take a look: https://github.com/llvm-mirror/llvm https://github.com/gcc-mirror/gcc/tree/master/gcc https://github.com/dotnet/roslyn

> An object can contain references to any other object held by the process

This is true for very small class of objects, like GUI controls with loosely typed event handlers, or objects that hold lambdas/functions that may capture anything at all (but the latter is not strictly OOP).

An object can only reference other objects of types that can be stored in its properties/fields. For many objects especially simple lower-level ones, this means objects can reference no other objects at all.

> have never seen an OOP code base less than 10x the complexity of the business problem it was built to solve

My guess is, you’re systematically underestimating complexity of the business problems solved by the code you look at.

Most of my career has been spent building stateless web applications over relational databases in Java. About half enterprise, and half consumer facing internet. Sometimes using Hibernate, sometimes using JDBI, sometimes leaning heavily on SPs. Sometimes generating HTML, and sometimes exposing REST-like API. The various runtime accoutrements of this architecture, like caches, queues, health-checks, proxies, linux, etc are quite familiar to me. My time as a freelancer gave me particularly broad appreciation of real world solutions.

In every case, codebase complexity was dominated by administrative overhead. My passing experience with apps written in C#, ASP, and PHP, tell me that it is the same story there, too.

This is my subjective view. One way you might understand my perspective (and perhaps even share it, to some degree) is to consider the act of adding a column to a database table, and how a typical OOP/RDB webapp codebase must change to incorporate a new DB value. (And this is only the tip of the iceberg, since usually adding a feature requires a view, an index or two, plus column and table changes.)

I’m a full-time developer since 2000. Over those 17 years, I only briefly did web development, Java or relational databases. Mostly I’ve been doing system programming, game development, embedded development, robotics. When I did networking, it was usually lower level than REST. I have minimal experience with proxies and linux, I’m mostly a Windows developer. Lately I’m working on Windows desktop software, the area is CAD/CAM.

As you see, almost nothing common with your background.

For the kind of software I work on, if the code is 10x more complex than necessary, the software might fail the performance targets. Complex code is also prohibitively harder to maintain and debug. And esp.in embedded, quality requirements are just higher: web requests come and go, but embedded software needs to reliably work for days without restarts.

I think the reason why I’m generally OK with other people’s OOP-style code I see in the projects I work on, is that code is just better then what’s in an average web.app. Especially if the web app ain’t Google or Facebook, AFAIK for these guys, software quality translates to substantial saving on electric bills.

Do you have any examples of an application which is written this way (as dynamic functions?)

Most compilers :)

Reply on news.ycombinator.com