July 29, 2014

Pages


Search Site


Topics


Links


Archives

How OO Almost Destroyed My Business

May 20 2009 by Marc Funaro

Yeah, it's long... but some people really need to hear this.  Besides, compared to all the tons of (mis)information about ColdFusion and OO on the web, this is a relatively small bit of blog-based sanity.

"There comes a time in the history of every project when it becomes necessary to shoot the engineers and begin production."

I don't recall where it came from, but this faded, worn 3x5 index card, printed in Bold Times Roman, has been hanging in various places in my office literally for years.  I've had it since at least 1997, when I ventured full-time into my sole proprietorship.  It followed me from my apartment north of town, to my new home south of town.  I always understood what it was trying to say, yet only now, in May of 2009, would I discover just how important those 21 words would become to me.  But let's get a little back-story in here...

I graduated with a degree in music in 1992.  I ended up in the world of technology (even back then, the recording studios had some cool computer-based stuff going on!)  I was hired around 1996 to be the IT person for a small company with national and international interests and assets.  In addition to getting the office network/workstations up and running, I was given the opportunity to develop a regular website (plain old HTML, which I had done for a few businesses before), and a database-driven web application to manage contact information for the company.

Being new to programming (having only written some BASIC programs in the past), I stumbled around trying to figure out how to connect a website to a database.  First I tried plain old CGI stuff.  Someone pointed me to Microsoft's Active Server Pages (it's free!  Use Microsoft Access!!  YAAY!).  But at the time, I just couldn't get my head around how the languages worked.  (Turns out later, this should have been a giant hint...)

Then, someone introduced me to ColdFusion.  At the time, if memory serves, ColdFusion 3 had just come out.  (Not a CFC in sight!)  Ben Forta was evangelizing up a storm.  Allaire would soon go IPO.  The CF forums were on fire.  Even though the product would cost money if I chose to use it, I was intrigued.

I went from "intrigued" to "SOLD" when, in a matter of 15 minutes, I had written a web page that pulled a record from a database, written some HTML for me, and spit it into my browser window.  I'll never forget the feeling of empowerment as I went from that first experience to lying in bed pawing through the ColdFusion Reference Manual, looking at all the tags and functions.  It was as if, one by one, they stood up in front of me and said, "And here's how *I* will do something really cool..."  Each one was a little gift all its own.

I was hooked, and became a code-writing madman.  Twelve hour days flew by.  I was putting out web pages full of useful information, for people across the globe to see.  I was doing it quickly, and my employer was praising the work.  Yes, as a new developer I made all the usual mistakes... pound signs where they weren't really needed, misuse of functions, poor organization.  But I was learning, and at the same time I was productive and useful to the company.  Within a couple years, I'd published my first article in the fledgling ColdFusion Developer's Journal.  It all felt absolutely wonderful, and I was making a living.

Fast-forward to the 21st century.  Specifically, the past few years of my life.

Message board threads related Object Oriented programming in ColdFusion seem to rule the web-waves.  There are OO gurus; there are OO training classes.  There are even courses for MANAGERS in the benefits of OO -- for people that may not even be programmers.  There are blog posts aplenty about how Object Oriented Programming can "save your project", make your team more efficient. 

And me?  These days I'm still busy as hell.  Too busy, and too far behind.  But I'm getting caught up, now that I've stopped hemorrhaging time and collecting frustration... now that I've blocked my near abandonment of the career and company I used to love. Yep, for all the work and associated revenue I've ALWAYS had, I nearly walked away.

I don't recall when I first got introduced to OO, but the first real step in the path towards near-destruction was an innocently-titled course I took, called "Java for ColdFusion Developers." It was being held in the Washington DC area, taught by someone that I trusted and could call my friend... a relatively well-known expert in the field that actually has a similar background as I do. He was assisted by his brilliant buddy -- a brainiac computer science and OO/Java expert. 

I took the course because, well... because of all the promises.  Not by the class instructors, but by the OO world in general.  Promises that OO would make me a better programmer.  I'd write better programs, faster.  Modifications to my programs would break less code elsewhere.  Insert-your-favorite-OO-buzzword-here would make my life so much better.  And, I took the course because I was starting to feel like I was "falling behind" in the field... even though my bills were more than paid, business was booming, and clients were happy.  The grass looked greener.  And while the instructors did their best to keep the buzzwords at bay (and did so nicely), they were still there, in every magazine, on every web page.

As it turned out, for me, that greener OO grass on the other side wasn't even grass at all... it was Astroturf.  It was a kind of fake, a fraud.  Of course it was greener... it was sold that way.  But it would not provide the pastoral comfort of the real thing.

I took the Java course, and while most of the OO marketing made sense, I finished the course quite frustrated.  Not because the course was not taught well... not by any stretch.  No, it was because "OO is a hard concept to understand... you have to think completely differently about things."  (That's what you get told... it's a "paradigm shift.")

Okay... so I'll shift.  It can't be that hard, can it?  I don't have to know it ALL about OO ('cause you never can... you're told that too), I just need to know enough to make MY projects better...

So I persisted.  The framework I'd used and loved for so long, Fusebox 3, by version 5.5 has become completely OO-based.  That HAD to be better (right?  RIGHT??!).  It was pure OO - or at least, as pure OO as ColdFusion can get.  It was just a given -- if you really wanted to do OO, your framework should be too.  (Oh, you're not USING a framework?  Heavens, what's WRONG with you?!)

Then things really got ramped up.  Fusebox or Mach ii or Model/Glue?  Reactor?  Coldspring?  Oh geez... what's a Service Layer?  Oh my, so much to learn. But,  I GOTTA learn it, though.  Seemed like everyone was saying how if you really want to be valuable, make sure you "keep your skills up to date" -- and those skills had better be in OO because "that's where everything is headed".

So I piled all of that into my applications, little by little.  My "skeleton" application structure -- my starting point for every new app, now had over 5000 lines of code, before a single line of code was ever written by ME.  But that's what's going make things better, right?  A whole bunch of code that does things for me?  And it's all OO-based, so then I'll be more likely to "do" OO "properly" myself, right?  And there's always more training classes...

 

But training in OO is a self-fulfilling, self serving thing, at least for someone like me... a musician who learned how to write ColdFusion code; someone who to this day is still giddy about the fact that I can write something in a file, upload it to a server 70 miles away, and then someone half a world away can read it... instantly.  For someone like me, OO slowly started eating away at my "coding soul"... if I couldn't get something to work right using OO, then I "wasn't really doing OO"... so, back to the drawing board.  More training.  More books.

Over the course of 4-5 years, OO has cost me over $6000 in training and books, and a priceless amount of (priceless) time.  OO took away useful tools in the ColdFusion world (I even had to turn off "Report Execution Times" in CF administrator, because my OO framework would slow to a crawl for some reason), in favor of harder to use tools that took more time to use.. If there even was an equivalent.  It made my applications run slower.  It made my interactions with clients more difficult, for them AND for me, because instead of looking at the problem domain for what it really was, it all become secondary to making sure I was "thinking OO" as we tried to hash it all out. 

All of this was my own fault, I'm sure... because if things weren't working out right, then I probably wasn't doing "real OO".  I was still not good enough, and I was convinced that my projects would suffer -- every one of them.

But OO did something worse than all of that... it eroded my confidence to the point of "work paralysis".  Seems like everything had to be thought through, ad nauseum, to prevent "code rot" or writing myself into a corner, sickening amounts of refactoring.  Lacking an OO solution that "felt right" for a specific challenge would mean hours of research, and the pestering of other gurus... because whatever I finally got right, I could most definitely reuse "next time".  It was an "investment"... but each investment in extra time and research for the OO solution made me further behind.

The worst part of all, in 20-20 hindsight:  Even if I knew how I would have solved a challenge outside of the OO lexicon, if it wasn't an OO solution, it wasn't going into the code.  I wanted to know OO that badly.  It felt like a real commitment, when all it was turned out to be Astroturf.  How lame is that!?

Even though our application and database platforms had progressed -- ColdFusion 8 with MSSQL 2005 is a combination that can most CERTAINLY deliver a robust and feature-rich web app -- my own productivity in 2008 was the lowest it has ever been.  Oh, clients were still paying... but now they were wondering why even smaller projects seemed to take so much longer.

But... Worst of all, OO took away the very joy of programming it promised to bring.  This lack of happiness nearly destroyed my little business. 

