Part of the site will be static content, the other part will be user generated content. The user generated content is being powered by a custom MVC framework and the static content is powered by WordPress. This gives us the ability to update static content, blog posts, and general information in WordPress’s interface without having to jump into the MVC code to make content updates. We wanted the user experience to be seamless. So if a user visited a static page or a generated page the site would not look different, thus not ‘breaking’ their experience.

We also wanted to keep the code together as much as possible. So we structured the code base into separate directories under one project name: coolnewapp. The WordPress code lives in the site directory while the MVC code lives in the app directory. The static resources, like CSS, JavaScript, and images, live in the assets directory. Here is what the directory structure looks like:

1
2
3
4

coolnewapp/
    app/
    assets/
    site/

The challenge is how do we get Lighttpd to serve up pages from the WordPress code when a static page is visited and how do I get it to serve up pages from the MVC code when generated content pages are visited. So I set out on my quest to find a solution.

I searched the highest mountains and lowest valleys of Google but could only find a couple sites that even remotely talked about what I was trying to accomplish. I found a blog post entitled, “How to setup multiple apps on Ruby on Rails and Lighttpd“. This post gave me the insight I needed to accomplish multiple applications under one domain.

I was able to get Lighttpd to serve different document roots depending on the URL. Here is the solution I developed, with the help of the article:

1
2
3
4
5
6
7
8

$HTTP["host"] == "coolnewapp.com" {
    server.document-root = "/path/to/wordpress/dir/"
 
    $HTTP["url"] =~ "^/mvc-url" {
        server.document-root = "/path/to/mvc/app/dir/"
        alias.url = ("/mvc-url" => "/path/to/mvc/app/dir/" )
    }
}

The key to this succeeding was alias.url. This basically tells Lighttpd that if the current request is for any URLs that start with /mvc-url use the provided path as the document root instead of the default path.

So now any URL that starts with /mvc-url will use the MVC application code instead of the WordPress code. If a user requests a URL that does not start with not /mvc-url the WordPress code will be used instead.

One issue with this solution, although not a show stopper, is that it tightly couples the server configuration to the whole site. This means that the site is less portable when it comes to switching to a new server or if the site needs to be hosted on multiple application servers. A solution for this issue is that the config file will always be stored in version control and a deploy script will be used that will include the config file as part of the deployment process. As time goes on with this project, the whole process will be refined.

America seems to have forgotten how things used to be. We seem not to care where our food comes from or how it is grown and cared for. Maybe some still think that their food comes from small family farmers. The sad truth is that in some parts of America, not all, food can travel up 1500 miles from farm to plate. This number varies depending on your where you live. But what that number tells you is that our current food system is broken. No longer do small family farms support their communities but large industrial companies that have one goal: profit.

Yes these industrial farms want to protect their product. But that mindset is part of the problem. The animals or produce that they grow is more than a product. It is a life form that sustains other life forms. They are not products to be treated as lifeless or immaterial. But are to be protected, nurtured, and cared for because their sacrifice will sustain our own lives.

So profit should not be the goal. The goal should be the best quality of food that was grown and nurtured in the best of conditions.

With as tough as software development can be, you would think that a lot of developers would have learned their lessons and decided not to jump directly into code. You would think they would sit down and say, “Let’s think about the best way to solve this problem”. I will be the first to admit that I have, many times, jumped head first into coding a project without thinking about what is going to be involved. This style can be a good thing. Look at agile software development, agile breaks a project down into smaller portions and these smaller portions are worked on with minimal planning. A lot of companies have been successful using the agile approach, and I am sure there are an equal amount of companies who haven’t had much success with agile.

When a new project is given to a developer, or a team of developers, one of the first things that should happen is a brain storming session. This meeting is just for the development team. No managers. No business owners. No one except the ones slinging code. This meeting is just to flesh out the entire application from beginning to end. This gives the developer(s) a chance to see the application from a 50,000ft. vantage point. This vantage point allows them to identify areas that may need some special attention. They may find that they need a specific technology, but no one on the teams knows this technology, so they will need to get training.

These meetings do not need to last 8-12 hours. They certainly do not need to go into minute detail. What they need to do is give a thorough overview of what the application entails. It places everyone at the same starting place and gives everyone the same goal to reach. So do not look at planning as a boring, long drawn out process, but as a way to see the overall picture. Try it. It ain’t that bad.

A model should only represent the data, it should not do any type of complex data manipulation only simple sets and gets. So the question then arises how do you do complex data manipulation? My first instinct was to put that on the controller, but that quickly got out of hand and I had multiple controllers that needed to do the same type of data manipulation. I didn’t want to have the same functionality in two different places. You know that whole KISS thing.

So this functionality should not reside in the controller or in the model object. This is where a new class is created to house the complex data manipulation but only gets and sets from the model. This new object can then be instantiated whenever it is needed. The necessary methods could be stored at the object level then that object can be created from any point in the application.

