Is the ability to use/design MVC framework signature for advanced programmers?

[Hall of Famer]

Just curious. I've heard of people talking about definitions of noncoders, beginners, intermediate and advanced programmers. This is what I have in mind:

 

Noncoder:

---Cannot write their own codes at all

---Occasionally able to copy/paste existing codes to get something to work

 

Beginners:

---Can write basic procedural codes, knowledgebase of PHP covers at least arrays and functions

---Always able to copy/paste existing codes to get desired results

---Not capable of using OOP and basic design patterns

---Can use simple MySQL database functions

 

Intermediate:

---Can write OOP codes and know how to use third party classes

---Familiar with concepts like inheritance, Polymorphism, interface/abstract class and encapsulation, and make use of them in practices

---Know basic design patterns such as strategy, abstract factory, iterator, decorator, and can apply them in practices if a design pattern is specified

---Can use OOP style database libraries such as MySQLi and PDO, or even know how to extend them if needed

 

Advanced:

---OOP is being used everywhere, almost no trace of procedural codes

---Capable of using and designing MVC frameworks, know how to use Zend, CakePHP, Codeignitor frameworks

---Expert at all design pattens, and know which is the best design pattern to use under various circumstances

---Maybe more, such as usage of AJAX?

 

What do you think?

[requinix]

IMO it's not that cut and dry. There is only one major distinction: whether you're a blue pill programmer (learn-by-what) or a red pill programmer (learn-by-why), but even there will be some mixed behaviors. The rest is down to just how long you've spent programming and how much progress you've made since you started.

By the way, I'm trying to not rant. I think I did well.

 

 

Blue pill programmers learn by covering various topics. They copy/paste "codes" they find on the Internet, fiddle with them until they work (or give up or ask someone for help), congratulate themselves, and move on. They look at a subject long enough to remember what it's called. When things don't work it's probably some "bug" in PHP or some really weird behavior (unique to them, of course) and the workaround involves changing their code into something different... but whatever, it works now. They hear about some cool concept, find a tutorial somewhere, copy/paste the code (or download "scripts") and figure out how to make their own code work with it.

 

But they don't actually learn. Sure they've dealt with lots of subjects but they don't actually learn what's going on. SQL injection is because someone didn't addslashes() on some input and/or haven't turned on magic_quotes. $_FILES["name"]["type"] is automagically some value that says what the type of file is. Classes are things that have variables and functions.

If they get hired at a company it's because the company (a) needs someone for cheap or (b) doesn't understand how to evaluate the skill of a programmer. The programmer will introduce many problems in the code but it takes a long time for them to be noticed because (a) the other programmers are also at that skill level or (b) the site doesn't draw enough users/traffic/attention for anything big to get exploited or broken.

 

Red pill programmers learn by finding out how things work. They see a website and want to make their own, then start learning how websites work. They might find the various options like PHP and .NET and Python and (for this discussion) choose PHP. They use WAMP because it provides the things they need and requires minimal configuration. When scripts work it's because they put what they've learned together into one cohesive unit; when things don't work they try to figure out why and then fix it. New subject matter requires some research: maybe a manual or documentation, maybe a forum or community, or maybe just playing around with it. Maybe they find working examples and take them apart to see how it is they work.

 

And they do learn - maybe not everything, maybe not in depth, but they understand how things work conceptually rather than in terms of what lines of code are needed. Once introduced to the concept that users are malicious they will distrust stuff not because it's in $_GET or $_POST but because it comes from the user. Might wonder where the information in $_FILES comes from, and when they realize it's not from PHP they start wondering "then where?" From the user? So does that mean a malicious user can manipulate the file type? Oh they can? Oh, well then some code needs to change. Hears about SQL injection and how bad it is, and wonders if what they're doing is enough.

 

 

How about some more direct comparisons?

 

- Classes

BPP: collections of variables and functions, classes can get other variables and functions from other classes if you "extend" them

RPP: things or entities; OOP is very complicated, there's things like polymorphism and design patterns, and PHP supports a lot of it

 

- MySQL (and databases in general)

BPP: tables have columns and rows, use queries to do things; SQL injection is because a programmer didn't escape the quotes

RPP: more things and entities, they're probably related to each other somehow, there are different types of queries for different things; SQL injection is because someone, somehow manipulated the query string

 

- File uploading

BPP: PHP gets uploaded files, type and name tell the file type and original name, you have to copy the files somewhere

RPP: PHP gets uploaded files, you have to make sure the files are safe and then you can copy them somewhere

 

- Validation/sanitization/other basic security principles

BPP: regular expressions can check anything, JavaScript is good for doing it, I don't need to worry about security because $reason

RPP: regular expressions are complicated, JavaScript is nice but I can't rely on it, I should worry about security regardless of whether I trust my users or not

[KevinM1]

I think that's a pretty good distinction, requinix.  The advanced/skilled programmers are all Red Pill.  They turn the why into the what.

 

@Hall of Famer - yeah, no one who knows what they're doing says 'codes'.  It's just code, singular.  It's a nitpick, but also a pet peeve of mine.