Yep, it was my own confidence and happiness.  Not the economy (I haven't needed to advertise for work since I started), not my own lack of knowledge or diligence or effort.  The lower productivity and the allure of that succubus called OO caused an undeniable lack of productivity, and an exponentially increasing level of daily frustration.  I was truly, truly unhappy.

I decided to give this all one last shot.  My friend, the one from the first training class, was offering a new one... nothing to do with Java.  It was "Object Oriented Programming for ColdFusion Developers".  This was it.  I called my friend, and I told him, "This Is It.  If I don't get this under my belt, I think I need to find another line of work, because this is slowly killing me."

For almost two months, I remained nearly paralyzed, waiting to go to this class.  I was afraid to start EITHER of the two major projects I had lined up, because I was so afraid of the re-writing I might have to do after whatever OO epiphany awaited me.  I stalled; I worked on smaller items I could deliver quickly.

Through fate, I had this friend all to myself for the week.  (This was great for me, probably not so great for him.)  We laughed, I learned.  We talked about something OTHER than programming... often.  That alone was therapeutic.  I was introduced to a new way of working... a way that was empowering, a way that gave back some joy for all the effort that goes into building a web application.

But it took another few weeks before the actual epiphany.  And when it came, it hit hard.  My epiphany about OO had finally come, but it wasn't about OO at all.  It wasn't about how I wasn't looking at objects properly, or modeling my domain properly, or about how i wasn't using a design pattern properly or extending my classes or using abstract classes or using interfaces or CRC cards or service layers or mixins or facades or my ORM properly.

My epiphany was really about ColdFusion.  My epiphany is about the fact that ColdFusion was something I USED TO loving working with, and that it has been nearly ruined by the OO world, seemingly just because it happens to run "on top of Java."  My epiphany was that I had listened to too many gurus, bought too many books, tried too hard to learn something new, in entirely the wrong context.

ColdFusion applications don't need "objects" and "OO" any more than Coke needs another f#$&*ing flavor.  Coke is perfect the way it is.  If you are craving an ice cold Coke, when you grab one, it TOTALLY satisfies.  It is associated with fun times.  It is perfect, Just The Way It Is.  OO can too easily become that unnecessary new flavor of CF programming, and unless the circumstance really calls for it, it just isn't needed.

This hard-learned lesson made me really think about all the other people out there -- the ones that are just starting with ColdFusion, or are still just thinking about it.

I would wish upon them my experience from 1997.

And, I would do whatever I could to shield them from the OO marketing and buzzword BULLSH*T of the present.  I'd block every website, every blog, about OO programming with ColdFusion.  I would have them embrace what ColdFusion really is -- a tag-based language with some excellent features, all of which make you productive as hell.  AS IS. 

Here's another statement that's sure to draw some fire:

The worst thing that could ever happen to a ColdFusion developer is to take a Java class.

How could I say such a thing?  Easy.  Because ColdFusion ISN'T Java.  I don't care how many new object-based features they pack into this language, EFFYOU it ain't Java.  Taking a Java class will show you the absolutely wonderful features and benefits of a strongly-typed language.  It will lead you down the path of Objects, and all the zillions of books and courses on the subject.   You'll love Java.  But then, you'll go back home and need to write things in ColdFusion -- either because, like me, you have to make a living, or because (like me!) you still love all the things that ColdFusion has to offer.  And CF will be ruined for you in at least some small way -- you'll feel like somehow, the language is suddenly inadequate.  Trust me, that's just the smell of the Astroturf... it's not real, fresh cut grass!

Take a course in Java, and you'll start trying to work like a Java programmer can, but in ColdFusion.  But you NEVER REALLY WILL.  The language doesn't truly support it.

Read all the books on how to think in Objects, and you'll try to make that all work flawlessly in ColdFusion.  But you NEVER REALLY WILL.  The language doesn't truly support it.

And even if the language DOES support it... you'll start to miss how fast you COULD deliver code, like ColdFusion was meant to do.  You'll miss having control over your entire app, as soon as you jump on the buzzword bandwagon and start using a framework, an ORM, a dependency injection framework.  It's all someone else's code.  It all can slow down you or your app, or both.  You Ain't Gonna Need It.

OO in ColdFusion is half baked, and I think it's that way for a very good reason... it's there to enhance ColdFusion, not CHANGE it into Java.  Not to write 100% OO based applications.  So Don't Try To Do It.  I would imagine the smartest developers at Adobe would tell you this very thing.

Here come the flames...

"So what, Marc, are you condoning going back to the old days of spaghetti code, with no separation of concerns?"

Absolutely not. 

Absolutely not.  Absolutely not.  Absolutely not. 

No.

What I am condoning is some f'ing sanity in the ColdFusion community.  Some responsibility on the part of the OO enthusiasts and gurus to leave things alone until OO is really needed.  Stop pushing the classes, the books, the websites, the design patterns.  Stop being smug -- "Oh that didn't work?  Then you're not doing real OO."  Screw you buddy... I don't have time or money to take another class in unobtainable purity.

What I am condoning is that we teach new and established CF'ers some basic coding techniques -- MVC (yeah, I still dare to use a buzzword or acronym or two!) and that it's okay and even NECESSARY to go back and refactor your code OFTEN.  Small examples of the most useful aspects from the OO world, and nothing more.  And that refactoring is actually EASIER when you don't have your own code buried in a steamy pile of someone else's ideas about what a web app "should be" to be "right".

What I am condoning is that we teach new and established CF'ers that writing a web PAGE is just DANDY.  A page... you know, A PAGE?  like, when the web world began?  Remember?  Like, uh, product_list.cfm.  Or product_detail.cfm.  Or contact_form.cfm.  Pages, that come from a file, the contents of which gets received and interpreted by a browser.  Yeah... not /index.cfm/event/main.home or whatever strange stuff inevitably comes out of OO and framework overkill.  A page, that you can go and open, debug, etc. using all the tools already available in the CF world.  A page you can just open and modify and not worry about what objects are involved, who's inheriting from what, and what layers the data is going through to get to you... or what damned OO rules you're going to break if you have to change something quickly should the feces strike the ventilating unit.  Oh and how this will tweak someone:  If your page doesn't do CF at all, then name it .htm.  "WHAT?!?  No Way!" you say?  Way. A page is a page. It's worked for two decades.  Don't let the engineers ruin it.

Real OO should come out of NECESSITY in ColdFusion; it should not be the starting point, like it is in a true object based language.  The starting point in a CF app should be the page.  What do you need your page to do today?  And, what does ColdFusion ALREADY OFFER that can make that happen, without thinking about "oh, well that thing on the page -- that is clearly an OBJECT."  No, IT ISN'T.  Not necessarily.  Sometimes a kiss is just a kiss.  Sometimes a bit of data is just a bit of DATA.  Just do the damned table join using SQL - it'll fly compared to OO.  Quit taking other people's advice and think for yourself... does it make sense to return one or a hundred objects to a Web Page, when a simple CF recordset will do?  REALLY?  More often than not, the recordset will do just fine, thank you.  Your server will thank you, too.

The bottom line is, when you NEED to use some OO concept, YOU'LL KNOW.  *That's* the time to start writing OO-style code, and only then... not everywhere else.  And the moment you start downloading one framework after another, piling them all into an application, because someone said "use this, your projects will go faster"... That Should Just Feel Wrong.

What's ColdFusion good at?  Recordsets.  Querying a database, and handing you effing data, formatted as HTML or JSON if you like.  CF is good at taking a web GET or POST and turning into an insert or an update in your database.  Sending email containing data.  It's really good at that stuff, and a LOT more.  I should know... I've been using it since version 3.  And now at version 8, it's good at so many OTHER cool things too.  More than any other application server in its class. None of which requires getters, setters, a front controller, inheritance blah blah blah zzzzzzzzzzzzz.

Saving and retrieving data.  Creating dynamic PDFs.  Image manipulation.  Messaging.  File-based data management.  Even some cool report building.  What do most apps call for?  THAT STUFF.  You know, that stuff you can do with a .cfm page and some CF tags... maybe some CustomTags if you like. Perhaps some centralized controllers for your pages to talk to, so you still have some good organization.

Don't turn a row in a database into an object "just because".  If all you need is a recordset, then by all means, use a damned recordset.  If all you need to do is validate a form post and store it, don't send it through three layers of crap and a zillion objects to do it.  It's pointless.

"But Marc, I bet your apps are hard to maintain."

Nonsense, pure and simple.  In fact, it's easier to maintain an app when you don't have to go through 10 templates to figure out what the app is doing to your form data.  And a business client can tell me what PAGE they are on when they have a problem.  A page name -- go figure!  I'd be willing to bet the majority of apps that the CFers out there are writing, or at least the mini-apps inside the larger ones, really are THAT SIMPLE.  QUIT GUMMING THEM UP WITH OO, slowing down yourself and your servers.  Unlike Java or C, CF is terrible at creating an Object - it has to work pretty hard to be that type of God.  It's Slow.  So don't do it, unless and until you really really need to.

MVC and "diligence in refactoring" when things start to feel wrong or unclean.  Well thought-out specs, in advance of the first line of code.  Decent standards compliance in your views.  That's what OO gurus might consider teaching CF developers.  Objects don't own the market on these concepts.  Save your Singletons, your Dependency Injection Frameworks, your Frameworks, your Design Patterns, all of that, for when a developer presents a specific problem and wants a clean way to solve it.  If the problem calls for any of those things -- truly calls for it -- THEN you may bring it up.  But not a moment earlier.  Teach through specific context, not by buzzword and framework-download mania.  Write a blog post for each example if you have to... it's better than tome after tome about the OO world.  And quit being smug about your knowledge of OO - it's not helping anyone and nobody cares if your app is pure OO.  Sorry.

"But Marc... you're an idiot for having let things go so far that it was going to ruin your career!  You took it all too far!"

I couldn't agree more.

But remember, it didn't happen overnight... it snowballed, just as the OO world crept into the CF world, a little at first, and then suddenly took over with all the vigor of a 15 year old boy getting his first dry hump.

And consider this... if it happened to me -- someone with a fair amount of intelligence and common sense (yeah, I guess I do have some confidence back) -- it could easily happen to others.  Especially young CFers that have fallen (wonderfully!) for the Adobe marketing of ColdFusion, or those folks that just don't come from a Computer Science background.  Their new programming minds are so impressionable.  Don't screw them up with the OO drug.

Perhaps, as my friend has alluded to, it was my personality type.  Not uncommon, really.  As a musician, we strive for excellence.  The only way to truly achieve it is through complete immersion in your instrument.  Wire and wood is all my guitars are... to be a true instrument it requires ME.  So I went to school for music.  Learned history, theory, performance.  Practiced 8-12 hours per day.  Completely immersed myself in the instrument.  The practice was always more valuable than the theory, by far.

My approach to programming was the same.  I wanted to immerse myself in it.  But instead of immersing myself in my chosen language, without noticing, I had become immersed in the theory.  I stopped "picking up the instrument" in favor of reading about all the ways it could be played.  And then when I finally did pick it up, it no longer brought me happiness, because all the theory was telling me that what I was writing wasn't going to be good enough. 

That was the Kool-Aid I sucked down, little by little.  It was a slow poisoning, that up to the last moment felt simply like blissful intoxication.  Don't fall for it!

My career didn't "Almost Die" because I had no clients, and no ability.  It almost died because I was somehow reaching the conclusion that I wasn't going to be good enough to sustain my success.  I was worried about becoming marginalized by the OO programmers.  So "OO programming" was the catalyst for that wholly incorrect conclusion. 

If you've read this far, maybe you know the feeling... "Eventually the OO programmers (from India?) are going to be able to deliver projects like the ones I do now, in half the time, and maintain them at a fraction of the cost, and I'll have to go back to selling cell phones.. perhaps out of a kiosk at the Carousel Mall... because eventually, nobody's going to hire a non-OO programmer.  I'm not doing things the right way, and unless I get this OO thing nailed down, I'm going to eventually fail."

Extreme?  Maybe a little.  But that was the logic.  As a single hired-gun, my success almost seemed too good to be true, and OO was going to give me some security.  I would start doing things "the right way", as told by all those brilliant minds.  And if I didn't, I would eventually lose out.

What a pantload.

I now say Wake Up, CF'ers.  When you've delivered a working project that's 99% (or more!) your own code, does what it's supposed to do, and for which you've just received a fat check... believe me, you've done it the right way. And with ColdFusion you CERTAINLY don't need OO to do it.

The fact that I couldn't quite grasp ASP as a newbie should have been a clue -- they talked about objects, even back then. 

When I left the Java class frustrated, and later realized that I loved CF too much to abandon it for Java/JSP... that should have been a clue. 

When it got to the point where I was starting out projects with a METRIC TON of code already written for me, that should have been a clue. 

When I was spending more time trying to figure out design patterns than what the latest features of CF8 were, that should have been a clue. 

When I started hating my job... when I couldn't deliver some of the more simple things... when I was feeling really depressed and actually considering leaving an otherwise thriving business... all clues I missed.  When my friend, who was initially a huge OO proponent, disappeared from the community... that was a much more subtle but way more important clue.

I have my friend to thank.  The last "training" was still about OO, but it brought about a sea change in common sense.  Especially for small non-Computer-Science programmers:

-- Use OO when necessary, and not a moment before. 

-- Don't use OO at all if you don't have to.  (I recently told him I had just architected a fairly involved but completely well organized project, without ANY objects... and I was almost afraid to tell him how GOOD it felt... his response?  "Imagine that."  After which he proceeded to demonstrate how he'd recently done the same damned thing.  HAPPILY.)

-- Don't buy tons of books and training courses covering every aspect of OO, hoping it'll make you a more valuable CF programmer - people couldn't care less, clients especially.  Don't kill your productivity that way.  Instead, put your energy into learning what CF can do... bury yourself in the manuals for the product itself -- seems there's always some new little discovery waiting there for you.

Exhaused that info?  Really feel the need to expand your mind?  Great!  Move on to the real meat -- nothing's worth anything if it doesn't LOOK right.  Take a design class; concentrate on your look and feel, your usability.  Take on the challenge of a fully validating XHTML page, and make that page come from your app.  Maybe every page.  Take on the Section 508 accessibility standards.  Your diligence in those areas will TRULY pay off, and it will keep you busy, if that's what you feel you need.   Get obsessive about stuff that REALLY matters.  Exhaustive OO in CF will merely punish you, and your server.

-- What REALLY matters is building a sensibly organized application that works, under a reasonable budget and timeline, and committing to refactoring when things feel even the slighest bit messy.

-- Understand that when you start using someone else's code on a large scale (i.e. a framework upon which you build EVERYTHING), especially FREE code (another rant for another day), you are accepting THEIR shortcomings into YOUR project.  And when something breaks and you can't figure out where to fix it, they have NO real incentive to give a response to even your most urgent requests.  How much time have you REALLY saved?  Really?  Not as much as you think.

-- Set your own standards for how you wish to build your web apps.  Refine them with each new app.  Borrow from others only what you fully understand and can incorporate into your own standards.  Document those standards.  They'll come in handy if and when you DO have to integrate the app into a team environment, or if you have to turn your code over to another developer.  Strive for consistency in your app, and document it.  You don't need OO to do any of this.  The difference between an amateur and a professional is consistency and documentation... and OO Programming doesn't have the market on either one of those concepts, nor can it deliver on any promise it might make that you'll achieve them any better than without OO.

ColdFusion gives you the ability to do all that you need to do to deliver a high quality web app, "out of the box", with ZERO OO required. 

Given this new line of thought, I now feel totally confident knowing that if I had to go back to writing in CF 3 tomorrow, where objects where unheard of and Jeremy Allaire and friends were simply jammin' on adding more useful tags and functions to the language, it wouldn't change a damned THING (though I'm sure I'd miss CFIMAGE and a few others :).  I'd be just as happy... and so would my clients.  And my bank account would still remain in the black.

I'm not saying OO is evil and should never be studied, even by CF'ers.  There's some good stuff in there.  I just think OO is for WAY FEWER ColdFusion programmers than anyone doing CF OO wants to admit, and only then a small subset of the OO lexicon ever really applies.

If you're really groovin on OO and jonesin' for true, pure OO programming and it's related tools, and you already kinda grok it, then put down the CF manual and slowly back away from the server... you want Java.  It's the next door down on your left.  Help yourself to an Oreo on the way out.

But if you really love CF, and your CF server, then PROVE it.  Fire up your editor, create a brand new EMPTY directory, and write a ColdFusion WEB PAGE.  I dare you.  Go on... the world will keep spinning, I promise... and you might find that you CAN get back that feeling of power that made you fall in love with CF in the first place -- how quickly you can write something truly useful, and FEEL PROUD of what you've just done.  Oh, and you'll probably be happy and productive and make money and spend time with your family and have a hobby.  :)

Shoot the engineers, and begin production.

Posted in ColdFusion | OO |

155 responses to “How OO Almost Destroyed My Business”

  1. Chris Peters Says:

    Thanks for sharing, Marc! If this does start a flame war like you mentioned on ColdFusion Community, at least you can know that *someone* is on your side. You exposed a nerve with me, so here is my response:

    http://www.cfwheels.org/blog/index.cfm/2009/5/24/How-OO-Almost-Destroyed-a-Business

    .
  2. Marc Funaro Says:

    Thanks Chris. I observed some lashback in the PHP community, too. Though with the way I am designing apps now I don't think I'll ever need another actual batch of someone else's code called a "framework", I'll check out CF on Wheels just to see what it's all about!

    Thanks for taking the time to read my mini-novel.
  3. Mike Hazard Says:

    Wonderful post. I've been feeling just this way for the past year. I continue to use CF because I can get things done...and yet I hear more and more people insisting that getting things done is not nearly as important as spending months and sometimes years modeling the application first.

    Like you, I'm not ashamed to say that there is absolutely nothing wrong with writing a page and that for many of us, OO is simply not needed.

    Thanks again for putting into words what I've been thinking for some time. I'm glad I found your blog!
  4. Yves Says:

    Hi Marc!

    I could relate with some of of your post. I certainly agree with some things you've mentioned. Use OO if you need to use it...

    Last couple of years, I've used one of the more popular frameworks for an evolving project and while my experience hasn't been all bad I noticed a few things that kind of tie into some of your post.

    First off, I've found that learning to work with a few of the frameworks has helped me thing about how I organize my code better.

    But, on the other hand I've definitely shied away from using any of the frameworks on a number of projects...

    Some priorities in development are some of the following:
    1) organized code
    2) organized or smooth "flow" in my code's execution
    3) code's performance

    I found that the extra processing the framework added wasn't really worth the hit on certain projects.... depending on the server/vps would be hosting the app.

    Lately I've been using my own small "framework" which focuses on minimal code processing... it's stripped down, lightweight and uses naming conventions (kinda like ColdBox).

    Basically, in my opinion, for many of the projects I work on... returning datasets, handling/presenting the data and considering any caching needs is more reasonably done without passing it through extra steps. That's not to say I'm anti-framework. Because I am not. I just don't see it as necessary for most projects I work on.

    When the question of productivity or how easily modifications can be made upon an application which has a framework.. I think if a business (team of developpers or developper) is using a framework it may be easier to modify... but, the real determining factor may be in how well the app's documentation is written.

    For instance, if my lightweight stripped down "framework" or "methodology" has decent docs, any experienced CFer would have little difficulty in understanding it's structure and flow.... which was another goal.

    I really enjoyed reading this post.

    BTW... I really don't have enough coffee in my system at the writing of this comment...
    ;-)

    But that's a subject for another day!!!
  5. E. Martin Says:

    You just have to read this interview with Bjarne Stroustrup, who created C++, the object oriented variant of the C programming language:

    http://artlung.com/smorgasborg/Invention_of_Cplusplus.shtml
  6. Marc Funaro Says:

    @Mike:

    I agree -- the focus on initial requirements, documentation, et al can lead to "paralysis" - nobody wants to START because "oh my, we might have to refactor/redo something later". But that's exactly how the world works. Managing that fact IMNSHO is primarily a matter of starting with the human element - the UI - and getting all the changes incorporated there first. It's easy, there. Nobody wrote a spec document for the first web page. Make the UI the focus, and everything else will fall into place, with due diligence.

    @Yves:
    I agree that investigating a framework (a good, mature one) can lead to some understanding of how to organize one's code -- or at least, the benefits of doing so. Let's not beat around the bush here -- we're talking first and foremost about MVC. Heck, my coding practices became MUCH better when I learned fusebox 2 and then 3.

    But I now feel that MVC can (and should!) be taught without the HINT of a framework available. ColdFusion provides a solid PLATFORM for writing an MVC-styled application, and that should be the starting point.

    Though I should probably think this through some more, I think my "Priorities in Development" list might differ from yours a little bit:

    -- A permeating focus on the one true picture of the application: the UI. Without the UI, the app is nothing, and this must remain in our field of view as we write the code.

    -- Use the simplest solution possible to solve a given challenge

    -- Code that makes the best of it's language's capabilities

    -- MVC architecture (No, this does not immediately mean the use of objects)

    -- The documentation, use, and flexible evolution of the project's "coding standards" (which always mirror but are sometimes ahead of my own overall 'coding standards' that are updated after every project)

    -- Writing only the code needed to complete the tasks at hand -- additional hooks, placeholders, etc DO NOT save time, money, lives, etc.

    -- Creating an environment where I or anyone else can feel completely comfortable CEASING codework to refactor, as soon as something begins to feel wrong. Near-Obsessive refactoring is what keeps an app lean, mean, and easy to understand -- and hence, easy to modify.

    From these priorities, one will NATURALLY achieve organized code, easy-to-trace program flow, and good performance. Notice that "code reuse", "code extensibility", and "design patterns" are not on my list.

    I found your statement:

    "I found that the extra processing the framework added wasn't really worth the hit on certain projects..."

    to be DEAD ON. Especially with regards to "pure-OO cf frameworks" which are trying to make CF something it is not, all for some perceived benefits that have no real-world evidence.

    And I think when you said:

    "I think if a business (team of developpers or developper) is using a framework it may be easier to modify..."

    The key word is MAY -- MAY BE EASIER TO MODIFY. The fact that there's no real-world proof that modification is any easier in the OO-paradigm means that way too many people are simply buying the OO rhetoric without doing their homework. And I think you touched on the real point when you mentioned documentation -- a well documented traditional/procedural app is just as easy to work with as it's OO equivalent. (Someone prove me wrong!)

    Again, I'm not 100% anti-OO or anti-frameworks, etc... I just have turned the corner a bit, and I'm more skeptical of the vivid, ceaseless claims by OO proponents. I want to see real world evidence that's it's better than simply applying the non-oo principal of MVC and writing code based on a solid UI, with emphasis on doing what the language does best.

    Whew... I'm still ranting about this... musta been building up for a long time!
  7. Marc Funaro Says:

    @E. Martin:

    Funny interview, but I do feel the obligation to mention here that in case someone wants to take it seriously, that 'inteview' is a just a humorous hoax :)
  8. Aaron Greenlee Says:

    I understand how you feel. As a CF programmer since 2000 I felt the need to continue my advancement with CF. And CFC's and OO are the 'new thing'.

    The project I am building now is complex. If I was writing procedural code it would have been finished last month. With OO, I still have another four weeks to go. But, I expect it will be easier to evolve its complex behaviors over the next few years.

    On the flip side, my personal web site (other than Mango Blog) does not use OO. It was not required and the last two projects required only a few CFCs.

    I enjoyed your post. I continue to purse the pot of 'true OO' gold at the end of the rainbow. I still think I'll get there.

    This was the first time I have found your blog (thanks to Scene Coyne's twitter post, I found it). If you had an RSS Feed I would have subscribed today.

    Thanks for sharing. It was nice to have some of my frustrations validated.
  9. Sammy Larbi Says:

    It's a very long read that I think is valuable.

    I think it would be *extremely* valuable if you could boil it in a format that's less stream-of-consciousness and more like a typical "intro/thesis, 3-to-5 paragraph body, conclusion" essay with the added value of succinctness.

    Anyway, I posted it on reddit because I the ideas expressed "in between the lines" to me, are worth discussing.

    The URL is http://www.reddit.com/r/programming/comments/8mxcp/how_oo_almost_destroyed_my_business/

    Here's what I wrote:

    It's very long and drawn out. It's written with words that make it seem specific to ColdFusion. It's written mostly without regard to introspection on the part of the author.

    But, it contains a lot of assertions that can generate good discussion. It contains a lot of statements that are true about the way OO is sold by the true believers. It begs a lot of correction.

    However, it made me think. It made me think about how, even with a lot of effort on the part of students, computing, programming, and OO in particular might not do a good enough job at being approachable and talking about "it depends".

    Certainly there's plenty of "it depends" out there. But I wonder if, in our zeal to say "beginners should do it by the book until they can make appropriate decisions about when 'it depends'", we just leave them by the wayside floundering about in frustration.

    I'm sure this post will be downvoted for the reasons I mentioned in the first paragraph of this comment, but I hope we can read between the lines, look past the obvious, and discuss the real issues the author raises, even if he may be doing so unwittingly*.

    (* "unwittingly" - I don't know - I haven't asked him)


    There's so much in there that I don't think I'd ever find the time to respond in full- so many side issues and story behind the story.

    Great post, even if I rather strongly disagree with a lot of what I read. It's something I should take into consideration.
  10. Marc Funaro Says:

    @arron:

    You said:

    "But, I expect it will be easier to evolve its complex behaviors over the next few years."

    It will be interesting if the evolution you are asked to bring about in the code is truly assisted by it's OO-nature, compared to a non-oo version... but since there will never BE one, there's no way to truly measure the benefits you may or may not experience -- and whether those benefits will ever make up for 160 man-hours of estimated additional coding time!

    Keep that pursuit of that "pot of OO gold" in check -- and really consider looking at what CF can handily do without it. ColdFusion can stand on it's own!

    There are in fact two rss feeds for this blog:

    http://www.advantexllc.com/blog/feeds/rss.cfm

    and

    http://www.advantexllc.com/blog/feeds/atom.cfm

    Feel free to post back if they are not working for some reason!
  11. Marc Funaro Says:

    @Everyone:

    It occurs to me that I haven't really thanked you all for visiting, and taking the time to tell me that you found this post useful. THANK YOU! :)

    @Sammy:

    I agree, this post is too long. It is my first official venture into blogging, and it was the topic itself which finally pushed me to do so... so there was a lot to say, and I did feel the back-story was kinda necessary to (1) Introduce myself to those that have no clue about me (i.e. the majority of the planet, and (2) really demonstrate that I am simply a ColdFusion developer, and by far not a computer "scientist".

    As far as it being "stream of consciousness", well, it's a personal blog, so I feel it can be less formal, even if the blog itself focuses on a relatively professional topic... can't really apologize for anything but the length :)

    You are correct -- my post IS VERY SPECIFIC TO ColdFusion. I am unable/unwilling to discuss any other language in substantial detail because I simply don't use any other language. Early in my post I describe my love of the language, and that love has not changed, though it was (NEARLY) lost.

    If this post has made you (as an apparent OO enthusiast) think, it's definitely done it's job! The idea here is not to mock all that is OO, and take a hard-core position for or against it. The idea is to provide some real perspective on how the OOP "folks" are really taking their approach with the same vigor as someone with a hammer, where everything starts to look like a nail. I just feel strongly that most CF projects (or developers!) should be hit with it. At least not with all of it, and certainly not as a core philosophy behind "fundamentally changing how we work". If you're good at CF because you know the language and it's capabilities, you have what you need to deliver successful projects already.

    And I like what you alluded to -- that perhaps the OO proponents need to step back and take a look at how they "market" OOP.

    I can relate this to my own experience as a percussion instructor. Each year, we field a moderate-sized group (around 80-90 students) in competition in the New York State Field Band Conference. Our wise, 25+ years-experienced former director once said something I'll never forget... "If our students aren't doing what we've asked them to, the first place we MUST lay blame is with US -- it's something WE are not doing right as a staff."

    Depending on how many CF programmers "concur" with my post, it may be an indication, as you've implied, that perhaps it is the *OO* community that needs to make a change. A change in marketing, a change in tone... perhaps even a change in "venue" -- as in, OOP doesn't necessarily BELONG in every possible programming scenario.

    I welcome any response you do find time to make to this post, and deeply appreciate your time (and everyone else's) to wade through it!
  12. Brian Rinaldi Says:

    Here's my initial feelings about this. First of all, it contains far less nuance then you think it does. While you say things like "use OO when its useful" (or along those lines), you generally dismiss any uses. So, its not nearly as even-handed as you think...and tends to be more pure of an anti-OO rant than you would like to portray it as.

    I've found a lot of benefit from learning OO and in fact, when I am dragged back into procedural (in your words CF3) code I keep running into the same problems. Code is copy pasted everywhere, logic is repeated 100 times in 100 pages and when 1 change is needed it means a massive rework. There are still chains of files, but they are includes and custom tags and far less flexible than CFCs.

    Still, like many people when they come to understand these concepts, I am pragmatic about it. Frequently you cave in on purity just to get the project done and on time (and embrace the possibility of refactoring)...but that doesn't negate the benefit of the concepts I learned and use (the ones you are so thoroughly dismissive of).

    I understand that feeling you had that you had to get it all perfect. I have been there. Still, in the end, the OO police don't actually exist...your projects were yours to architect as you pleased and you were the one setting these high standards you couldn't meet. You sort of acknowledge as much but also seem to blame your situation on others (OO gurus). This paralysis you describe is a completely self-inflicted wound. It also doesn't mean you need to go back to pre-CFC procedural coding (which is also what you seem to imply).

    Finally, there are some people who can be object purists to the point of religiosity but this is very rare in my opinion (which isn't what's implied in your post)...but there are a lot of nutcases out there on a lot of topics and they only have much influence if we choose to listen to them. My point is, you paint with a broad brush that is unrealistic and unwarranted.

    On another note, keep up the blogging. Just because I disagree, doesn't mean I don't think the discussion is worthwhile. :)
  13. Sammy Larbi Says:

    @Marc:

    You said:

    "As far as it being 'stream of consciousness', well, it's a personal blog, so I feel it can be less formal, even if the blog itself focuses on a relatively professional topic... can't really apologize for anything but the length :)

    You are correct -- my post IS VERY SPECIFIC TO ColdFusion. I am unable/unwilling to discuss any other language in substantial detail because I simply don't use any other language."

    Let me just respond to these two things, which are ancillary to the post, but which clarify my opinion:

    1) I don't actually mean to say that the stream of consciousness technique makes the post less valuable, nor do I begrudge you using it on your personal blog.

    What I really mean to say is that this post brings up a load of quality discussion topics, and that the style means a lot of people will ignore it because of the style and length. It's just as valuable, but people have to dig harder to find the value. Most people won't, which is why I said it would be more valuable in a more concise and to-the-point form.

    2) While your post may be very specific to CF because of your experience in that language, it needn't be. In fact, it's a very general topic that I think people from all backgrounds can appreciate and learn from. When I mention that, it's only to point out that the appeal is broader than a typical scan-read would indicate.

    Anyway, I am going to try to sort through it and make a blog post in response. After I'm done, and if I feel my words do the topic justice, I'll post a link in case you or anyone else is interested.
  14. Marius Andersen Says:

    I was kind of expecting it to end with a reference to the beginning quote. Oh well, here's another:

    "The theory is the result of listening to the problem. When the theory acquires a life of its own because some people like it more than the real world, all kinds of uninspiring, uninteresting things happen, so the key is both to listen to the problem and to study the theory. But always remember that just as much theory is bunk as there are buggy solutions. There is nothing more wrong with "theory" than "solutions" - both their quality and their applicability are orthogonal to their existence." - Erik Naggum
  15. Charles Says:

    You bring up valid arguments against OO, but you do so by mistake.

    I take photos, but I am not a photographer. I make dinner, but I am not a chef.

    You are not a developer, you are a hobbyist.
  16. Mike Hazard Says:

    @Charles,

    Please define developer. Also, if his arguments against OO are valid, I'm not sure your "you do so by mistake" follows.
  17. Leon Says:

    "The worst thing that could ever happen to a ColdFusion developer is to take a Java class."

    I think the word 'ColdFusion' is redundant in this sentence.
  18. Yves Says:

    To continue my comments a bit.. although I didn't list all my priorities (which may vary a bit depending on the project)....

    Learning some OO concepts and a few of the more popular frameworks have had a positive influence on me personally on how I think about code structure.... and flow... so that I don't have to write stuff over and over.

    Although I don't use these frameworks on every project.... I (admittedly) am a bit fond of both Model-Glue and ColdBox.

    I guess overall, it's good to have tools in the toolbox.
  19. Paul Says:

    On the basis of this post I kind of worry about you Marc. I don't want to deflate your confidence but I feel as if you entered the computing world through one alley and have treated it as if it were the highway.

    Really, what will happen when cold fusion is discontinued? Are you ready to learn the next thing? Are you content to just move on to a different business?

    You don't mention Javascript in this post, but it is a fairly object oriented language. In fact it has some tricks up its sleeve that leave Java in the dust. Are you comfortable with it, and with slightly advanced features like nested functions and JQuery?

    If not, I really think you may be heading for a dead end. I say that not to make you feel bad but really with the intent of helping.

    Your article just doesn't suggest what your plan is for when Cold Fusion is obsolete.

    Here is my suggestion for you: 1. learn Python. 2. use Django for a low-priority site. 3. set yourself a goal of contributing to Django or some related tool.

    My reasoning is that you can learn a lot about OO, MVC etc. by watching how other people do it. When you contribute code to an open source project, you are learning as part of a community and not off by yourself.

    I think that Python is a good language to learn OO *and other modern techniques*. OO is not a be-all and end-all. It's just one of several modern web development techniques, along with AJAX, CSS and URL routing.
  20. spaghetto Says:

    Man it's good to know that you finally reached the only sane conclusion to all this OOP madness raging everywhere these days:

    "OOP at-all-costs in small/medium dynamic web sites is totally idiotic"

    Let the OO monkeys loose their sanity on MVC design and patterns, sometimes they get so pathetic that you should feel a real competitive advantage not having to care such BS!

    Have a great day!
  21. florin Says:

    The short point that Marc is making in his long statement is that educated programmers introduce complexity for the sake of it.

    OO has its place and Marc recognizes that. What he finds offensive is that a simple manner of getting things done which obviously matches his need, this simple manner is being mocked by 'pros' as unprofessional.

    The fact is that if you give a philosopher a final answer, you suggest to him suicide. He needs to keep talking. Women love to talk not to find and answer but because they love talking.

    Likewise, these smart, educated programmers, cannot live with a simple solution that just works for the given scenario. Nope, they need something that is extensible, manageable and sophisticated. They need something that gives them an opportunity to expose their vast and complex brain. It must be twisted, unfathomable and arcane. It must draw and 'Oh' from the audience. It must be brilliant.

    They forget that someone needs to deliver and pay the bills - only their bills are important for time spent in artful discussion.

    This is very common to the java world. It's not the language, it's the people who, unlike a pragmatic oriented Microsoft or a pleasure-in-results driven php world, yes it's the people that now have the freedom to implement a framework based on the GoF.

    I've long given up on complex frameworks and while I still do java / groovy I stick to the simple. Lke Apache click with velocity and Ebean. Yep, an ORM yet all I need do is add @Entity at the top of the class.

    PHP remains awful though. CF is great and will stay, yet is not embraced because it's been here for too long and it just works. There's not much to talk about it, it's not cool and trendy.

    Lesson learned.
  22. AdvanCode Says:

    Replace 'CF' with 'PHP' and it's the same thing. I agree that many times you don't need OO / MVC / etc., especially for a few simple pages. OO make sense where is the ONLY option, like Java, not languages like CF or PHP (that were MADE OO from procedural).

    And think OO for larger teams where you have architects that like drawing (aka UML), specialized team only for design and usability, another team for testing and a larger team of developers. If that's not the case it's safe just stay away from OO entirely.
  23. Nick Kwiatkowski Says:

    Marc,

    I read your entire article, and enjoy what you read. But in all honesty, I think there may be a bit confusion between the worlds of OOP and Frameworks. The problem with the CFML world is the two are often tied together, and are often substituted for each other.

    CFML is a language, that since version 6, allows for fairly (read: 80%) good implementation of OOP concepts. I don't think there are many languages other than Java or C++ that can take it above 95%. You don't need the complexity of a framework to expose these concepts -- infact I would argue that the available CFML frameworks that exist today go against many of the popular OOP concepts that makes it so popular.

    I personally use OOP in a majority of my projects, but haven't used a framework in over 3 years. Sure, I explore the frameworks that are out there, but I think they make their use and deployment entirely too complex and over-driven. There is no reason that in an OOP world that you have to go through 5,000 lines of code to return a simple query. Conversely, there is no reason for a simple query to take 3,000 ms to process. This is not dictated by OOP, but rather the over-architected frameworks that exist.

    Concepts like patterns and inheritance have existed in some form within CFML long before OOP. Although they weren't by that name, Patterns directly relate to the architecture of your application. While people point to "the pattern book" to find the best solution to their problem (or even worse, people pick a pattern before they realize the problem they are trying to solve -- the frameworks they deal with today). For me, I deal with about a half dozen patterns in my applications, all of them tackling the problem the best way possible.

    It's funny that you went down this route in a way -- Fusebox users often had the worst mentality -- fusebox is the hammer for every nail, every coffin and every street light. It was the excuse that businesses used to get CFML to build "enterprise" applications. I still haven't found out what an enterprise application is, but from all of them that I've used, I feel it means that you have a bunch of users that have no option but to use the slow, overly complex application.

    But, I digress -- you can listen more to my rants at an interview I did a while back -- http://www.cfconversations.com/index.cfm/2008/10/26/CFConversations-20
  24. frank Says:

    It sounds like you are talking about the difference between component and page models for web page development. That's separate from OO and the component model does add a lot of complexity.
  25. gorlok Says:

    CF is a tool for non-programmers and small projects. It could be a great tool for the right job. But, don't shoot in your foot.
  26. marc esher Says:

    Thanks for the brain dump, Marc. It's interesting to read about your "journey".

    To the commenters who wrote about "gurus" who poke fun at non-OO code, or gurus who basically say "if you're not doing OO, you suck"... can you please point me to blog posts, articles, newsgroup posts, etc where "gurus" have made these types of claims? Or maybe if you have specific people in mind but just can't find the particular post, could you say so, so that I can go read their writings? I'm much interested in reading them.

    Thanks.
  27. Mike Brunt Says:

    Marc, first of all thank you for taking the time to write this post, I read it all and my perspective is not from a developers point of view. I did start as a developer in CF at version 1.54 but moved to the server side 10 years ago when I was employed, by Allaire, as a CF-Spectra consultant.

    Since 1999 I have been constantly tuning and troubleshooting CF-JRun applications. I have seen 100's of CF applications of all flavors, frameworked non-frameworked including all of the formal frameworks. I can say this without hesitation all of the applications using OO constructs had performance problems that were impossible to totally solve. All of the applications using OO constructs were far more difficult to troubleshoot, by enths of a degree. Those are facts.

    I feel that CF can be both procedural and/or OO in concept and that the developer community will find comfort in one or the other. Your experiences here attests to the fact that it is not always optimal, nor in my opinion necessary to move from using CF in an procedural paradigm to an OO paradigm. I do think that existing OO programmers will find comfort in using CF in that manner and that is a plus. It is definitely not a bad thing to write applications from the get-go, now, today, as procedural, in my opinion. Organization of code is the key issue, procedural does NOT automatically mean spaghetti code, it is wrong-headed to think that way and make assertions like that and yet many do.

    One last comment I have, there is a certain smugness in some of those, in what is perceived to be the higher echelons of the CF community, typically most of whom espouse OO concepts. That smugness is coalesced is the phrase "5 Taggers" which I do not like to hear at all. To be blunt if all that we relied on for the survival of CF was revenue to Adobe from the OO side of CF usage, I have a feeling the Adobe would not be too interested in investing in continuing the evolution of CF. I hope I explained my thoughts well there.

    This is a truly great blog post one of the best I have read and there are many out there who feel the same I know I have met them in the 100's of client locations I have visited.
  28. William Steiner Says:

    I agree with Nick Kwiatkowski, OO didn't almost destroy your biz... the world of "universal frameworks" almost destroyed your biz.

    On a side note...I had a CF buddy who every time he had a issue and asked me for help, it was a simple fix. But because he was using a "framework" he had to go to the moon to go from FL to TX.

    To quote John Lennon: "I don't believe in Frameworks, I only believe in me." or something like that...

    a good framework is a guide..not a rule. If you are spending most of your time programming around your framework -that is a frickin problem.
  29. Raymond Camden Says:

    Wow, great blog post. I don't agree with many of your points here, but you really made me think and it was great to see the discussion here.

    I won't argue with your conclusions here. I don't agree with them all, but it's what you learned and what you feel, and I don't really see the point. (I don't mean that negatively or that your stuck in your opinion, just that the blog post was your rant and you are certainly allowed to express what you think!)

    I do take an issue though with what feels like an attack on the "OO gurus". What community are you in? The CF community isn't perfect (which one is), but you described a group of people who are pushing OO as the solution to every problem and putting down newbies who dare to complain.

    This is not the community I know.

    Our community has a great, and varied, collection of bloggers. People who, in general, share their time and energy helping to teach other people. And while certainly there are a few egos out there (I've got one, I'll admit to it, and I'll also admit to having used the 5-tagger term), I'm not aware of any blogging acting as you have described.

    Maybe you didn't want to name names, and I can certainly understand that, but I really feel like you are seeing a side of the community I am not.

    Most folks I know of that 'push' OO never do so as "The One True Way." I'll throw out 3 names just because they come to mind: Hal Helms, Sean Corfield, and Brian Kotek. I think these guys are incredibly smart, and have a huge amount of combined knowledge in the OO, frameworks, design patterns, etc world. Yet I've never seen them ever push OO as the solution you MUST do, no matter what, in all cases. Rather, I've seen them try their best to get developers to NOT blindly follow OO principals when it doesn't make sense. (I'll admit to being one of those people who tried to. If you are look at some of my OS apps, you can see where I did, and my only excuse is that I still trying to find my own way.)

    For me, learning about frameworks and design patterns was incredibly helpful because it helped solve problems. ColdFusion is incredibly powerful. But as powerful as it is, there are still times when a project gets to a level of complexity where frameworks can help me out. It let's me focus more on the business needs and less on organization. To me this isn't adding complexity, but rather _removing_ complexity. Ditto for ColdSpring. But anyway, that's just been my personal experience. :)
  30. Fabian Pascal Says:

    Suckah!
  31. Chris Mallinson Says:

    Marc, you have earned the title of "My Favourite Person" today.

    Like others have said, I don't agree with everything in your post, but I agree with a lot of it. I don't like the idea that everything has to be slotted into OO in some way.

    Personally, I use Transfer for almost all my sites now. I like the idea of an ORM, and I find it makes development faster for almost all sites. I also abstract my calls to Transfer into my own DAOs and I create gateways for more complex data retrieval. My methods would not be considered MVC, but I get close.

    As for personal development, I think the suggestion by Paul above is spot on. Learn Python and Django. It really is a great introduction to OO done right. I have to admin that I have trouble wrapping my head around some of the more complex OO concepts using CF, but with Python, it seems more natural.

    Despite learning a new technology, I have no plans to leave CF behind. It's such a powerful language, while at the same time being accessible to the masses. I don't think there is a more productive way to build websites.
  32. Brian Swartzfager Says:

    Marc, I understand where you're coming from. It sounds like you're a solo developer like me, and as such the only sounding board we have for the work that we do, the examples we have to compare ourselves with, come out of the blog postings, presentations, and comments of the ColdFusion community that exists online. And a lot of what is out there these days concerns OOP, so if you're not doing OOP but it seems like all the respected members of the community are, it can apply a subtle pressure on one's coding thought process.

    But I agree with what Ray Camden said regarding Hal Helms et. al.: if you talk to any of them, they will all at some point that there is no one specific way to code an application, and that there are cases where OOP is overkill. But hearing that "some point" can be tricky: the mantra "use the right tools for the right job" isn't stamped out on every blog post...and it's not practical to do so.

    It sounds like coming to this decision to follow your own coding path has pulled you away from the brink of abandoning coding, and as such I think it's the right decision, even if it means taking a strong anti-OOP stance.
  33. Dale Fraser Says:

    Marc,

    What a good post, I must admit that I went through a similar process when transitioning from Procedural to OO programming.

    I really struggled with it for a long time, thought it was beyond me didn't understand how or why, was very lost. I thought why did they have to do this, I was very comfortable and capable in the way things used to work.

    It wasn't until I went back to Uni and did a few OO type classes that it finally clicked and I could transition those lessons to ColdFusion. However this transition was a long and painful one similar to yours, many months frustrated at lack of understanding, thinking I wasn't doing things the right way etc, etc.

    I now like OO concepts and develop this way, however it is NOT for everyone, I know of countless CF developers that have never transitioned and probably never will, they are comfortable and competant in their existing knowledge.

    I agree 100% with your view that unless you use OO and frameworks you are made to feel inferior by the community. This isn't a CF specific community issue, this is just a change in the times, hard core OO people will never go back and some old school people will never go forward. I believe there is room for both. But they will like to express just how wrong / badly you are doing things none the less.

    One of the fundamental issues with learning OO from a procedural background is just changing your mindset. I taught all several of my CF developers OO as they came from procedural backgrounds, they all picked it up fairly easily but I think that was due to having me teach it, someone who had been through the whole struggle. I could teach, this is how you would do it, and this is why. There is no point understanding how, if you don't understand the why (benefit).

    The biggest negative with not learning / adopting an OO approach is that everyone wants it now, it might be hard to land a job without these skills, but if your working for your own clients, this might not be an issue.

    Its good that you enjoy ColdFusion development in the original way it was intended to be developed. And just to be clear, there is absolutly nothing wrong with the way you are doing things.
  34. Chris Clark Says:

    Marc, you are a dumbass. Perhaps you should get an IT degree before you call yourself an IT guy.
  35. Mike Brunt Says:

    @Chris what a rude inappropriate and totally unreasoned statement you made here; perhaps you should get a degree in manners.
  36. Chris Peters Says:

    Chris Clark is probably an OO elitist. ;)

    I'm glad that I subscribed to the comments because this has been a fun conversation to read. I love this community for keeping it respectful and for sympathizing with those of us who may be on the other side of the fence. I must admit that I'm less mature at times.

    FWIW, I'm not sure what gorlok meant when he said that CF is only for small projects. I beg to differ that it is more appropriate for larger projects than some of the other server side technologies out there!
  37. Alirio Boquin A Says:

    Hi Marc.

    I really respect your opinion, but In my experience all this about, how much you understand the project.

    We have a lot tools to use in our solutions, I mean languages(CF,PHP,.NET), UML, design patterns, frameworks, etc. But this tool don't help you to make an easier and practical solution, you have to understand the project.

    Another important thing is, USE the SIMPLEST solution possible. A simple solution it is easy, to upgrade new features.

    I my experience I been working with CF since 2001, and using OO with CF since 2004. And really make my life easier. At the College I study C++, Java, and other OO languages. All this knowledge is important, is our experience. Two years I go I begin with Flex, and CF backend, and was so easy to use in some case because is pure OO, my experience help me a lot to go forward. :)
  38. Yves Says:

    I really agree with Chris Peters in that I'm glad I've subscribed to this thread.

    I've enjoyed reading what everyone has had to write on this topic.
  39. Marlon Moyer Says:

    It's funny, because originally when the OO approaches were first starting to appear for CF, I hopped on the bandwagon and started the process to adopt them. It never really felt 'right' to me and it really made me start doubting myself with all the people on the CF lists praising the new OO frameworks and all the benefits of using them.

    I started developing in RoR as of version 0.13. Amazingly enough, the OO concepts in rails clicked....and clicked fast and I loved it. After that, I tried OO in CF again. It still felt like I was trying to shoehorn OO concepts into it. In the end, I've adopted my own strategy for CF development which has some OO, but mostly procedural code.
  40. Aaron Greenlee Says:

    Another approach would be to build your models with Groovy or another language that does true OO. Best of both worlds if you want the OO.
  41. Scott Stroz Says:

    @paul - Did you realy try to compare Java and JavaScript?

    Also - and I am surprised no one else mentioend it - its ColdFusion NOT Cold Fusion...thanx!

    @Marc (the author) - I, like others, would like to know who are these 'OO gurus' you are state are claiming that if you don't do OO you suck.

    Honestly, the OO vs procedural discussion is growing about as old as the 'CF is dead' discussion.

    Is an OO appraoch always going to be the best solution? No, and anyone who tells you otherwise is a fool.

    Is a procedurtal approach always going to be the best solution? No, and anyone who tells you otherwise is a fool.

    Just like anything else, you need to choose the best toosl for the job.

    I happen to like using frameworks, but I also happen to like using an architecture that allows me to be able to move my 'model' from one framework to another or even take fraemworks out of the equation completely.

    I have had the experience of inheriting unfinished applications from a number of developers. Some were good, most were bad. Some were OO, some were procedural. I can tell you that there really was no disparity between the good/bad and OO/procedural. But there was one common thread. If the developer followed good coding practices then the apps were orders of magnitude easier to work with than those that did not - and it did not matter of the app was OO or procedural.
  42. Alan Rother Says:

    Man.. I need to buy you a beer at the next CF conference. You said a lot of how I've felt over the last 4 or 5 years. Thanks for saying it so well and so honestly.
  43. OOoh Says:

    @Charles
    If Marc has been supporting himself for years developing applications, he is a developer, not a hobbyist.

    That said, I agree with some above commenters that this rant is more against frameworks than OO specifically. OO did not almost destroy your business. For that matter, frameworks did not almost destroy your business. A single-minded determination to jump onto somebody else's track, without thinking critically or researching when or how that track should be applied -- *that* almost killed your business.

    The biggest mistake Marc apparently has fallen into the trap of there being One True Approach for all problems. When he started with ColdFusion, it let him make a certain type of classification quickly, easily, and to his clients' specification. So far, so good. Great, even. Then, when first bitten by the OO bug, by his own words he was paralyzed by having to place anything and everything in an OO (or framework) context. When he tired of trying to force square pegs in round holes, he returned to ColdFusion as the One True Way. Yes, there is lip service here paid to "good stuff" in OO, but it seems more a sop to any OO zealots reading than any real understanding as to where or how it would apply.

    The truth is, there is no One True Way. Never has been. Never will be. Part of the struggle in being a developer is learning new techniques and languages, and even frameworks, sure, but the skill that keeps you sane is knowing when to apply each.

    The best thing for your career, your enjoyment, and your blood pressure is to stop looking for a Golden Hammer, and instead focus intensely on your clients' problems. Determine the shapes of the holes you have to fill, and plan your time and your toolset around those holes. If CFML is the best fit for every hole in a project, then stick with it -- it does *NOT* make you any less of a developer. If, however, a hole suggests adding a tool to your belt, do so not blindly, but with an eye on the problem at hand -- odds are each technique you learn this way will give you that same rush as when you picked up ColdFusion as your best tool to build that first dynamic website.
  44. John Edwards Says:

    I'm surprised this is still a topic. I remember well the times that OO was introduced for mainstream development. Old timers had a very hard time to make the paradigm shift, if they were able to cope at all. People who had been through a paradigm shift before (from chaotic to structured) just couldn't wrap their heads around OO.

    The newer generation however never had a problem with OO. When they learned programming, they learned OO with it, straight from the start. This was back in the late 80-ties, early 90-ties.

    Rants against OO were common back then, but I really haven't heard this stuff since 10 ~ 12 years or so. It's like a post ranting about the move from mechanical type writers to electrical ones.
  45. John Says:

    The way I see it is OO did not 'almost destroy' your business, you did.
  46. Marc Funaro Says:

    Greetings Everyone,

    I'm posting a short reply (imagine that!) to say thank you to all those that have commented here. (Yes, even the immature snipers.) Every single comment has been useful, and has helped me begin the process of better clarifying my position, justifying my statements, and yes, admitting where I am at fault.

    I hope to find time in the next week or so to write a followup post, but in the meantime, I do hope to see more discussion, either here or on reddit (where I took a substantially more brutal beating! :)

    Please keep the conversation going, it is truly helpful.
  47. Mike C Says:

    I couldn't agree more.
  48. Steve Bryant Says:

    Marc,

    This is definitely a thought provoking post (as demonstrated by the comments it has received). I started to write a comment, but it ran long so I turned it into a blog entry.

    http://www.bryantwebconsulting.com/blog/index.cfm/2009/5/26/The-Trouble-with-OO
  49. phill.nacelli Says:

    I have found that the ColdFusion community is made up of two groups. Folks who provide website design/creation services and web based sofware solutions providers. Both groups have very different needs and they have very different methodologies and processes to solve those problems, kind like a executive chef and a pastry chef, but unfortunately is that from time to time they tend to want to follow the same "recipes" they find online.

    I'm just curious who in here are building websites (whether dynamic or not) versus building real enterprise level web based applications...
  50. Brock Baxter Says:

    I'm noticing a lot of dissent in the community.

    There's a growing movement afoot against OO, and I think well-researched commentary like this post is supportive of the fact that there is a big backlash against OO.

    Even at the large CF conferences we're seeing more and more of the Big Name CF people coming out of the procedural closet to explain why OO isn't really the best. I think this is great, because I (and a silent majority of programmers) still use procedural code and do it every day.

    So, let's keep it up boys!!!

    thanks,

    BB
  51. Raymond Camden Says:

    @BB: Again, I keep hearing 'Big Name CF', 'OO Gurus', being thrown around. Can we please start being specific? As I said in my earlier comment, I don't know anyone that I'd consider an expert who has _ever_ said that OO is the one true way and that all code must follow the same pattern.

    If you are seeing this, please point out specific examples. As I said in my original post to Marc, where are you seeing this in the community?
  52. Marc Funaro Says:

    Hi Ray,

    I don't have time at the moment, but I want to at least get a quick response in on this point -- I must correct/retract any implication that *I* have made that the experts are saying that OO is the one true way. I intend to respond to this more fully.

    Please don't let that one unclear position detract from the overall conversation, and to everyone else, please know that I don't hold that specific view... i have more to say on the matter as soon as I find the time.
  53. phill.nacelli Says:

    Thanks Ray,

    I was also wondering who the "Big Name CF", "OO Gurus" are? Show me where on their blog did those comments come from. I don't see that big of "dissent in the community", CF.Objective was a very successful conference and there were many folks there looking to learn more about Object Oriented Programming as well as the frameworks that take advantage of OO and Design Patterns.
  54. Garrett Johnson Says:

    I can understand many of your points on this post. I personally feel (like others have stated) that OO can be a complex solution for complex problems. But this is what makes up many of the CF applications out there that our generous CF gurus are building. Therefore, it is a good fit for them.

    I do not think that the problem is with OO or the ones “pushing” it, but the pressure that people new to CF or programming in general PUT ON THEMSELVES to learn these patterns. (Not saying that this is you, but me!). When I first started to program, I felt like people would think I “SUCKED” if I used procedural code (though no one really did). So I went out and thought... “…well I don’t know any SQL, best practices are how to even do the basics, but I am going to solve all my problems with ORMS, frameworks, patterns, etc…” (I actually tried using Ruby on Rails, before I even understood HTML, because I thought I would be “COOL”!) … WHAT A STUPID AND BAD IDEA ON MY PART!!!!

    I have learned that you need code “normally” and learn how to actually do it correctly, before moving on to the complex OO patterns. By doing so you will figure out how OO will solve SOME of your problems that your current coding techniques are not solving, and how to implement it in your own way that fits your problem best. You will also figure out how it will not solve some of the other problems. (again, I do not think this I you, you seem to be quite solid in your development set!)

    Thank you for your great post!

    Did anyone else feel that way when they first began to program?
  55. Steve Bryant Says:

    As I mentioned in my entry on the topic, I don't think the issue is really that anyone is saying that OO is the only way. I think the real issue is that all of the prominent ColdFusion bloggers seem to use OO themselves and there is no countervailing force saying "Hey, here is a way to do non-OO development".

    So, effectively this is the fault of people like me who don't do OO and don't blog about our experiences.
  56. fsilber Says:

    Java is a good object-oriented language, but I find that it is virtually impossible to use object-orientation when designing JSP pages. That's why there are a hundred open-source web frameworks to try and make J2EE web development easier -- but they just add layers and layers of complexity. I am not surprised to hear that the same is true of ColdFusion. Tag files are simply not object-oriented, and trying to force object orientation into an application based on a collection of tag files is a mistake.

    Object orientation _can_ be used to make web development easier and more productive, but only if you use an object-oriented display-logic toolkit such as Wicket, GWT, or Echo2. These are Java frameworks, but they're not the most commonly used.
  57. The Daily Nerd Says:

    Thank you for posting this. I have also been CF'ing since version 3.1 and had similar thoughts on the subject of OO programming. In many cases, I just don't feel it's neccessary. It's depressing to think of the hours I've wasted overcomplicating my projects. I will say though that I am very excited with what Chris and the others are doing with the CF Wheels framework. It's simple and it saves me time, both with writing and maintaining code.

    Anyways, thanks again for this post.
  58. fsilber Says:

    You learned OO with the WaterFall method -- complex design patterns (e.g. MVC) are architect before coding. This turned out to be a very bad approach -- unnecessary solution flexibility means unnecessary complexity, as you have seen.

    The agile or XP approach to OO development says don't design any complex mechanisms unless and until they're needed. To add them at that point you must refactor your code using Martin Fowler's techniques, unit tests, and an IDE that automates many steps.

    Sadly, these refactoring techniques are impractical when program logic is embedded in tag files (e.g. ColdFusion, JSP, HTML with scriptlets).

    You'd do best to either stick with small systems and ignore OO, or use a web toolkit that lets you keep display logic out of the tag files (e.g. Wicket, GWT or Echo2).
  59. Brock Baxter Says:

    Friends,

    Just to be clear--when *I* mentioned big-name OO people, I was mentioning big-name CF people who were AGAINST using OO in CF, which seemed like an interesting counter point to the original article.

    I did not want to mention specific nams (because I do not want to speak for them), but they are easy enough to find.
  60. John Edward Says:

    One other thing to consider is that the next paradigm shift is already around the corner: the shift from sequential coding to concurrent coding.

    The magnitude of this shift should not be underestimated, and is atleast similar to the shift from procedural to object oriented. In fact, Herb Sutter has made this exact observation in his legendary article "the free lunch is over".

    If you still have difficulties with oo, are you ever going to understand the concurrent model?

    (and for those wondering, concurrent programming us not about serving multiple request, but about exploiting parallel hardware to serve a single request or computation)
  61. Lee Says:

    For what it is worth:

    I trained first in OO.

    At my current company, we have both procedural ColdFusion applications and OO .NET applications.

    The OO applications take about 4 times longer to modify.

    The OO applications take about 3 times as long to troubleshoot.

    Part of this is surely working with .NET, but part is the unnecessary (IMHO) complexity introduced by OO for the mid-sized applications we build.

    As lead in my area, I've resisted the push to go OO just for the sake of it. I'm open to the concept, but haven't seen the benefit. That is not to say that we won't go down that road if a large project would make it beneficial.

    I've also attended various conferences and training sessions on OO, and though instructors/experts have touted OO, none have decried procedural coding. They have implied that procedural is inefficient, of course, but that is a far cry from declaring it dead.
  62. Thomas Kamnikar Says:

    Marc - This blog post sings the song my heart has been crying for the last year.

    I'm a 35 yr old web programmer who graduated with an art degree. For the last year i've been paralyzed with fear over getting replaced or "refactored" by the young OO programers emerging. I've tried many times to grasp the OO/Framework concept simply because I've been told by all the CF experts that I respect that that's the way I need to go. Yet I continue to think to myself "this would take me a lot less time if I just wrote it myself the way I used to.

    Thanks for making me feel a lot less self conscious about my programming decisions.
  63. fsilber Says:

    OO is about having polymorphic types based on interfaces rather than data structures. It's much more flexible than traditional strong typing (e.g. Pascal), and much safer than weak typing (e.g. Basic).

    What causes trouble is the theory of OO design -- making classes represent business domain objects, as we have to work with relational databases, not OO databases.

    Whether you can benefit from OO language features depends whether your set of applications is large enough to have significant cut-paste-and-modify redundancy you could factor out. Used well, OO applications will be more complex but also MUCH SMALLER than the repetitive non-OO alternative. OO techniques that don't shrink the codebase (by factoring out repeating patterns) just get in the way.
  64. Adam Haskell Says:

    I think you have some interesting points. Your experiences have guided you to where you are and no one can fault you for that. This being said I must say this echos some of the issues I see in this community, and not just the CF community it happens everywhere it is just more pervasive in the CF community. You have been guided into your position based on a good bit of misinformation and misunderstanding/misrepresentation of statements. All to often we have envy of some other group of people, be it Java or smalltalk, groovy or ruby on rails. We then take some generalize statement like, "you should learn OO the concepts are important" and internalize it and remember "I should always code in OO." This happens constantly I watch it happen and I have had it happen to me.

    A large piece of misinformation you have now put out into the are is the OO nature of Fusebox.

    "The framework I'd used and loved for so long, Fusebox 3, by version 5.5 has become completely OO-based. That HAD to be better (right? RIGHT??!). It was pure OO - or at least, as pure OO as ColdFusion can get. It was just a given -- if you really wanted to do OO, your framework should be too."

    Fusebox itself is now CFC based that is true but I can assure you while it does, internally, leverage some OO concepts it is not OO or even hinging on OO in many respects. It's not even the whole "OO as good as CF can do it" BS either. It is important to point out that the intent of Fusebox is to provide a procedural and OO framework, it is made to fit your coding style. Some framework do force OO styles on you but Fusebox is an elegant solution for OO or procedural. Honestly this fact is what drew me to Fusebox and why I took it over. Sometimes I like a little Object lovin' sometimes I don't.

    The second disservice you have done to the community I want to defend, briefly, is tell people to not learn Java. I want to add clarification to that... Don't learn Java with your intent to code LIKE that in ColdFusion. Learning Java is still important as it is the basis of our platform, I think it is important to at least at a high level understand how the Java platform works and how it can be leveraged. Just don't try to code Java style code in CF. Learning Java can have some great benefits but you have to learn it for the proper reasons.
  65. Sean Corfield Says:

    Marc has done a good job of expressing the frustrations that many developers feel when trying to learn OO (especially developers who don't have a comp sci background or experience with a broad range of languages).

    I started doing "OO" in January 1992 with C++. I say "OO" in quotes because whilst I used objects, it certainly wasn't very well-designed code. Fast forward seventeen years - with experience in a number of OO languages - and I'd consider myself a pretty competent OO architect but, guess what, I'm still learning new techniques all the time.

    I like to think that I'm "refactoring" my skills and my knowledge to constantly take advantage of what other smart people have figured out.

    The biggest problem for many folks coming to OO is that there is no One True Way. There's no "right" approach to OO. Take a lot at design patterns: each of them specifies forces that may lead you to pick one over another but also consequences to their use. In other words, for any given problem, there are many ways to solve it and there are pros and cons to each different solution. Perhaps the "best" solution today will turn out to be a "bad" solution tomorrow when requirements change? Never be afraid to refactor your code to tackle new requirements - or even just to take advantage of new techniques or, heck, even new frameworks!

    I agree with those who said Marc's "failure" (not really a failure - see next para) was brought on himself by setting unrealistic goals and looking for a silver bullet that doesn't exist. The problem is not OO - it works fine for lots of people - nor frameworks (again, they work fine for lots of people). Part of the problem is being a lone developer which makes it very hard to bounce ideas off colleagues and learn from their experiences (it's why conferences are so incredibly valuable - as are user groups and, to some extent, certain mailing lists). Another part of the problem is being a monoglot - a single-language programmer - which makes it difficult for many CFers to take on new concepts because they don't have the context of a language built around those concepts.

    Finally to a comment on Marc's perception of "failure". He hasn't failed at all. He didn't kill his business - he learned some really valuable insights and has been able to turn his business around. He learned a lot about himself (despite the apparent "blame" being cast "out there") and he had the decency to share his experiences as a cautionary tale to others. As I noted above, I've been doing OO for over 17 years now and I had a comp sci background which made it easier for me. I started programming back in the mid-70's. I learned a lot of languages along the way (for a while I was proficient in Prolog, Haskell and Smalltalk - three languages about as different from each other as they are from CFML but all three taught me things that I can leverage in CFML today).

    My advice: yes, learn Java - but don't try to write CFML like Java. Let programming in Java teach you *concepts* you can apply to your CFML apps. Learn Python, Clojure, Scala... learn Prolog and Smalltalk and Haskell... absorb the *concepts* behind them and synthesize them into your CFML apps as you feel appropriate.
  66. O?uz Demirkap? Says:

    Well done. I feel your pain!

    As Sean said, having a background with computer science/programming and learning right things on right time is the case.

    I would suggest to use whatever works good/enough for you. Do not try "over" limits. If you are happy, there is no problem.

    But if I would be hiring you for my company, probably I would not prefer a guy like you. Do not get personal, I even do not know you or your name. This is a general expression for any "classical" CFML developer.

    This is not only your problem/situation. This is a common status in CFML world and I do not see any solution for this.

    Still you can consider to use "the right" framework for you to create a standard and team environment. Still try to use CFCs even for simple needs etc. Still there may be benefits of using some "OOP" stuff in some cases, use them. Do not forget that you have already paid money/time to learn them. :)

    Good luck! :)
  67. 6 month old CF-er Says:

    I must admit that I agree with most of Marc's comments.

    The main aspect that I take away from this is that there is a different solution for every type of problem. Yes OO may be useful in some cases, but from my short CF experience it can cause more trouble than what its worth.

    Frameworks..where do I start. I actually started CF in a support and bug fixing role and in the first month it was a headache trying to understand how my inherited system actually worked. After some time i figured that it was actually a 'fusebox like' application (without any of the fusebox stuff) but I realised that because so many people worked on it- they did the simplest thing to get the job done. Yes, it may be spagetthi code, but its easily maintable about 90% of the time. No objects, no cfc's (well except for the one i recently created). My point is that this 'fusebox-like' app works without any OO.

    However, i do think that if OO design principles were used some areas would be more flexible and more easily maintable. From a developer perspective, its a challenge that I will glady tackle. However, the powers that be will always have the last say.

    The best thing about CF,as Marc noted, is the 'feeling of empowerment as I went from that first experience to lying in bed pawing through the ColdFusion Reference Manual, looking at all the tags and functions.'

    Overall, brilliant, thought provoking, post Marc. Thanks.
  68. Glen Says:

    Reading your post, I can see that the word ActionScript may be easily substituted for CF and Flash "application" for web page...

    The huge drive to "OO" in ActionScript has frustrated a large number of people in the Flash world, so much over the past few years, that Flash On The Beach 2007's main theme was getting back to "playing around" rather than worrying about your code.

    I have found myself worrying about the design of my next app so much that I never get any coding done because I am worried about getting my patterns wrong. Recently I have been working with a lot of code that is very functional and worrying about updating it and porting it over to a more robust / extensible design. Often when I get so tangled up in the why's and wherefore's of it all I think that the app works nicely now, it is still quite easy for me to update and better than it was, so why try and OOP'ize it all just to fit in with some framework. After spending a long time considering a number of frameworks out there and experimenting, I am coming to the conclusion that whilst refactoring is important, fitting it all into someone else's framework is not necessarily the way to go.

    Anyway, the main thing that frustrates me about OOP is the fact that you often have to write, or setup, so much code just to do a quick experiment... I used to write lots of experiments in flash that all ran on Frame 1, now I have been drilled in keeping my code off the timeline, must have a document class, must do this, must use library x. It's no fun anymore...

    Same problem with PHP too - I used to code for web sites and then spent several months trying to get to grips with CakePHP / Zend, etc. I stil find that my "monolithic" Pear libraries provide the fastest way of setting up a quick AMFPHP app to splurge data into a Flash App, I don't want to install another instance of CakePHP, then spend 2 hours correcting the dodgy code that the scaffolder generates.....
  69. Scott Stroz Says:

    Just because a developer may not be able to grok a concept does not mean that it is 'bad'.

    That being said, I think that not only should you use the proper tool for the job, but a tool with which you are familiar and comfortable. It is possible that 2 tools can serve the same purpose.

    For example, if I am building a house and have a choice of using a compound miter saw or a circular saw (both equally capable of cutting wood - they just do it a little differently) to make the necessary cuts and I am more comfortable using the circular saw, should I really use this opportunity to get used to working with the compound miter saw? No, on a job this big, I would use the tool with which I have the most comfort. This will help me get the job done better and most likely quicker.

    I would use smaller, more personal projects to learn how to use the miter saw and when I feel comfortable enough, I would use that on a bigger project for someone else.

    Eventually, I may get more comfortable with the miter saw and that may become my preferred tool. If not, at least I know how to use the tool so that if I got pulled into a much bigger project where the foreman said the miter saw must be used, well, then I will be OK.

    Just because I may prefer to use a circular saw and have more comfort with it, does that mean that using the mitre saw is wrong? Does it mean that everyone who uses a miter saw is wrong? I think the answer to these questions is pretty obvious.

    I guess what I am trying to say is that when learning new techniques, its not realistic to expect you to become a master at them quickly and, more importantly, to not give up on learning those new techniques if at first you don't 'get it'. Learning a new skill or concept will serve no other purpose than making you a more well rounded (and more valuable) developer.
  70. fsilber Says:

    It seems that most web developers are frustrated by the huge difficulty of implementing OO concepts in the tools they use. This is not their fault. It _is_ extremely difficult to combine OO concepts with most web development tools.

    They conclude, however, that OO was not such a good idea after all. I, in contrast, recognize the ease of using OO concepts in tools such as Swing (for Java fat client PC applications), and Java with Wicket, Echo2 or GWT for web applications, and conclude that it is the other approaches to web development (ASP, CF, ASP.NET, Java with JSP) that are inadequate.
  71. Bob McCormick Says:

    It's been fascinating to read the various posts on this entry.

    I've been on a CF hiatus living in OpenSource land for the past several years and only recently have come back to ColdFusion in working on a project with Marc here of late.

    To state that CF has matured greatly while away is a vast understatement - that said, I think that it's important to note that I think some have misunderstood what is being said in this post. As I read this initially, I could see that the essence of what is being said is that going a purely OOP Design from top to bottom may just not be a good design decision depending on the project.

    I can confirm that the project we're on most definitely has components of OOP AND procedural design that Marc has been laying out which I think is what was the catalyst for this article. Think of it as a hybrid of sorts and it is actually quite powerful, extremely fast to render and I was able to discern the 'lay of the land' quite quickly.

    My sense of things now that I've seen the various aspects of what CF has become is that going whole hog in OOP in CF may just be an exercise in intellectual pride. CF at the core is not an OO based language, therefore some things that can be done in languages that by their very nature are simple to do in an OO way, require a LOT of additional work to accomplish in CF. For instance, Ruby was designed from the beginning to be a OO language. Literally, EVERYTHING is a object, therefore one doesn't HAVE to use a crowbar or additional layers of code to make things work as objects - it all just IS. This is due to it's very core essence.

    PHP5 has has OOP 'bolted on' and while you CAN do things in an OO way, sometimes that just gets in the way or makes for more work. PHP5 and CF seem very similar in many ways architecturally speaking at this juncture, so I feel that the sinkhole that can swallow one up is to live and work at the extreme edges. It's the all Procedural or all OOP attitudes that get one into the code quagmire we all seek to avoid.

    Somewhere in the middle seems to be the best way through the jungle. The path of least resistance so to speak. ColdFusion has aspects of both OOP & Procedural and some things are just wicked fast due to the core essence of what it is. Why throw that away or lose that capability because of an over-indulgence of the OOP KoolAid? Conversely, one could do things the old way and have code splattered all over the project, or does one take some of the OO design goodness such as MVC and have an architecture that is really easy to understand quickly?

    I think that what Marc is trying to say, and based on what I'm seeing in this new 'framework' he's having me work with, it seems that the HYBRID approach REALLY makes sense for the CF architecture. It's not about all or nothing, but the friendly melding of the two. HYBRID baby - that's the ticket here in CF land me thinks.
  72. Brian Rinaldi Says:

    Fwiw, I posted a response that took a different angle on this debate. I think the concerns here are more to do with the general complexity of our jobs as web developers nowadays. The days of CF3/4 were quite different.

    http://www.remotesynthesis.com/post.cfm/this-oop-debate-isn-t-about-oop-at-all
  73. John Engstrom Says:

    The beauty of ColdFusion is that it does not force people in a particular direction. It's completely agnostic. OO people love and continue to expand the power of the OO side. The procedural crowd has an excellent tool with rich tag and function libraries. Those in the middle stay productive and cherry pick the tools and techniques that work best for the project at hand.

    ColdFusion is for inventive people and inventive people are passionate. There is no spoon. There is simply your imagination and ColdFusion. ColdFusion doesn't care if you are an object oriented master or a freestyle procedural hack. It accommodates both with pleasure. It works poorly if you write poor code. It's unflappable when you feed it clean, efficient code.

    Love it and love this community. People don't hire us because we are ColdFusion coders. They hire us because as a community we have proven we are passionate and imaginative when it comes to building web applications and we make ColdFusion do what we want it to do, be it procedurally, or OO.

    I love our community because we can have these spirited discussions without people becoming vulgar. It's a testament to the quality of the individuals that make up this community and it is why we will always be well paid, and in demand, at all skill levels. We're nice people!
  74. Andrew Scott Says:

    The frustration that is felt here is not just a well I don't get it, and I will vent it out sort of thing.

    As some have pointed out ColdFusion allows for the best of both worlds, and although those who see the benefits of when to use OO over procedual is neither here nor there.

    Having developed in ColdFusion since it was V2.0, I have seen some major changes to the language and one of those is that it can be very easy to learn and very hard to learn in the same breath.

    ColdFusion has the added complexity that there are too many ways to skin the cat, or as you might say to get the job done. That would usually be a good thing, and is some cases it can be a bad thing.

    Twitter search #ColdFusion and you can see that the frustration of people wanting to learn ColdFusion ends up in well CF sucks.

    Some come to that conclusion because they try to apply current world methodology to an older syntax and it will not always work.

    Take examples of code and how to learn ColdFusion, someone pasts a ModelGlue example and someone else thinks it is so cool. But they use another framework, and its like how do I get it over to that framework!!

    ColdFusion has not made code to be very plug and play, and most if not all have to make a hard decision on what is best for them at the time. The hardest part is seeing something so cool, that you want to slot it into your application to only find out that it won't work in your Application without some serious modifications.

    This sort of post has brought out some of the bug guns, and its good to see that they can see the frustration on the author. But should we as a developer really blame a pattern, methodology or should we be looking at the tool?

    And by tool I mean ColdFusion in this example.
  75. Chris Says:

    Finally. The best response.

    Coldfusion is not a Java equivalent, nor should it be treated as such. Coldfusion is a complementary technology. If Coldfusion is lacking, then you can extend it through CFX by coding in Java or C#.

    The techniques to build a J2EE software application like Coldfusion are different than techniques for building a highly scalable web app in Coldfusion. Don’t confuse the two end products.

    Ben Nadel (under appreciated guru?) recently questioned the practicalness of being an OO purist in CF. As well suggested CF may be a framework in itself. Interesting and bang-on IMO.

    Coldfusion is great middle layer component-glue/service provider and should be treated as such. Procedural code does not have to equal spaghetti code. Facebook uses PHP in this way (remember the leaked code), and they know about scalable and refactorable systems

    The debate should be refocused back towards CF’s strength. Immediate productivity and supporting use & techniques.

    http://www.bennadel.com/blog/1587-CFM-Templates-And-Remote-CFCs-They-re-All-Just-ColdFusion-Page-Requests.htm

    http://www.bennadel.com/index.cfm?dax=blog:1547.view
  76. Ronny Karam Says:

    It's not just about CF. It's about every language that started as a scripting language, then evolved into a robust OOP language.

    The same thing happened when I tried to learn ActionScript 3. Migrating from AS2 to AS3 was and still is a problem. Yet the problem is in choosing the write programming method; if you're building a huge complex application that needs constant maintenance and evolves with time, you have to write in OO. But if you're building a 2 pages website that takes 20 mins in AS2 but takes 3 days in AS3... i prefer the procedural programming paradigm over the heavy OOP.

    It's a choice you have to make in the end.
  77. Chris Says:

    "Finally. The best response." was pasted in by mistake. Certainly not self-referencing.

    @Ronny, what do you mean complex projects need OO? Functions are a core part of procedural programing and CFCs can just be a collection UDFs (with some useful bonuses) without all the heaviness of java-like OO.
  78. James White Says:

    Marc,

    I feel your pain. For the past 3 years I have chased the ideas and concepts of OOP (especially as it relates to Java) thinking I would become irrelevant if I did not know how to code Java, then being a web developer it became necessary to learn JSP & Servlets. And since you need to learn the accompanying frameworks with JEE development, now you have throw in Spring, Struts, Java Server Faces, etc. and before you know it, you have spent more time "thinking" about the best option to take then you do actually building the application. The more I chased Java and the OO way, the less I liked programming and start doing other things (Business Analysis and Project Management). I was so blinded by the fact that that there were so many more Java jobs than CF jobs. Even though, I have never had a problem finding a CF gig. I realized that even though the CF gigs are not as plentiful, when people need you as a CF Developer, they really need you.

    Last July, I got back to CF development using just Coldfusion. I make use of CFCs, and the MVC pattern where appropriate, but I totally agree that all that boiler plate code just is not necessary in CF. The need for ORM and ColdSpring still escapes me. Maybe because I actually like writing SQL and think what you can do with CF and SQL (or it's variants like T-SQL and PL/SQL) is truly amazing. For Java Developers I totally understand wanting to leave SQL to boiler plate code, because there are too many other things to worry about. CF does not suffer from this problem (unless you add all the boiler plate code). I have coded CF since 1999. I go back to CF 4.0. Thanks for writing this article Marc, you have expressed frustrations felt by at least one long time CF Developer.
  79. Michael Steele Says:

    Marc,

    I can look back and remember when I felt just as you did. For me the epiphany came when I realized that there was HUGE difference between OOP, which you seem to be referring to, and OOD, which seems to get overshadowed by OOP when developers want to know the how to OOP and not the why you should OOP (or not OO).

    Many of the tenets of OOD don't even really say that things HAVE to be objects. :-) (Another post for another day.)

    If a programmer is capable of writing clean maintainable (subjective huh?) code that is completely procedural, then who am I to judge his programming approach.

    I personally solve most of my programming problems from a more OOD perspective. Yes, I can speak design patterns and can quote the teachings of Robert Martin, but it's not because I'm trying to turn CF into Java or be a pseudo-java programmer. I actually program in java when I need to be a java programmer.

    For me, CF offers the ability to code solutions in the way they I "think", from a more object oriented (note the non-use of OO) approach. And the beauty is, it still offers you the ability to solve problems in a way that is satisfying once again.
  80. Nando Says:

    Marc,

    There goes the baby with the bathwater.

    I understand your pain, especially the part about nearly losing your business. It's hard enough to keep up with evolving languages without having to deal with all the stuff that comes with running your own business. I've been there, and somehow came out the other end.

    To me, the use of OO constructs and frameworks in my CF apps involves a tradeoff. It's more complex, and at the same time it's more simple.

    For instance, the fact that I can call a simple function such as getTransfer().save(myTransferObject) is something that I just love. And that fact that I can do that consistently across the whole app is an enormous time and brainpower saver. A functionality is encapsulated and tucked away in a single method that can be reused again and again. Wonderful stuff, this OO!

    On the other hand, the price I've chosen to pay for this simplicity is that my application is divided into a more complex structure, that manages singletons and makes them available in the objects that need them for instance. That's a bit of an ouch, but I make the tradeoff. And I'm getting used to how these structures work, so it's less and less painful as time goes by.

    If you're anything like me, you don't like being confused, and you don't like feeling inferior because you're confused. I jumped into the deep end of the OO pool when Hal Helms came out with his CFC book and splashed around in design patterns and the heady concepts of OO for some time. I swallowed a lot of water and felt I was sinking. Survival instinct drew me toward the shallow end of the pool.

    I've found that I'm very comfortable at the shallow end of the OO pool. The use of objects and methods to encapsulate and reuse functionality is something that I take to, and I believe that's at the heart of object oriented programming.

    I wouldn't go back to a procedural coding style, and I doubt I'll ever be an OO architect fully immersed in design patterns. Because as interesting as that may be, nobody's paying me for that level of expertise. Economics dictates, to a certain degree, what I am able specialize in. So it's the shallow end of the OO pool for me, at least for now.
  81. Hal Helms Says:

    My take on Marc's post can be found at http://halhelms.com/blog
  82. Alistair Says:

    Very useful post and subsequent comments; it does seem to me though that the problem is not OO or frameworks, but whether or not to listen to the community. It's about confidence in the decision you're making for a particular project, and whether to ignore the nagging doubts that emerge because 'evangelist X is currently shouting about ORM this week and maybe that would reduce my dev time by 20%.. but on the other hand learning about it would increase it by 20%... but for this project only'.

    Assuming that you are never doing the best thing, but that you are doing one of the many available second-best things for this particular project, makes coding a whole lot more fun.
  83. Claudia Hoag Says:

    You speak from the point of view of a single programmer or a limited size team, working on limited scope projects. On an industrial scale, it might not be so true. Bunch of programmers and high turn over, a framework helps keeping it clean. But then, I believe that on an industrial scale, ColdFusion has a limited role - should be used for front end only, not business logic.

    And just BTW, do you really work with clean, well thought-out specs BEFORE a single line of code is written? Seriously. You should get over the "only code after specs complete" thing. There are established software processes that incorporate reality.
  84. Jay Says:

    Man, I agree with a lot of what you have said. I also believe that full OO can be done the right way.

    I have always long thought that OO in coldfusion is just plain ugly. A tag based language doesn't lend itself well to writing OO, imo.

    The most obvious example that comes to mind is the difference with java/python where you have to import all your modules at the top of your file. This is great when doing OO cause you know exactly where all the pieces are being connected. In coldfusion it usually involved traversing 10 to 20 cfc files until you figure out the base cfc that has the logic you need to change. To me that is OO spaghetti! Its no different that 20 nested cfinclude files.

    I have to give props to CFWheels. Although it needs to grow a little, I feel its a CF framework done the way the language was intended.

    /shameless plug- Long live Django! :)
  85. Andrew Scott Says:

    Claudia Hoag, you cant be serious with a comment like this.

    "ColdFusion has a limited role - should be used for front end only, not business logic."

    I would serioulsy rethink that statement before you get pounced on.
  86. Andrew Scott Says:

    Jay,

    Tag based? Business logic??

             //Check for mandatory fields
             eventLocation = "contact/dspHome";
             if(event.getValue('contactName') eq "")
                errString = errString & 'You need to provide your contact name' & '<br>';
             if(event.getValue('contactEmail') eq "")
                errString = errString & 'You need to provide your contact email address' & '<br>';
             if(event.getValue('contactMessage') eq "")
                errString = errString & 'Please provide a message' & '<br>';
             if (len(errString) eq 0) {
                emailObject = getMyPlugin('emailPlugin');


    Seems to have no tags in that code?
  87. Claudia Hoag Says:

    Andrew,

    I'm dead serious. Why not, because everybody else here loves ColdFusion? I've been working with ColdFusion for 11 years (since CF 3 just came out) and I'm dead serious. I currently work in a ColdFusion environment with tens of developers, including off shore, and I'm more serious than ever.

    And another thing: what's with the pride of "my code" versus "someone else's code"? You want to leverage on what has been done, already. I agree with the lack of support that some existing code might have, but that's not always the case - so you have to choose your tools and your add ons, but you won't go as far if you rule them out.
  88. Andrew Scott Says:

    Well then let me throw this back at you then, asp.net is only for front end. PHP is only for front end, because neither has the capacity to do anymore or less business logic than the other.

    And seeing as there are some very heavy Intranet Applications running all 3 seems a bit of a strange statement to make.

    ColdFusion can do as much business logic as the next language.
  89. Jay Says:

    Andrew:

    Are you seriously pulling the cfscript card? Come on. You can't do 90% of ColdFusion using cfscript and you know it.

    That wasn't even my argument. Don't get me wrong, I generally love CF. I have been using it since version 5.

    All I'm saying is they way CFCs are made, it makes it extremely difficult to figure out what is going on. At any point in the CFC I can create another object to another CFC. That CFC can have 5 other objects created inside them which also extend other CFCs which also extend base CFCs.

    Wow! It would take me quite a while to figure out whats going on without A) Very good documentation, or B) They guy who created the code sitting right next to me.

    In contrast, it is really easy for a OO programmer to look at a python, c#, or java file and know fairly quickly what is going on.

    No one can debate that.

    Hopefully centar helps with this, but I'm afraid that even though we will be able to create CFCs using C style syntax, it still will be a nightmare figuring out where all the connected pieces are coming from.
  90. Claudia Hoag Says:

    .net or Java for back end, ColdFusion for front end, perfect marriage.

    ColdFusion is a scripting language, .net is an OO language. You can surely turn this backwards, but that's not using the best of each one.
  91. fsilber Says:

    Jay wrote: "A tag based language doesn't lend itself well to writing OO, imo."

    I agree. Unfortunately, as Andrew Scott pointed out, this is true whether you embed logic amid tags, or have programming language functions create strings of tags.

    Object orientation is extremely good and extremely important, but to use it you have to get away from tag-based notations. This rules out not only ColdFusion, but HTML in general -- and thus most web frameworks for _any_ programming language.

    You can virtually eliminate HTML by using Java WebStart or Applets, but these have their own deployment problems. You can avoid working with HTML by using Java APIs that compile into HTML/Javascript/CSS -- e.g. Google Web Toolkit or Echo2. Or you can use Java with Wicket -- which keeps HTML well segregated from anything so much as resembling an `IF' condition.

    Rest assured, the heartburn you suffered trying to make your ColdFusion applications OO is being suffered by developers trying to use object orientation with Java Server Pages, Java Server Faces, ASP.NET, etc.
  92. Andrew Scott Says:

    Jay how much do you want to bet?

    90% of my code is cfscript these days, and with the release of CF9 it will be 99%.
  93. fsilber Says:

    Claudia Hoag wrote: "ColdFusion is a scripting language, .net is an OO language. You can surely turn this backwards, but that's not using the best of each one."

    That's a meaningless distinction. Scripting languages can be as object-oriented as any other programming language. The only difference between scripting languages and .NET languages is the kind of type-checking (static versus runtime) and the degree of pre-compilation. The very first popular OO language was Smalltalk, which had runtime typechecking and was interpreted -- just like JavaScript and Ruby.
  94. Claudia Hoag Says:

    fsilber, you're right, it's not for being a scripting language that ColdFusion is not an OO language.

    But it is not an OO language.
  95. Andrew Scott Says:

    But the point is that I mentioned asp.net, not .Net.

    The other point is ColdFusion is more than capable of running Business Logic, whether the business logic is Domain Driven or Business flow.

    But to say because it is tag based (as I can show you in many examples, there are many things than can be done in script not tags), that it can't lend itself to doing Busibess logic is pure and simple wrong.

    Sure until cf9 is released there are some limitations to the script, that one needs to write a wrapper for. But hey I can still do it in script.

    Now ColdFusion is not considered an OO language by default, but it can behave in an OO manner if writing correctly.
  96. Andrew Scott Says:

    ColdFusion might not behave like an OO language.

    But I can do this, which is an OO concpet is it not?

    <cfset myString = "sales_2356_89_3" />
    <cfdump var='#myString.split("_")#' />

    Notice the method called split on the string, let me guess string is an object. If it wasn't then I couldn't run that objects method called split then...

    And that behaviour is only availabke in OO languages:-)
  97. Claudia Hoag Says:

    No. Using objects or having objects doesn't make ColdFusion OO.

    Encapsulation, interfaces, inheritance, it's all limited in ColdFusion.

    Not to mention the way it loads stuff in memory on each page request. It's like recreating the World.
  98. Robin Says:

    Thanks for your post; I really enjoyed your perspective. Clearly you've drawn your share of fire from the comments you've made here, and I don't necessarily agree with your views on OO either, but that's not the point. There are benefits to both procedural and OO design; DESIGN is what's really important here, not PROGRAMMING.

    I don't know anything about ColdFusion, but I know that it doesn't make sense to treat an apple like an orange. I've seen plenty of egregious abuses of OO technology, resulting in exactly the kind of cryptic, overconfigured monstrosities you describe. However, I've also seen OO design principles used to create very elegant solutions where I had previously thought OO would be completely unusable or irrelevant.

    OO can a very empowering way to solve problems with software - but not every software solution can be modeled after the real world. Many solutions that CAN be modeled after the real world don't NEED to be, and not every development environment will let you do so anyway.

    The bottom line is: take what you need and make your professional way using tools that work for you. Software problems get solved with knowledge and tools, not with religion.
  99. Sean Corfield Says:

    @Jay,

    "All I'm saying is they way CFCs are made, it makes it extremely difficult to figure out what is going on. At any point in the CFC I can create another object to another CFC. That CFC can have 5 other objects created inside them which also extend other CFCs which also extend base CFCs."

    Can you explain how that is a failing in CFML but not a failing in other OO languages?

    Seems your criticism applies to *all* OO languages. Could you try to explain that objection better?
  100. Marc Funaro Says:

    I have to agree with Sean on this point, and ensure that this reader's comments do not represent my own opinion: It's not the CFCs themselves that make things "difficult to figure out what is going on...". It is the nature of OOP, especially poor OOP, that can create that type of complexity, regardless of the language used.

    I will take this opportunity once again to thank everyone for their input on this controversial post. I am in the process of creating a follow-up post, as previously promised, and I hope you all will help in keeping this conversation going.
  101. Sean Corfield Says:

    "It is the nature of OOP, especially poor OOP"

    I don't agree that it is in the nature of OOP in general, just poor OOP. Well-written OOP code should be extremely readable and should make it very clear what is going on - just as well-written procedural code should. It's all about proper naming of variables and methods so the code reads like English.
  102. Frank Silbermann Says:

    Indeed, if a program is well designed and well-written you normally shouldn't have to trace all the method calls that result from a method call. You just look at the class name and the method name and understand that which is being accomplished. If it's not where the change needs to occur, you're supposed to be able to ignore the details.

    It's the same principle as in functional (top down) decomposition and abstract data types that everyone taught before OO. The only difference is that now we can decompose programs on the basis of APIs and interfaces implemented, rather than on the implementation itself.

    It's usually a better way of programming, but not in a small program written in a language that makes you implement the object oriented framework yourself. For example, I wouldn't try to implement an OO design in Assembler Language or, worse yet, in enhanced HTML -- which is the nature of Cold Fusion (and most other web tools, such as Java's JSP).
  103. Sarah Kelly Says:

    Marc conveys the frustration that many of us feel. The responses convey the complexities of the issue and the thoughtfulness (usually) of the community. I am especially interested in and made some comments about the 'lone programmer' issue that Sean Corfield mentioned in #65.
    <a href= "http://endcfloner.blogspot.com/">http://endcfloner.blogspot.com/</a>;
  104. Sarah Kelly Says:

    oops, I guess the blog auto-converts those http://s. i'm sure you can figure it out, but for convenience...
    http://endcfloner.blogspot.com/
  105. Gerald Guido Says:

    This is a great discussion. I am much like Marc Funaro. I have a couple of BA's (Psychology and Human Development) was on a career path to become a College Prof in clinical/social psych when the Internet grabbed my imagination by the short hairs and wouldn't let go. I got my first PC in 95 and was employed as a full time "web master" two years later. I an extremely passionate about and absolutely love web development (and CF) and I cannot see myself wanting to do anything else (except maybe a college prof ;o)). I am very lucky (like marc and many of us here) in that I LOVE what I do for a living. I would probably not be a programmer if it were not for CF. It allowed to to overcome my learning disabilities and dyslexia (syntax used to really mess with my head - think bad spelling except for code). Now that I understand the concepts made simple by CF I was able to pick up other languages; ASP, PHP, JS etc. a lot quicker. And now that I have got some CFOO under my belt, I look at PHP and Java that used to make me feel really stupid and realize that I "get it" now.
    Instead of going "Duh"... light bulbs are starting to off like the photograph flashes at a Hollywood red carpet event.

    Look. OO is hard. I got into an awful bout of analysis paralysis when I first immersed myself in OO. For a while I was flat out stuck and I even turned down an offer from a well-to-do friend to start a side company (even though I would get paid for my development time) because I felt that in order to do it right it needed to be OO and I felt that I was "not ready". Pretty stupid huh?

    But make no doubt, there is LOT to learn and many OO concepts are abstract at a rather high level, and in many ways, not too far off from philosophy as far as being nebulous and abstruse. It is very easy to "think yourself stupid" (given the tremendous amount of information to digest) as Marc, myself and many others have when first grappling with OOP. I can honestly say that I have spent more time and concerted, focused effort into learning OO, frameworks and related concepts than I have learning any programming language, even my first two (CF and PHP).

    In psychological terms what Marc is describing is very much akin to what is known as cognitive restructuring http://en.wikipedia.org/wiki/Cognitive_restructuring and it is NOT an easy thing to do psychologically, cognitively or emotionally. It literally challenges and brings into question the very core of what you know to be true. In simple terms (and one of my favorite phrases) "everything you know is wrong". An when the very foundation of the world as you know it, is challenged, brought into doubt and maybe even flat out WRONG it causes cognitive dissonance which in turn can cause a great deal of anxiety. ESPECIALLY when it comes to ones perceived competence and self worth as is the case here. Wikipedia described what happens when one experiences cognitive dissonance:

    http://en.wikipedia.org/wiki/Cognitive_dissonance

    "Noticing the contradiction would lead to dissonance, which could be experienced as anxiety, guilt, shame, anger, embarrassment, stress, and other negative emotional states.

    Now tell me that this is not what is happening here. Make no doubt about it, this is some pretty heavy stuff and it will (in scientific terms) "f#ck with your head".

    There can be a great deal of peer pressure in the various tech communities and the herd-ish nature of our geek brethren has been well documented on the internets in the form of holy wars, the open sores trolls at ZDnet and Slash dot Karma whoring. But as with many psychological ans social constructs and phenomenon, peer pressure is a nuanced thing and is full things like shades of meaning, tone of voice, innuendo, inflection, intonation and other nebulous psychological constructs that one cannot point a finger at a singe concrete example and say look... right there, do you see it? THAT, RIGHT THERE, is a zeitgeist, or peer pressure or envy, or love etc. None the less they are all very real, palpable or not. It is like when you walk into a place and you get the feeling that you are in the wrong place and that you should probably bolt with a quickness, kinda like the guys in the movie "Easy Rider" felt when they walking in to that Diner or when the Guys from "Animal House" found themselves in an all black bar. You just feel it and it is difficult to point to a single instance or example of how or why you felt that way.

    But make no doubt, a central zeitgeist in the CF community (and others) involves the pressure to move toward OOP. It is something that we are supposed to be doing, like how my grandmother, my aunts, my cousins, friends etc think that I am supposed to be married by now, and that since I am not I feel like I am doing something wrong. Because, you know, I am supposed to be married by now. Totally irrational but at the same time, totally human.

    http://en.wikipedia.org/wiki/Zeitgeist


    The pressure is there, no doubt about it and it is VERY real and it is messing with peoples heads. You are not alone. Even Michael Dinowitz from Fusion Authority blew a gasket a few days ago and went off on
  106. Gerald Guido Says:

    It seems that my comment was cut off.

    Here is the rest

    The pressure is there, no doubt about it and it is VERY real and it is messing with peoples heads. You are not alone. Even Michael Dinowitz from Fusion Authority blew a gasket a few days ago and went off on this very subject. My father who likes to think that the status quo is just hunky dory would poo poo things like this and say there was not really a problem and it was "a few activists making a big stink". But he watches too much FOX news. ;o)


    Now what really kills me is that According to Hal Helms even the CFOO GURUS got it wrong. No really. According to Hal Helms not even the gurus in the CF community know WTF they are doing when it comes to OOP and EVEN WORSE they are spreading misinformation and as a result the ENTIRE CF COMMUNITY is pretty much fuct when it comes to OOCF.

    http://www.fusionauthority.com/views/4774-hal-helms-makes-it-real.htm

    Yeah... it is pretty messed up state of affairs.

    In short Marc. I feel ya brother. ;o)
  107. Jonathan Knapp Says:

    Excellent post!

    I love to read articles about how programmers think and WHY they think they way they do.

    As a devote lover of programming it is great to read some of the opposing sides to the piles and piles of theory that I uncover everyday and have to decide if I have enough time/effort to invest in them. (not specifically pointed at OO, Java, or CF)

    Thank you very much for sharing, and for a different point of view.
  108. Brian Knoblauch Says:

    As a long time procedural programmer, gone OO in the last few years, I agree. Go with what gets the job done best. They don't pay you based on the technology you use, it's based on the result.

    As an interesting side note, I consider classic ASP to be procedural and I have a real rough time working on it now that I've got so much OO time in. Years ago, it would have been easy, but once you make the shift, it's very hard to go back. Once I realized that, I decided to give up on learning functional programming... I can't afford to shift to functional when 90% of the demand on me is OO. :-)
  109. Jay McEntire Says:

    Some additional thoughts that I finally got around to posting-- http://bit.ly/1XoI8F
  110. amclean Says:

    If i could agree more than 100%, I so would.
  111. George Murphy Says:

    @Marc, I share your thoughts and feelings in regards to some of your perceptions related to OO. I agree there has been this tremendous push to move all ColdFusion developers to the use of frameworks and OO frameworks in particular. The problem I have with all of this Adobe does not seem to be on board with this officially. The big problem I see is a lack of books and enough good training to bring everyone on board. Sure there are blogs and lots of things on the internet about this subject; however, if you want new programmers and people new to OO to adopt this Adobe has to open up its wallet and get some training at the university level. Microsoft has been there with .NET for a long time. I know that Adobe has assigned someone to do this; however, where is the Adobe site telling folks where they can go to take a 16 week Object Oriented ColdFusion class. If it is there can someone please post? I know there is the occasional class at places like cfobjective and cfunited. That is not enough. Furthermore, can we please have something along the lines of Learn Visual Studio? http://www.learnvisualstudio.net
    500 videos on the .NET framework that is impressive. The average length of each video is 40 minutes. Unless we step up to the plate and teach our language better we will all be forced to hear this rubbish about how ColdFusion is a language on its way out. I do not want this to happen, I love ColdFusion. So, if there is anyone in a position of power to change this I would love to discuss this further. I am speaking of folks like Adam Lehman, Ben Forta, and Tim Buntel.
  112. Pardeep Says:

    I too used fusebox until it upgraded and I had to load hundreds of lines via the browser before getting a response to a simple query.

    Furthermore, it took me more time to figure out what the _uck was going on if I forgot what I'd done in my switchbox. I hated those weird URLs too vs just opening a page and editing it.

    So I took the best of Fusebox, the naming conventions for files, qry_, dsp_, act_, separating display for function and putting each app in its own modular folder.

    Its simple, it works, it lets me enjoy my work and get it done fast.

    I think of the frameworks are just _sshole wanker eggheads adding more complexity without any pragmatic need for it.

    Its like those corksucker attorneys who get all this legal training. Then they take their sorry asses to DC and make a ton of new laws to _uck over the rest of us. They have to make new laws to justify their small dick existence due to all this legal training.

    I'm going to give CF on Wheels a shot though, although I'm skeptical about frameworks and OOP for the most part, they add more complexity and lose time without any rational reason.

    Most of my clients are small to mid size biz with websites that will never scale to huge traffic. So OOP and this framework stuff is bullshit and overkill.

    Good post. Death to small dick egg heads who add complexity without any pragmatic real life real world payoff.

    And _uck the eggheads who differentiate between a coder making a living with Coldfusion vs some small dick who got a degree in computer science.

    If you're coding and making a living at it, you're a developer. End of story.
  113. Jen Says:

    I would have never used an MVC if a programmer where I worked hadn't quit and left a rather large Model-Glue application in my lap.

    I was lost. Even though I was competent with CF, I just couldn't wrap my head around it. Not until...

    I built an app from scratch in MG. I did this on purpose because I was drowning in this MVC and had no where to go for help. Then it slowly, slowly, slowly dawned on my how this stuff worked. Now I love it - for large, complicated apps. Smaller, ad hoc stuff works great with plain vanilla CF and CFCs.

    I got lucky. I had the time to learn it. And, now I have one more option for how I want to approach a CF project.

    Right tool for the right job.
  114. Mark Says:

    I cant comment on Coldfusion but OO is the building blocks of C++,# Java and it really is intuitive for people who think that way.
    The Golden rule: Only use what brings value to your project, no person, entity/company in the world, uses every principle in OO, That is not the purpose, I am sorry to say but you are not getting the point. I would try to ask you to Abstract, Encapsulate, Modulate and hierarchy but I dont feel you can think along those lines. Let me ask you this?
    What you are saying is the equivalent of someone saying they hate Microsoft Word because for every article they write in word, they have to use every function and I mean Function word offers (Function is F(X) here.) Thousands of them.
    Now do you grasb?
  115. Michael Says:

    To the author of this article, your entire thinking is flawed, I agree with Mark just above me, Coding is something we are born with and I am very concerned that you fail to see the picture and cannot compartmentalize concepts. I need to ask you something, How well to you write arrays and pointers? How comfortable are you with them? I am awaiting your feedback.
  116. Marlon Says:

    I fear the day when scientists are able to isolate the "object oriented programmer" gene. It will lead to a eugenics nightmare of parents aborting their children because they've only got the "procedural programming" gene.

    Michael, are you being serious when you say "coding is something we are born with" ?
  117. Michael Says:

    Marlon: Am i serious? Yes and No.
    Obviously certain people are wired differently at birth, for example, I would never be able to be a musician or and artist, my brain was never wired that way. Other people might have a tendency to be better at math and sciences.
    No: By no means I am trying to say that there is a programming or OO gene :)

    But Marks analogy(3 posts above) is 100% on target.
    Imagine writing a letter congratulating a friend on his newborn.
    Now Imagine having to use every font, color, & function in the toolbar and every possible option MS word offers in writing that a couple of lines.
    and if you dont use everything, you feel guilty of not using Microsoft word or you get accused of not being able use MS word.
    This is exactly what the author is trying to say. Please understand, I am not trying to belittle him in any way or be offensive, but his abilities and thought processes are very flawed.
  118. Sandeep Chakra Says:

    What Mark and Michael are saying is very true. Education system in U.S.A is very poor and what author is happy with being able to do is work that 13 year olds learn abroad.
    Author would never survive in real environment, in ANY industry, think of Patriot missile system or Boeing Avionics, or Wall Street trading system, they are all OO and would have failed if otherwise. OO principles are part of the fabric that exist in nature.
  119. Marlon Says:

    I think the author's analogy is more like:

    If you're using word for an essay and you want to add some illustrations, do you use words built in graphic tools, or do you use an application that's more centered on graphics.

    I also don't think the author is making a blanket statement that OO isn't needed. He's making a statement that OO isn't need in ColdFusion, of which I agree.
  120. Mark Says:

    Now, I feel bad, I hope I did not start something negative here. I apologize to the author if my post was offensive in any way shape or form.
    But based on the bold
    "There comes a time in the history of every project when it becomes necessary to shoot the engineers and begin production."
    I am both a lead developer and a senior systems engineer and we all know that mistakes can cost up to 1000% more if they are discovered after production.
    In mission critical projects, they cost you lives when things are not thought of or certain scenarios and architectural views are ignored.
    I guess working for Google on the search engine has distorted my frame of reference to different kinds of projects.
  121. Pat B Says:

    Holy crap this was one of the best articles I've read in a while. My neck hurts from nodding for 30 minutes straight. If you are going to Max I'll buy you a drink just for the fact that you made the post I've always wanted to write. Excellent.
  122. Goyuix Says:

    A better title for the blog post would be "How trying to do OO in ColdFusion almost destroyed my business" - but that would probably sound really bad to the CF faithful. It just isn't a really strong point of the language - and that is not a bad thing. Use the right tool for the right job. Example: OO can be particularly useful if you are building a framework. It generally isn’t that useful for rendering the page to the browser. Use it where it is appropriate.
  123. Sunil Senadheera Says:

    Great insight. Hype of OO and Java in particular has taken the industry for a ride in about last 10 years, which in itself self-destructive. Essentially we've increased software development costs with these convoluted frameworks making IT expensive overall.
  124. fsilber Says:

    Sunil Senadheera, don't blame the hype of OO and Java for the increased costs and convoluted frameworks; blame the non-OO nature of HTML itself and the consequent difficulty of building a decent OO framework around it. A few decent ones do exist (Wicket, GWT, Echo2) and make web application development cheap and efficient (if you know Java and OO), but they're not the way most HTML monkeys are used to working.
  125. Emmit Says:

    HTML monkeys?

    Do have to practice being a condescending douche bag or does it come naturally.

    >>blame the non-OO nature of HTML

    WTF does that have to do with anything?
  126. ToEmmit Says:

    The non-OO nature of HTML makes it exceedingly difficult to use OO techniques in web development. It's not a fault of Java -- Java is not responsible for the non-OO nature of HTML. It's not a fault of OO theory -- OO theory is not responsible for the non-OO nature of HTML.

    HTML-monkeys? That's just referring to people who don't resent the non-OO nature of HTML/XML/CGI and who aren't eager to organize their projects on some basis other than (enhanced) HTML pages. (GWT and Echo2 abstract away the HTML; Wicket merely compartmentalizes the HTML and makes it subordinate to the Java code -- as it should be.)
  127. Emmit Says:

    >>> The non-OO nature of HTML makes it exceedingly difficult to use OO techniques in web development.

    IIANM the the original post made reference to that notion.

    >>HTML-monkeys? That's just referring to people who don't resent the non-OO nature of HTML/XML/CGI and who aren't eager to organize their projects on some basis other than (enhanced) HTML pages.

    I see that being a condescending prick comes quite naturally to you. You may be missing the point.

    Personally I don't resent mark up not being OO. That is like resenting water for being wet. It is what it is.
  128. fsilber Says:

    Yes, HTML is what it is. That's why it is difficult to build OO web applications with most frameworks. That's why most web applications written in easy-to-use frameworks (such as old CF) are unmaintainable crap.

    That's why people who build web applications _should_ resent the non-OO nature of HTML, and should embrace frameworks that solve the problem. ColdFusion with OO editions are not the solution. Neither is Java with JSP/STL/Struts/JSF/etc. Neither is Ruby on Rails. Neither is ASP.NET (whether WebForms or MVC).
  129. Emmit Says:

    >>ColdFusion with OO editions are not the solution. Neither is Java with JSP/STL/Struts/JSF/etc. Neither is Ruby on Rails. Neither is ASP.NET (whether WebForms or MVC).


    I would put PERL, PHP, Groovy, Grails and Python in that mix too.

    Well, that pretty much accounts for ~ 98% of all web development. Ya think?

    So we are all pretty much fuct, except of course, the "enlightened" people like you.
  130. Jen Says:

    Not everything can be or should be OO. It's overkill at times. Point made.

    I backed into OO because I had to and I'm glad I did. Now I know when to use and when not to.
  131. fsilber Says:

    Emmit wrote: "Well, that pretty much accounts for ~ 98% of all web development. Ya think? So we are all pretty much fuct, except of course, the "enlightened" people like you."

    No, I'm fuct too, because in most jobs I have to use whatever tools everyone else is using. I can hope that these better tools become popular, but that could be as vain as hoping that businesses in the early 90s would switch from Windows 3.1 to the MacIntosh.

    Jen: "Not everything can be or should be OO. It's overkill at times." Exactly, just as using structured programming instead of the GOTO is overkill at times, or using function/procedure subprograms instead of a single module is overkill at times. It ceases becoming overkill when you find yourself doing the same kind of thing more than two or three times. And even then it's often overkill when you're stuck with a crappy OO framework that facilitates making only a portion of the application logic OO (e.g. Java/JSP/STL/Struts).
  132. Slap Daddy Says:

    Dude, you have got to be my twin brother or a freaking mind reader.

    My self-confidence has been blown out the door because I am not up on the OO lingo or have fallen behind playing framework bingo.

    I am running my butt off trying to keep up with all the latest CF fads while the rest of the world seems to be running 100 times faster than me. It is as if I spend more time studying how to speak the latest buzzword terminology instead of writing something productive in CF.

    It's a good thing I don't work for the U.S. Postal Service otherwise some people would be hurt right now...mainly due to my sheer raging frustration of being seemingly inadequate in my CF profession. It really pisses me off!!

    Your article has brought me hope, encouragement and a renewed desire to go write something good just for the heck of it. ColdFusion will be my object and the tags will be my methods...how's that for OO?

    Thanks new twin!
  133. grapeshot donkey Says:

    you want some cheese with that wine?
  134. Concerned CF Citizen Says:

    Take a look at how many OO langauges are thriving compared to the number of procedural ones. That should be a clue.

    This blog entry embodies everything that is wrong with the CF community.
  135. ike Says:

    I've been a bit hesitant to reply, not because I felt it was a sensitive subject, just because there had been so many replies already. What could I add? Personally I think that cognitive science is actually more important in software development than computer science. And I think that cognitive science has a lot to say about these kinds of tendencies that we have as programmers, because in a lot of cases they're the same kinds of tendencies that people have in general, irrespective of programming. For example there's a concept of "the magic number 7, plus or minus 2", which is a rough measurement of what a person is able toe asily remember. It seemed coincidental or arbitrary that phone numbers tended to be 7 digits, but when you understand that this is the limit of arbitrary numbers a person can easily remember, then it makes perfect sense. I think it's unfortunate that as an industry, software development seems to take little consideration of these kinds of well-known human factors.

    For me personally I often find that the developers of other frameworks describe simple concepts in very obscure language. And when that's the case, I can hardly blame people for being confused. People should use plain language whenever possible, instead of resorting to phrases like "application bootstrapper CFC enhancements" for example, which was used in the Mach-II roadmap to describe adding the ability for modules to execute code when an application starts or ends. And after a survey I did several months ago, I realized that I'm more guilty of that very thing than I realized, because I would say things to people like "service oriented" or "aspect oriented programming (AOP)", thinking that these phrases would get people excited. The survey showed me that they don't, because most people aren't familiar with the terms, in spite of the fact that the terms often describe what they actually want. So one of the things I'm working on now is to change the way I describe my work to be more straightforward. Instead of talking about SOA for instance, I talk about how the onTap framework's plugin manager makes it easier to borrow applications from other developers. This fits nicely with my overall objective of making software easier to develop in general.

    I think too that this tendency to describe simple things with very complex language is part of the reason why all of us who do this for a living seem to have difficulty separating the theory from the code. It seems like every time I give a presentation, somebody asks a question that's all style and no substance. For example my DataFaucet ORM includes a custom tag to make it easier to configure it and when I gave a presentation on it, someone asked if they had to use the custom tags. It's true they don't have to, but there's no particular reason why they shouldn't, because that has nothing at all to do with writing good software. It's just another example of how habits and social pressures result in a kind of OO-Nazi attitude in which custom tags somehow become evil because they're not OO, despite their ability to make things easier.

    I do like OO. I strive not to be an OO Nazi though. I think I have a bit of an advantage in that I don't have a Comp-Sci degree and so I didn't come from a Java background. In cognitive science (no formal education there either), we learn that things we've learned before compete in our brain with new information. So there's a paradox where a person with lots of Java background actually has difficulty doing things that are far easier like ColdFusion because they're so accustomed to doing things the hard way. The hard way that they've already learned competes in their brain with the easy way and often the hard way wins.

    I disagree that OO is "half-baked" in ColdFusion. I think that's confusing the theory with the implementation. Speaking of which I had a pretty popular article on the DataFaucet blog about that titled "Is This OO (Enough)?" in which I was expressing my own frustrations with OO Nazi's complaining about things like the lack of abstract classes or the fact that CFCs are heavy compared to Java. These also often being the same people who run off and make anemic domain models, which is the opposite of what OO was created for. These things they complain about don't make OO in CF "half-baked", they only make it different. By the same token, Sean Corfield recently pointed out that CF makes it dead-easy to create singletons, whereas the same thing is very complicated in Java. So you could apply the same argument in reverse, that Java's OO implementation is "half-baked" because you have to do back-flips to get a singleton.

    So although I disagree with some of your comments, I definitely appreciate your frustration. I have some of the same frustrations with OO nazi's. Software needs to be easy and practical first - if we can get elegance afterward, that's a bonus, not the other way around. :)
  136. Trevor Burnette Says:

    I have been using a modified framework for years, I wrote 1 app using an OO framework. It took way to long to write, debug, and was way slower to execute than our other apps. That was the last time I used an OO framework.

    I do think java objects are very valuable to CF programmers. I once had a cffile write that took 35 minutes to complete due to the large size of the transaction file. I used cfobject and java for the write. It executed in ~40 seconds. That is the beauty of CF, use tags to quickly write code and use more complex code methods only when needed.
  137. Saul Says:

    Spot on for me. As a non-pro hobbyist who occasionally has been paid for creating a web site, and who's been with CF since ver 3 , I've just spent 2 weeks trying to get my head around frameworks and OO because I felt I "should". I would have had my next app substantially written by now. Thanks for giving me the confidence to just "do it" and not use a framework (not to say that I'll be ditching trying to be organised and consistent).
  138. Web Design Manchester Says:

    Jeez, that is some hard hitting home truths right there-feel for you man.

    Web Design Manchester.
  139. Red Ninja Says:

    Good stuff Funaro. It's kind of funny how the things got off topic like "education system in the U.S. is bad" or "writing pointers in ColdFusion". (There are no pointers in ColdFusion.) It just made me laugh.

    A little bit background info about myself, I started programming with Fortran 77 and Assembly (<< speaking of pointers) back in the day. I took Java classes at school, and self thought ColdFusion MX 6.1. I have been working with ColdFusion since 2002 and was introduced to CF framework at my second job. (Man, I wish I could go back to my first job to fix all the f-ups I caused). They had two main applications: one in Fusebox 3 and the other in Fusebox 4. I gotta say, I liked how things were organized in Fusebox 3. Fusebox 4 was another animal. I could see the suffering of the fellow programmers each day. Trying to debug an application was a major headache. Since then, all the applications I worked on had or have their very own in-house made framework. Important to note, they still managed to separate business logic from presentation layer, which I love doing.

    I have been looking at getting back to using some kind of a framework. I looked at a bunch out there. To me, it doesn’t matter if you are working alone or in a team environment. I like having things organized.

    I installed ColdSpring - Model Glue several weeks ago. When I run one of the samples "Rich Widgets", I was horrified when I saw the amount of templates in the ColdFusion debug and noticed a 3735 ~ 5600 ms of load time. This is currently running on localhost by the way. Why so much overhead?

    The thing that grinds my gear the most is when they are using their own functions like:
    redirectTo() . It makes me think WTF? You are not supposed to reinvent the wheel, right?

    @Kwiatkoswki.
    Totally agree with your points.

    @Nando
    getTransfer().save(myTransferObject). You don’t need a framework to accomplish this.

    @Guido and @Murhpy, Maybe Adobe needs to take some kind of ownership and provide some guidance. Going back to very of my own problem, I don’t really care about your sh1t like redirectTo(). What if 2-3 years down the road, I want to migrate to another framework? What a pain it will be to strip out all these functions!

    I think maybe ColdFusion needs something like RoR (No not ColdFusion on wheels @#$#@R$@). Check out Hal Helms blog about why he likes RoR? A fast way to develop applications, put joy back into programming, and other littler things.

    Aren’t we all asking for these in the first place.? (Funaro, me or others)
  140. Jeff Says:

    OMG Marc, thank you, thank you, a million times thank you for writing this post! You expressed everything I have been secretly thinking, but too afraid to say out loud to anyone. All my best work has been straight up SQL queries or stored procs with data moving in and out (using forms, usually). I read these things about managing 100s or 1000s of objects and ask: Why? It usually just isn't necessary. My idea of OO was having a CF for CFMAIL, or one for some other shared functionality. And I found even then your start and finish is usually a cfm page anyway....so why do I need the headache of learning about DAO and Gateways and Beans. Because I'm SUPPOSED to, said the gurus. Yes, it is nice to have this stuff in the tool bag. But much of the time you DONT need it. And that is your point and mine. And I run into more and more devs who secretly confess the same thing. Some dont even use hibernate, coz their SQL queries just fine.

    Please God - let us think for ourselves!!!
  141. Arowolo Says:

    On a regular day i wouldn't read blog post as lengthy as this, but the title caught my attention anyway.

    Just like you i run my own show(have my own company), I started programming at an early stage in life(17 years) with Desktop programming tool (VB 5) and HTML.

    view my response at http://cfmlx.blogspot.com/2010/02/how-oo-almost-destroyed-marc-funaros.html
  142. ali syed Says:

    thank you for the advice and a wonderful read!
    cheers
  143. Blue Sun Says:

    E. Martin (post #6) was punked by a hoax interview with Stroustrup. I'm a member of IEEE Computer Society and, as soon as the hoax started to circulate in 1998, I checked my recent issues of Computer (though I was 99.9% sure it was a hoax). In the June, 1998 issue of Computer, Scott Hamilton of Computer wrote:

    For the past few months, a hoax
    interview between Stroustrup and
    Computer has been making the rounds in cyberspace. While we regret the incident, it offers us a welcome opportunity to have the father of C++ share his insights on Standard C++ and software development in general. We can also attest to his continued sense of proportion and humor—he suggests that the fictitious interview would have
    been a much funnier parody had he
    written it himself.

    —Scott Hamilton, Computer

    An article entitled The Real Interview With Stroustrup about C++ is in the June 1998 issue. Since non-members have to pay $19 per article for downloads, I am posting a link to the entire interview that has been listed on an AT&T research site:

    http://www2.research.att.com/~bs/ieee_interview.pdf

    Geez Louise, it still amazes me that there are so many goobers out there who fall for these endless hoaxes.

    In the early days (pre-web and pre-AOL), the internet community was mostly intelligent, LITERATE, professionals in computers or science. The quality of discussion on newsgroups and email was extremely high - written mostly by people who were not only intelligent, but who spoke (or wrote) in entire paragraphs.

    Having been on the net for 28 years now, all I can say is that you have to do a lot of careful digging to find the wheat among the chaff. The S/N ratio is unbelievable. The same thing happened to TV, I'm told, when it became cheap and available to the masses. One year the brilliant Sid Caesar of "Your Show of Shows" and "Caesar's Hour" (with writers like Mel Brooks, Woody Allen, Neil Simon, Carl Reiner, and Larry Gelbart) was dominant in the ratings. The next year, he was knocked off by the Lawrence Welk Show. The TV equivalent of AOL had arrived.

    Sheeeeesh...
  144. eric Says:

    Thank you. I too felt if I don't learn every bit of technology I will not be qualified for a job in the future. But then I look at the hundreds of basic html, cfml, and php sites I have out there that are still clicking and their owners can go in and make changes easily. I'm not sure I'd ever want to try to teach the owner of a landscape company the complexities of a framework.
  145. Aaron Greenlee Says:

    So, about a year ago I posted on this thread. Since then, I've gone all into the OO.

    I won't be coming back.
  146. Michael Says:

    thank you so much Marc, you express my unease with the OO trend much better than I could have done it myself. It feels good that I'm not the only one who feels like this!
  147. Jon Wallen Says:

    What an awesome article...I have studied a couple different frameworks and while I liked Fusebox 3.0, I have yet to develop an application on a framework...I don't much care for the new Fusebox). Somehow it's just easier and more empowering for me to write straight-forward simple code that can be used anywhere, rather than use a framework. Using a framework tends to put people off because they have to go through a learning curve before they can even start programming. One thing I don't get is the recent attitude that some people have: "I have to build my application on a certain framework or it's no good!"

    Please, CF doesn't need a framework to make it easy to use. That's why it's so awesome.
  148. Tom Minderson Says:

    How about a representative sample application be developed using OOP and non-OOP styles, say a college class and grade tracking system, and then throw several realistic change-scenarios at both code bases, and see which one is easiest to change in terms of modules, functions, and lines of code that needed changing. Theory and anecdotes only go so far. Time to science up. Also, multi-paradigm is growing in popularity of late. It may be an issue of what PARTS to make OO, not whether to "go OO". That is a wiser approach in my opinion.
  149. Heather Says:

    Thank you for speaking for me! I, too, am a musician who graduated from college in 1992. I started down the path of ColdFusion programming in 1998, and I STILL use CFStudio 5, much to the mocking of some of my peers!
    EVERYTHING you wrote rang true for me, from the love of programming in CF to the frustration of the ceaseless & uselessly added bulk of OO and the idiocy of time wasted attempting issue resolution in an OO environment vs. Old Reliable ColdFusion.

    Thanks for being 'brave' enough in this current buzzword~drugged climate to speak the truth, for your fellow programmers & their overcharged and underserved clients.

    THANKS!
  150. Bryce Says:

    Hi Marc,

    Can you believe it, your rant still packs a punch after all this time. I finally fell on it this (long, Thanksgiving) weekend and find little to disagree with and much to nod my head about in strong agreement. I too have run into my share of OOP Nazis and I too see some, SOME value in it. But damn, just let me get some work done already. Let me decide what tool(s) need to be implemented to get that work done. I've been at it for well over a decade, and have countless of happy (often GIDDY) customers all because of power and beauty of straight CF.

    If your rant was long winded, it WAS, I think because the steam was building inside you for a LONG time. That's the same steam that's been building in me and compelled me to read every word -- many of them more than once.

    Kudos.

    Bryce
  151. Stijn Dreezen Says:

    The hardest thing about OO is not learning it, it is learning when NOT to use it.
  152. Antonio Says:

    Just one more here, amongst all of you who have commented to say I feel "released" after reading this as I've felt this way all along. I worked in Canada for 6 years and built an entire intranet from scratch for a company in my own way. I would probably do things a bit differently these days but still, when I got back to Australia I experienced kind of the same thing you did to a point, doing contracting working with people who just seemed to be overcomplicating everything pretending they were top notch programmers and had to do everything to "OO" way. OOOOOHHHH, the OO way. I agree 110 percent with you and feel so much better about getting back into my own projects without necessarily trying to OO the hell out of it. Thankyou so much Marc :)
  153. Erin Says:

    Holy hot damn, thank you. I really needed to hear someone else say this.

    And now, I can close all these tabs I have open about ColdFusion and OO and best practices and get back to work.
  154. Marc Funaro Says:

    Don't abandon those Best Practices... but I hear you on the desire to get back to work! :)
  155. J Wild Says:

    Marc,

    I recently landed a promotion in a department which hired me to do, among other things, maintenance and development of their web apps.

    All of their apps are written in CF.

    I have never done any CF work (told them I could learn it).

    In terms of web work, have extensive php background and also some c#, where I use OO techniques. Not exclusively, but frequently.

    I looked into OO CF and found the grass is greener, blah out there...

    I was quite pleased to have found your post. Now I can put this to rest - use OO if I REALLY find the need, and learn CF and the tools it has to offer and 'get to work'.

    Your article saved me from (probably) chasing my tail wondering why I just couldn't seem to get the OO 'right' in CF.

Comments now closed