This sort of intermediate object model gives a developer the ability to create various objects off one model. So let’s say I have a user model where all information about a system’s user is stored (i.e. username, name, dob, etc.) but users have different roles within the system. I can create different user objects based off the one user model. So I could have a BaseUser class, ManagerUser class, and even an AdminUser class. These classes only have specific properties and methods based on the user model object.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

<!--?php 
 
# model class - represents user's data class
UserModel
{
    private $id, $name, $dob;
 
    public function getID()
    {
        return $this--->id;
    }
 
    public function getName()
    {
        return $this-&gt;name;
    }
 
    public function getDob()
    {
        return $this-&gt;dob;
    }
}
 
# base user class - all other user classes
# inherit this class
class BaseUser
{
    public function daysUntilBirthday()
    {
        $user = new UserModel();
        $dob = $user-&gt;getDob();
        // do some code
        return $daysUntilBirthday;
    }
}
 
class AdminUser extends BaseUser
{
    public function getAdminLevel()
    {
        return $this-&gt;adminLevel;
    }
}
 
class ManagerUser extends BaseUser
{
    public function getManagedEmployees()
    {
        return $this-&gt;listOfEmployees;
    }
}
 
?&gt;

What advantage does this give the developer? It helps to even further abstract methods from the data. This way models are not being used to do complex data manipulation but only access and do simple data changes (i.e. setters and getters). This allows the developer to build different classes that are based off a single data model. This helps in keeping application / business logic out of the model as well as out of the controller.

The American landscape is littered with farms that produce everything from vegetables to live stock. Everything we consume food wise started on a farm. We as humans have been farming for thousands of years. It is one of the reasons we, humans, have survived the ages. Agriculture is vital to everyones life even if they don’t know it or have never set foot on a farm.

I lived a portion of my life on a tobacco, alfalfa, and beef farm. The farm was in a rural part of middle Kentucky on about 180+/- acres of land. I lived there until I was around 8-10 years of age. Now as an adult I yearn to be back on the farm. Working the land with my hands and producing quality, healthy, non-genetically modified food.

As I begin my quest I have noticed that information about farming is hard to come by. There are places online that will give you a good overview of how to start a farm or business models for farms but nothing on the actual day-to-day activities that a farm goes through. There are no good sources for farmers to help a younger generation get the knowledge they need to begin the their journey into the agriculture business. This needs to be changed. I am not sure what that change will be but this is one of my goals for 2011. I want to figure out if there is someway to combine the power of the internet with agriculture and bring back the lost art of working the earth.

Per Wikipedia a ritual is:

A ritual is a set of actions, performed mainly for their symbolic value.

In my day-to-day life I have a ritual:

1. 1. Get up (before wife and kids)
2. 2. Get dressed.
3. 3. Brush teeth.
4. 4. Grab keys, phone, work-badge, laptop. Leave for work
5. 5. Get to work.
6. 6. Log in to computer
7. 7. Get cup of coffee.
8. 8. Read reddit.com
9. 9. Begin work.

Now all of this takes around 1 hour to accomplish. Why am I telling you this, well because I think that rituals are a vital part of accomplishing your goals. As a developer, I have a ritual of nightly working on a personal project. It is not structured in that I set a certain amount of time for each specific project but I do devote some time on a nightly basis to my various projects. This gives me consistency and focus on a specific goal. This time as a developer is invaluable. You have some time to play and experiment with whatever new technology you want to learn about.

Another great thing about rituals as a developer is that you begin approaching and/or solving a similar problem in the same way, every time. This gives you consistency in your work. If a solution worked in the past and you have a similar situation now, you should be able to solve it the same way. Another phrase developers use for this is “design patterns”. Design patterns are the idea of approaching a similar problem with a similar solution. So really design patterns could easily be called design rituals, to some extent.

Rituals are valuable to a developer in so many ways but they don’t have to be just for developers. Anyone can develop a ritual that helps them accomplish a goal.

I think this is what every good developer should do. When there is a re-occuring problem that you or your team face, the a tool needs to be built to solve the problem. As developer we are in the business of programming software and hardware applications for other people who are not software developers. That is why we must do our best to help our fellow developers.

If you are part of a team and there is something you can build that will help your collegues work more efficiently then you should try your best to build that tool.

In 2009 I took my first contract developer position as a front-end developer at one of the top five health insurance companies in the nation. At the time they had just hired a lead front-end developer about 6 months before me. He was getting everything switched from table based layouts to all css, standards compliant layouts. We began using Yahoo’s Compressor to minimize our CSS and JavaScript files before pushing them to production. This process took about 20 minutes to complete and it was very tedious.

After doing this process one time I decided to build a tool me and the rest of the developers could use to speed this process up. Since Yahoo’s Compressor was built in Java I used Java. Basically, what this tool became was a build tool for our front-end code. It worked very well. It took a 20 minute process and brought it done to about 10 seconds. Not a bad increase in efficiency.

