I’ve currently been using my Model 1.5 Framework (ScottWork) for sometime, but have been using CodeIgniter on a few client projects and dabbling with some of the leading PHP Frameworks like Zend, Symfony, DooPHP, Yii and CakePHP.

All of this MVC stuff of course got me thinking, what if I want to get other developers to code for me? What if I want to get other developers to maintain my apps/code? What if…?

So I write my own MVC framework here’s a summary if it’s main components:

• mod_rewrite and routing of request – This is basically the nice thing like removing ? and & from your URL so it looks pretty AND automatic routing of URLs to controllers->methods().
• Controllers - This is basically taking your request, and channeling it into some OO paradigm that allows you to “act” on your request in an object oriented way, then route your way to a “view”. It also contains all your logic and calls to your Model.
• Models - This allows you to talk to a database and controls your interaction with that database.
• Views - This presents your data combined/calculated/manipulated/read or otherwise transacted in your Controller.
• Helpers - This is a bunch of pre-built functionality designed to make the framework easier to use and code less.

Here’s my opinion of those main components after comparing them to my Model 1.5 framework (scottwork).

• mod_rewrite and routing of request – I see a lot of uses for mod_rewrite but the routing of request to some kind of controller/object oriented thingy is really a waste of time. Why have one huge controller with a bunch of methods in it, when you can just write a simple script designed to process the input of a page? It’s small, modular which means easy to maintain, there’s no object to create, or routes to manage. The easiest thing about not using some kind of route manager is that you can create a new page that reads data, by just adding the page, no controller/route/setting data to be read by the page later, it’s all right there, one php page. Vertict: mod_rewrite (yes), routing (no).
• Controllers - You don’t need an object to call other pages, most frameworks just use the good-old include() statement, or they wrap it inside some output buffering, but essentially it’s an include. What I do in my framework “scottwork” is to create a processing page (it does not have any HTML) which is essentially the same contents of a controller method, but it’s in one file that’s only job is to process the data from the one page. Vertict: controllers (no)
• Models - I use ADODB and a generated model based on that library. The model is good-old-fashion prepared statements with CRUD operations and basic validation to so that you can insert/update/delete and read-by certain fields. I extends the generated file with a child DAO that allows me to override CRUD operations or do new operations specific to my app. Vertict: models (yes)
• Views - This is completely ridiculous in MVC, the bindings and coupling between Controllers and Views is much worse than just having separate files with single methods. Plus for read-only pages, you just need to create your view, no controller->render_view() non-sense. Vertict: views (no)
• Helpers - This is a bunch of pre-built functionality designed to make the framework easier to use and code less. Vertict: helpers (yes)

In Summary:

You could use a framework or spend time writing your own MVC framework as I have done. Some people like OO, some people like the order/structure a framework provides. Personally I don’t like spending lots of time coding, so I generate most of my stuff. I also don’t like spending time figuring out a framework’s shortcomings or finding bugs in a framework. I believe in writing small testable, programs/scripts (web pages) that do one thing and do them well.

Some interesting reading:

• Second System Effect – The tendency to take something small and elegant, and make an elephant out of it.
• Unix Philosophy – Write programs that do one thing, and do it well.
• Neal Ford – Essence vs. Ceremony Talk (no link to presentation)

1. Language Fundamentalist – These are the types that love the ins and outs of a language, compiler optimization, how memory is managed, they can explain why a certain language is great or sucks.
2. Language Craftsman – These are the types that love a certain language, they can tell you the ins and outs of that language’s core API but they are resistant to changing an language once they’ve become adept and skilled at it.
3. Language Minimalist – These are the types that do as little with a language as possible, they might work with a defined content management system like Joomla or WordPress or if they built a system it might consist of an open source system with 5-10 frameworks or other scripts used to get the job done.

Now based on what type you are you usually dabble/play in some of the following areas:

The Language Fundamentalist

• Different Languages
• Abstraction Patterns
• Algorithms
• Compilers

The Language Craftsman

• Language X APIs
• Frameworks of Language X (they can tell you just about everyone pros/cons of each)
• Next versions of language X
• How language X is better than all the rest.

The Language Minimalist

• Ins-Outs of how to customize a few different systems
• Learning newer better or next versions of similar or same systems
• How to integrate these systems with other ones

Whether or not these three are all inclusive or accurate, I’m not sure since I am neither a psychologist or a sociologist, but I am a programmer and have seen these kinds of programmers.

Personally I’ve majored in Craftsmanship with a minor in Fundamentalism, I don’t usually care about compilers unless they are preventing me from doing something, I also don’t care for most frameworks as they are someone elses often poor attempt at abstraction or simplification.

Most people today don’t realize the art of being productive, everything is so rushed and fast, it actually takes time to be meaningful and productive.

I hope you enjoy the blog! Now go visit!

The reason is that I wanted to do too many things with the site and was forced to look for so many so-so plug-ins. So rather than do that I just coded what I needed and so far so good, it actually give’s me some practice with my PHP skills, which I enjoy.

There are lots of ideas about this and I have a few of my own. I have read some interesting articles and books on Pareto’s Law (The 80/20 Rule) and am finding that most productivity comes from just a few things.

3 Most Effective

1. The Language – The language you choose to do most of your coding is directly proportional to the efficiency of your programming (lines and quality).
2. The Libraries/Frameworks/Resources Available – Depending on what you are programming, re-inventing the wheel is wasted effort.
3. The Programming Environment – Text Editors, PC/Mac/Linux, Number of Monitors, Other Tools, Fast Internet Connection.

3 Least Effective

1. Development Methodology – This only matters when projects are not well thought out and people don’t know what they want programmed. But for the programmer that knows what he wants to code, it does not matter.
2. Unit Testing – I have friends that will roll their eyes at this statement, but I’ve written so many lines of code with no to little defects and I’ve not written one unit test or test case. In fact writing unit testing and doing testing on obvious stuff was the most wasted weeks I’ve ever spent.
3. Anything that makes code more maintainable – Often you will hear about rules that are good for creating maintainable code, some pattern, avoiding some anti-pattern, lines of code in a method, or size of a class file, etc. These all sound good, but the fact is only a small percentage of code is ever re-used, so stop trying to make 100% of it reusable.

Configure php.ini

1. add this to httpd.conf “PHPIniDir “C:/php/php.ini”"
2. un-comment this line: extension=php_mysql.dll

Copy libmysql.dll

1. Add your php folder to the path, for this example: c:\php
2. Open Command Prompt. Win+R, type cmd
3. net stop “apache2.2″
4. copy c:\php\libmysql.dll c:\windows\system32
5. net start “apache2.2″

Now your PHPMyAdmin or other program should work as expected.

-vm

%JAVA_HOME%\jre\bin\javaw.exe

I also made some adjustments to the VMARGS.

-vmargs
-Xms512m
-Xmx1024m
-XX:MaxPermSize=128m

Update (12/21/2009)

The launcher in Eclipse is rather tricky. You need to make sure your .exe is named eclipse.exe. You should also launch from the directory or via batch file with the following contents.

cd C:\Programs\Eclipse\java
start eclipse.exe

The reason for this is because the eclipse launcher uses the name of the exe to read the .ini. The launcher also is not able to find the .ini if you use it from a shortcut or a launcher like Launchy.

Hope this helps fix any problems!!!