Ted Neward

The people who I work with whom I regard as great hackers work almost exclusively in the real time embedded space (industrial automation systems) and don't have web notoriety. Slightly more prominent individuals could include Ted Neward (http://blogs.tedneward.com), Joe Duffy (http://www.bluebytesoftware.com/blog/default.aspx), James Devlin(http://www.codingthewheel.com/archives/how-i-built-a-working-poker-bot… and Dustin Campbell (http://diditwith.net)

thats the article i was referring to. i remember a lot of consternation about that analogy followp http://blogs.tedneward.com/post/thoughts-on-vietnam-commentary/

The first time as tragedy, the second as farce... As expected the linked site [0] gets the history wrong, [EDIT:] blaming JFK for getting USA into a conflict that Eisenhower had stoked over both his terms. (McGovern and Buford were shot down in early 1954.) One of the great things about assassinating your own commander-in-chief is you get to blame all your own screw-ups on him. For a while at least... [0] http://blogs.tedneward.com/post/the-vietnam-of-computer-science/

The article this title refers to [1] is very insightful, and I don't think it was ever improved by something better (analogy-wise, or more descriptive). [1] http://blogs.tedneward.com/post/the-vietnam-of-computer-science/

> It's like recommending against the use of HTTP before people learn TCI/IP... This is a false dichotoy. SQL is not TCP/IP because it's nearly on the same level as ORMs. Unless you normalize and understand your entities properly it'll be difficult to write performant systems. ORMs are rightly called the Vietnam of Computer science¹ for this reason. [^1]: http://blogs.tedneward.com/post/the-vietnam-of-computer-science/

This breaks down when you deal with classic object oriented concepts like inheritance, encapsulation, or polymorphism. This is why object/relational mapping (ORM) has been called the Vietnam of Computer Science[0]. [0]: http://blogs.tedneward.com/post/the-vietnam-of-computer-science/

Reminds of a great anti-orm article written from 2006 by Ted Neward entitled "The Vietnam of Computer Science" http://blogs.tedneward.com/2006/06/26/The+Vietnam+Of+Computer+Science.…

I do, for one, but don't take my word for it... lots of very intelligent people have problems with ORMs. http://blogs.tedneward.com/2006/06/26/The+Vietnam+Of+Computer+Science.… presents a good summary of the problems involved (forgive the inflammatory title). Despite its many problems, SQL remains the best way of interacting with a relational database.

Somebody may have already mentioned this, but there's a fantastic essay The Vietnam of Computer Science (2004) on this subject. It's long but so, so worth it. http://blogs.tedneward.com/2006/06/26/The+Vietnam+Of+Computer+Science.…

http://blogs.tedneward.com/2006/06/26/The+Vietnam+Of+Computer+Science.… I've tried for years working on it, and I even wrote a programming language (Kira: http://www.mathgladiator.com/projects/kira/ ) to solve this problem. I can attest that the problem... well, sucks. If you want to get off the ground, then using a RDBMS isn't the way to go. The way I would recommend is to use object graph serialization then as the problems arise, use a database to index. I wrote about this here: http://blog.mathgladiator.com/2010/08/guide-to-databases-in-start-up.h…

I actually wouldn't say this is very controversial, ORM is a problem that (in some ways) is fundamentally intractable. There is some great reading on this subject with an article titled "The Vietnam of Computer Science" (http://blogs.tedneward.com/2006/06/26/The+Vietnam+Of+Computer+Science.… This was pretty eye opening for me and I think it's a must read for any web developer (or anyone using ORM for that matter).