I tell you that story is that when I left that contract position I was most proud of that tool. It was a tool that no one outside of our 4 man developer team would ever use. But I left a tool that will help other developers go onto produce better websites.

Without any freelance projects I was able to focus my energies on things that were more important than freelancing. The first thing I was able to spend more time doing was time with my family. My family is very important to me and sacrificing time at night with my kids to work on projects was not worth the money I was making on said projects. Without any projects my focus changed to what is important in life.

Another thing I was able to do was focus on some personal projects that I had been wanting to get started. Mind you they are not finished but they are started and I am actively developing them. This time I had to spend on projects was great because I was able to challenge myself to learn new technologies, new techniques, and build my repertoire as a developer. It gave me time to hone my skills and build up my developer tool belt, if you will.

This time away from freelancing shown me that having the ability to focus on something and give it your all is vital to your development as a programmer. It gives you time to play, to experiment, and it gives you time to be a human instead of a code monkey churning out code in a dark room.

At my current job we code using PHP backed by MySQL. When I started we began discussions on developing an application for our clients. It was decided up front to use the MVC architecture. I looked at using an established framework and there were some good ones. CodeIgnitor. Zend Framework. CakePHP. The list goes on. What we decided was the develop our own MVC framework. This is in no means an easy task.

During the development there were many things learned and many mistakes made. These mistakes were easily corrected and they were ultimately very valuable because of the knowledge gained from their correction.

So this brings me to the point of this post. Is the mindset of doing-it-yourself a good approach when it comes to application development. First I want to give you the cons, then I will give you, what I think, are the pros.

First up, the Cons

Longer Development Time

The actual time it takes to develop a functioning application is extended because you are first busy developing a technology that the application will eventually use. This could be avoided if an already developed solution is used for said technology.

Mistakes Will Be Made

If you have never worked with a solution in a specific technology and then attempt to build that technology then you will make mistakes. Mistakes are fine. They teach you a lot but they can either add the timeline or worse create bugs or security holes in your application. Established solutions have the advantage because the developers have experience in the technology and they have probably worked out a major portion of the bugs, if not all of them.

And finally, the Pros

Knowledge. Knowledge. Knowledge

The reason I put this first is because, in my humble opinion, this is the most valuable benefit you will get out of doing something yourself. You are a better developer. You learn so much about not just the technology but about developing software that you ultimately will approach ever project after this one differently.

Intimate Understanding of the Technology

After you develop a technology for your web application you will have an invaluable understanding of how all the pieces mesh together. This will allow you to quickly diagnose issues that arise in your application. This will help you later in life when faced with similar situations.

A Since of Pride

You can officially say to someone, “I develop the technology that powers that application”. Not many people can say that about an application they have worked on.

I have the DIYer mindset. Unless it is completely out of my league, like Assembly programming, or nuclear physics, I am going to attempt to develop my own technology before using another solution. This may be foolish or arrogant but the knowledge I gain is more valuable to me than worrying if you think I am foolish or arrogant.

Author’s Note: Another title I thought about using for this post was “Desgin – Shoot from the hip and hope it sticks” but I thought that was too wordy. I hope you understand or at least mildly grok what I am talking about. If not, contact me and we can discuss further.

When an architect sits down to design a building he painstakingly works within the required space as well as the budget. He works within specific restrictions: building techniques, building codes, user desires, and physical boundaries (aka. physics). They do not have the option to design a structure, see it built, then decide to add a conference room area where a bathroom was originally located. They are set in stone so to speak. Sure, you can remodel a building but that takes a lot of work and planning. It is not something that can be started and finished within a weekend. It needs to be planned out in very minute details. Buildings are not modular they are not plug-n-play, even though the Japanese are pushing the envelope. But even those structures have to be planned out to the smallest detail so that all the pieces fit together.

This idea of modularity or plug-n-play can become a killer of any website especially when it comes to front-end development. A website is similar to a physical building. With this mindset the front-end developer is the architect who develops the front-end code of the site. When a web designer who does not code but only designs decides that sections of the website need to be able to switch in new designs it becomes an uphill battle for the developer. The developer has to anticipate what type of new layout will be placed into a specific area of the page. I am not saying that the developer will not be able to code for multiple element types but those types need to be known up-front. A developer can not just code a section with one element then 3-months the designer wants a new type of element that will require a redo of the container and all other elements for that container.

The solution for this type of situation is very detailed planning especially if the project is for a web application. As much as humanly possible, every detail of the site needs to be discussed. Some may say that this will take to long to complete and there for delay development. That is a possibility for a team that is not willing to truly decide what is necessary and what is not necessary for the site.

That last statement is critical. A good design/development team need be brutally honest when it comes to features and design of the site. Only then will they have any chance of developing a successful web site or application that will be some what easy to maintain and extend.

One more thing. It is my personal opinion that web designer needs to be able to code in semantic HTML and CSS at the very least. Ability to code unobtrusive JavaScript is a major plus. That is my 2 cents.