I guess I'm an Advanced ColdFusion developer
I'm advanced? That's the impression I get after reading Doug Boude's short glossary of Object Oriented terms. The list is intended to help novice ColdFusion developers that are just getting into Object Oriented programming. I read through the list, and was surprised to find that I already understand about 95% of the terms. The one or two that I didn't already know were just clarifications of a concept I did understand, but I had it slightly off.
The funny thing is, I didn't think I was good at Object Oriented programming. Why? Because I don't use one of the MVC frameworks, at least not yet (I do have plans to convert CFQuickDocs to Fusebox 5 in the near future). But I found out that I am actually using most of these OO concepts already in my code...just not in an organized, community supported framework.
This reminded me of a previous debate I initiated a couple of months ago on my blog. I was basically stating two things:
- OO developers aren't necessarily advanced
- Some Advanced CF developers don't use OO
Those two statements should be obvious, and indeed most of the debaters agreed with me.
But I want to follow up on that debate with this scenario. Say an advanced Java developer starts using ColdFusion. He quickly learns of the various CF tags that allow him to do an adequate style of OO programming (cffunction, cfquery, cfobject, etc.). He is making simple applications that interact with databases, in an OO manner. But is this developer advanced? He can engage 'non advanced' developers in a debate on the merits of OO in CF, and he would look very smart. But could he even pass the Certified Advanced CF developer test? No. He doesn't know anything about CF enterprise features like SMS, Gateways, Clustering, Web Services, etc. On the other hand, someone that does understand and use the above CF concepts (as well as other advanced CF topics), but does not use OO, will be able to pass the certification.
Again, I am not saying that OO is bad, just that OO <> Advanced.
Jake Munson
36 Yrs old
Personally, I think 'Advanced' is a relative term. Does knowing every attribute of every tag, and evey arguemnt of every function make you 'Advanced'? Some would say 'yes', some would say 'no'.
I think what is more important in determining if someone is 'Advanced' is their ability to apply what they know, and how to find, learn and apply what they don't know, to the project at hand.
I don't think that someone is 'advanced' simply becasue they implement an OO architecture, or because they use an OO framework, or any framework. However, this person would have other 'tools' in their 'toolbox', and some might view this as an advantage in the job market.
I totally agree with you. In Doug's post he says that these OO concepts are 'graciously shared by your more advanced ColdFusion brethren', as if knowing OO makes you an advanced ColdFusion programmer. I was attempting to offer a counter opinion to that statement. In my mind, using OO is just one way that you can become advanced. It may very well be that most people who know and use OO in CF are also using enough of the other advanced CF capabilities that they are advanced CFers. But knowing OO by itself doesn't make you advanced in CF.
Breaking it down as to why I referred to our "more advanced brethren" in that way, it's because in my mind I tend to "categorize" certain CF skills, or expect that a certain level of developer will possess specific skills. I mean, don't we all have the tendency to harbor a kind of "skill set hierarchy" that helps us categorize a potential new hire, for instance? Just off the top of my head, my own hierarchy goes something like the following:
*Junior*
basic CF
may or may not use structures or arrays
no real knowledge of variable scopes
may or may not use or have knowledge of fusebox 2
basic sql skills
hasn't built an entire app
used CF 1-2 years
*Intermediate to Outstanding*
Good command of scopes
In depth use of framework, whether home-grown or fusebox X or other
Intimate with structures and arrays
has built entire apps
may or may not have some knowledge of OO principles, dabbling in newer frameworks
basic to decent sql skills
used CF 3-5 years
*Advanced*
Custom tag creation
Intimate with the usage of different scopes
Advanced project work (e-commerce connectivity, shopping carts from scratch, etc.)
experience creating and consuming web services
Familiar with XML manipulation
Design, project management, and participation in building large apps
Solid knowledge of OO principles, used newer frameworks to build apps
solid to advanced sql skills
used CF 6-9 years
*Advanced with a halo*
All previous experience plus:
Expert knowledge of OO principles (understand it from several perspectives)
Experience with OO in realms other than CF
Major role on enterprise-size projects(architect, team lead, heavy-hitter coder, etc.)
Ability to convey OO concepts to others
Generally regarded in the community as "experts"
7+ years in the web programming field
So, using my subconscious hierarchy of skills, I refer to our "advanced brethren" as such because they do posess that intimate knowledge of OO principles, are able to convey that knowledge to others, and do regularly and faithfully give back to the community in that way.
Now, the whole point of sharing my Lexicon was so that next time, for instance, someone who is still learning about OO is sitting in one of Sean Corfield's talks, that person won't be completely lost; in order to really gain from what Sean and others have to say, it's needful to be familiar with the vocabulary that they are going to use, otherwise the knowledge being shared will, for the most part, be lost on that individual.
Sure didn't mean to make any implications whatsoever by the phrasing I used!
First of all, thanks for providing that list. I found it useful, and I'm sure others will as well.
The flaw I see in your hierarchy is that there's a natural progression from no programming experience, and with using older frameworks. If I'm starting today, why would I be using Fusebox 2? Plus, you don't have to use OO to use a framework. Fusebox can be used procedurally. Also, why is it assumed that as I progress through my CF career that I'm going to pickup and start using OO?
On the other side of the coin, will an advanced Java developer that is intimate with OO be an advanced ColdFusion developer? Of course not, he's never used it before. This is the mistake I see you and others making; implying that OO is part of CF, and there's a natural progression from newbie CF developer to OO god. OO has /nothing/ to do with ColdFusion. The two are very separate things, it just so happens that one can use OO principles in ColdFusion if one so desires.
Using OO as the only standard for calling someone advanced is like going up to a C++ developer that is proficient with OO in his language and calling them and Advanced ColdFusion developer. Like I said before, OO has /nothing/ to do with ColdFusion.
I am also saying that a person should be called an advanced CF developer if they've mastered many of the advanced CF concepts, even if they don't use OO. IMO, OO should not be the measuring stick for such judgments. However, /if/ the above person were also experienced in OO, in addition to his other advanced experience, then yes, that person is advanced.
Just caught this thread. Firstly I agree there are many dimensions of advanced. Client communication skills, defining business requirements, understanding patterns and being quick and knowledgeable with a given language are (just to take four examples) all things you can have varying degrees of skill in and may or may not be "advanced" in.
I would not require knowledge or use of a community framework to consider someone to be advanced developer, although in practice, someone who has never taken the time to look at community frameworks will have missed a lot of great learning opportunities to become a better programmer faster. Equally, you don't have to read blogs to become "advanced", but reading relevant industry blogs will probably help you to improve your programming to an advanced level much more quickly.
Clearly someone with advanced Java skills who is just starting is not an advanced CF developer. He is an advanced developer who is learning CF, with all of the associated frustrations and inefficiencies.
The only thing I'm not sure about is whether someone would be considered an "advanced' CF developer without a good understanding of OO and patterns.
OO - to me - is not analogous to a language. I would argue that the skills required to intelligently architect and design OO applications are quite a bit more complex than the skills required to architect an application without using an OO approach. While I would agree that there are advanced developers who have architected sophisticated applications using a non-OO approach in CF, most people I would consider as advanced developers are either profficient in OO coding or are busy becoming so. I also find OO skills a good litmus test. There are many less poor developers who can quickly and easily explain the benefits of an absract factory and three good real-world uses for it than there are poor developers without OO skills.
Can you be advanced without using an OO approach? Absolutely. How many advanced web developers are not at least starting to look into developing OO apps (even if on their own time if they're stuck in CF5 hell at work)? Probably not so many . . .
Best Wishes,
Peter
I think I agree with most of your arguments. The only thing I get hung up on is the OO as a litmus test bit. I think one could use CF related OO questions to find out how good you are at OO, but it will /not/ tell you if the person is good at all of the other advanced topics/practices. However, I think I mostly agree that it's usually safe to assume that if someone is using OO in CF, they're probably advanced at other CF related things as well.
But if you look around the CF community, you'll see a few advanced CFers that started as 'newbies' like the rest of us, but came from an experienced Programming background. Sean Corfield, Matt Woodward, and others all came to CF with an OO programming background. I'm sure if you were to ask them when they were just starting with CF if they were advanced CFers, they'd say something along the lines of "I'm still learning". You might just assume they were advanced because of their OO proficiency, but you'd have been wrong. Of course, I'm sure they're gurus now. :)
Best Wishes,
Peter
A bit OT, but I'm curious about your cfscript comment. I've read quite a few blog entries over the years where a high profile CFer says that they don't like cfscript, and some even wish it would be removed. Here's one example:
http://clearsoftware.net/index.cfm?mode=entry&...
1. I consider using OO practices in CF development to be using some of the more advanced features of CF. More advanced than knowing about scopes and complex datatypes.
2. Isn't it really up to whomever is going to pay our salaries or cunsulting fees to determined if we are 'advanced'?