> In my limited experience, code built around relational databases is difficult to grok. The structure is inverted with respect to typical OOP. Rather than having a sane class hierarchy, where one can start at the top and navigate down to understand how objects are nested, the structure is inverted, piecing together class relationships requires looking at the tables and following foreign keys which effectively point to parent classes. It feels backwards. Other than your first sentence (which is subjective), you are correct. The only question is whether you are going to mangle the database structure to fit your OO hierarchy or design your program in a non-OO way to fit the relational structure. Since the database will live on long past the program, and will have multiple programs talking to it, it makes sense to design your program around the data, not design the database structure around your program. [EDIT: See https://blogs.tedneward.com/post/the-vietnam-of-computer-science/ for why OO is a terrible design for persistent data]

This thread demonstrates that ORM is still (one of several of?) our field's Vietnam war... http://blogs.tedneward.com/post/the-vietnam-of-computer-science/ On top of the data/frameworks issue there's the one of data locality. Frameworks make the tradeoff decisions for you, but not always the right ones since the right tradeoffs are application-dependent. In one context using a cluster of commodity machines that do a mix of compute for your service and store and shuffle data around is a good idea. In another context a few beefy servers with the beef divided up between the app servers and database servers depending on where most of the compute most efficiently takes place is a better idea. (Though even with poor performance design, hardware is still good enough that a lot of things run just fine by having multiple services on one modest machine. That doesn't stop lots of programmers from reaching for frameworks that demand easily scaleable multi-machine systems even when there's no need and won't ever be need.) In any case consistency matters: SQL strings are just one form of shipping code to the data to compute remotely instead of retrieving the data and computing locally. When you bring in an ORM, inconsistency is bound to follow with lots of computation that could have been in a query or stored procedure now living in the ORM framework and the application itself. I can at least understand many people's annoyance with stored procedures though. Most DBs procedural…

Because you can't cleanly map objects to sets nor sets to objects. Sure, if you want to pretend an RDBMS is an object store you certainly can, but you'll be forced to have an incredibly stupid schema, and will miss out on much of the benefits of a good RDBMS. Turning a powerful SQL database engine into an object storage emulator is just sad. If your underlying data suits objects better than sets, consider using something that's designed for the job, like one of the many non-SQL database systems. Although it may seem trite to say it, Object/Relational Mapping is the Vietnam of Computer Science. It represents a quagmire which starts well, gets more complicated as time passes, and before long entraps its users in a commitment that has no clear demarcation point, no clear win conditions, and no clear exit strategy. http://blogs.tedneward.com/2006/06/26/The+Vietnam+Of+Computer+Science.… Well worth reading. Also: http://database-programmer.blogspot.com.au/2010/12/historical-perspect… http://www.codinghorror.com/blog/2006/06/object-relational-mapping-is-…

I wasn't one of the ones who upvoted or downvoted you, but just because you asked . . . while abstractions around your data-handling code are always a good idea, on some level they always leak. (For example, see the classic post http://blogs.tedneward.com/2006/06/26/The+Vietnam+Of+Computer+Science.… describing how ORM, one of the most common approaches to encapsulating data-handling code, tends to fail). Most of your code is data-handling code on some fundamental level, so it's pretty inevitable that it's going to matter to your application how that data is stored and what sorts of operations you can do on it, and that's especially true if you care about performance (which you generally always do after some level). So even if you have a nice abstraction of your query layer, the kinds of questions you can ask the database efficiently depend heavily on the underlying storage mechanism, and so your application logic has to be built so it only asks the right kinds of questions. Even abstracting away the differences between, say, Oracle and MS SQLServer and MySQL is difficult enough, because of the different capabilities and performance characteristics. When you do that, you basically end up coding to the lowest common denominator, which can often limit what your applications does. Trying to come up with an abstraction that can encapsulate the difference between a row- versus column-oriented database, or between a relational database and some other kind of storage, is…

> pinnacle of GUI design/rapid prototyping Ditto database work. The client/server paradigm is the corpus calloscotomy (split brain surgery) of our industry. Begetting ORMs, LINQ, ActiveRecord, chaotic mutant query language templating system of the week, and other well-intentioned but ultimately detrimental efforts. All being unwitting attempts to regain what was lost. Famously described by Ted Neward's "Vietnam of Computer Science" rant. http://blogs.tedneward.com/post/the-vietnam-of-computer-science/ Though Neward somehow avoids identifying the root cause (client/server). FWIW, I did a bunch of R:Base, dBase/FoxPro, Access, and FileMaker (ahem) projects, back in the day. Sadly never had an excuse to use Paradox in anger, which I understand was the pinnacle for "workgroup" apps (LAN-based, meaning shared access thru file locking).

I imagine it's a reference to https://blogs.tedneward.com/post/the-vietnam-of-computer-science/

Here's the article http://blogs.tedneward.com/post/the-vietnam-of-computer-science/ Edit: huh, seems to have got truncated over the years. Here's an archive link https://web.archive.org/web/20160120004603/https://blogs.tedneward.com…

The original paper: http://blogs.tedneward.com/post/the-vietnam-of-computer-science/ Previous HN discussions: https://news.ycombinator.com/item?id=14826496 https://news.ycombinator.com/item?id=7310077 https://news.ycombinator.com/item?id=780782

To me it is more of as Ted Neward describes "ORM is Vietnam of Computer Science"[1] "Although it may seem trite to say it, Object/Relational Mapping is the Vietnam of Computer Science. It represents a quagmire which starts well, gets more complicated as time passes, and before long entraps its users in a commitment that has no clear demarcation point, no clear win conditions, and no clear exit strategy." [1] http://blogs.tedneward.com/post/the-vietnam-of-computer-science/

Ted Neward's The Vietnam of Computer Science is an interesting read on the topic of ORMs. http://blogs.tedneward.com/post/the-vietnam-of-computer-science/

The problem space (Business) is not complex, its incredibly simple. Unfortunately the design patterns we use and the tooling is flawed. It has been this way for at least 25 years and the RDBMS, languages, design patterns, and architectures ( 2-tier/ 3-tier) are the cause. They make it simple to get started and even without knowing what you are doing you can easily churn out something that works if it is simple, doesn't change often, doesn't need to scale and deals with small amounts of data. But similar to http://blogs.tedneward.com/post/the-vietnam-of-computer-science/ "It represents a quagmire which starts well, gets more complicated as time passes, and before long entraps its users in a commitment that has no clear demarcation point, no clear win conditions, and no clear exit strategy." RDBMS are the root cause.

"We Can Do Better Than SQL" SQL is a programming language. Is just too limited and that is why many can't imagine to use it for a full project. But that limitations have no sense. The amount of code, time and efficiency that bring is huge (I know, I code in that kind of lang before) and is discussed in: http://blogs.tedneward.com/post/the-vietnam-of-computer-science/ In special look a point 5/6 of Summary. The irony is that we already have a "solution"(sql) to the whole problem, but is too limited and awkward to be used in practique.

As true now as it was 12 years ago: ORMs are the Vietnam of computer science. http://blogs.tedneward.com/post/the-vietnam-of-computer-science/ (tl;dr: there is an impedance mismatch / leaky abstraction between relational data and OOP for all but the most trivial use cases, guaranteeing that whatever problems an ORM might solve will be traded for new ORM problems instead)

FoundationDB on an embedded device? That's certainly an unorthodox approach, but I don't see the use case... On why Core Data is inconvenient: it's as inconvenient as any ORM framework in general. http://blogs.tedneward.com/post/the-vietnam-of-computer-science/

This article could be titled ORM considered harmful (2006) http://blogs.tedneward.com/post/the-vietnam-of-computer-science/

Obligatory reference/warning: http://blogs.tedneward.com/post/the-vietnam-of-computer-science/

I assume you've seen "Object-Relational Mapping is the Vietnam of Computer Science"? http://blogs.tedneward.com/post/the-vietnam-of-computer-science/

>I can't remember the talk..."ORM's are the Vietnam of programming". Had seen that article a while ago. Saw a few other mentions of it already in this thread, but here are a few I googled for and found: http://blogs.tedneward.com/post/the-vietnam-of-computer-science/ (the original, maybe) HN thread: Object-Relational Mapping is the Vietnam of Computer Science (2006) (codinghorror.com) https://news.ycombinator.com/item?id=7310077 https://blog.jooq.org/2012/05/09/martin-fowler-on-the-vietnam-of-compu…

Since you mention the OR impedance mismatch problem, I have to link to The Vietnam of CS article: http://blogs.tedneward.com/post/the-vietnam-of-computer-science/