Now that I know how to do this, it seems so easy and straight-forward. To change the default application files of a specific type are opened with, do the following:

1. Right-click a file that you wish to change the default application for and select Properties.
2. Click the “Open With” tab.
3. Select the desired application’s radio button.
   • Additional applications can be added if the one you want is not listed. Use the Add button to find the desired application.
   • You can also remove applications from the list by highlighting the application and clicking the Remove button.
   • Adding applications to or removing applications from this list changes which applications are available in the “Open With” option when you right-click a file.
4. Click the Close button.

Again, it seems so easy and straight-forward now. Go figure.

I’ve spent a little more than a month working with Git now. I can honestly say that while there are many things that I like about Git, there are just as many things that I personally find to be a pain in the butt.

Submodules specifically have managed to be a thorn in my side on many occasions. While the concept of submodules is simple, figuring out how to actually work with them can be a chore. I say “figuring out” because not everything about working with submodules is well documented. I’ll cover two of the more difficult things to figure out: removing and updating submodules from your repository.

What are Submodules?

The concept of submodules is brilliant. It essentially allows you to attach an external repository inside another repository at a specific path. In order to illustrate the value of submodules, it will probably be helpful for me to explain how I am using them.

My profession is working with WordPress themes. Basically, I develop feature enhancements to the themes. I develop the code for these enhancements in modules that are completely contained in their own folder. This allows for the code to be easily added to other themes and also simplifies code updates/improvements as the code for specific features is consistent across all the themes that use that specific module.

Each theme that we produce is kept in its own Git repository. In addition, I’ve created a separate repository for each one of these feature modules. Rather than actually putting the feature module code directly into the theme repositories, I simply add the needed feature module repositories as submodules.

For example, we have a theme called FlexxBold. FlexxBold currently includes a total of seven submodules: billboard, contact-page-plugin, featured-images, feedburner-widget, file-utility, flexx-layout-editor, and tutorials. Since I’m using submodules, the code can be pulled directly from the relevant submodule repositories rather than requiring me to manually update each individual theme repository.

As I mentioned before, not everything in Git is easy to work with. There are four main functions you will need to understand in order to work with Git submodules. In order, you will need to know how to add, make use of, remove, and update submodules. I’ll cover each of those uses below.

Adding Submodules to a Git Repository

Fortunately, adding a submodule to a git repository is actually quite simple. For example, if I’m in the repository working directory of a new theme called SampleTheme and need to add the billboard repository to the path lib/billboard, I can do so with the following command:

[user@office SampleTheme]$ git submodule add git@mygithost:billboard lib/billboard
Initialized empty Git repository in ~/git_dev/SampleTheme/lib/billboard/.git/
remote: Counting objects: 1006, done.
remote: Compressing objects: 100% (978/978), done.
remote: Total 1006 (delta 631), reused 0 (delta 0)
Receiving objects: 100% (1006/1006), 408.22 KiB, done.
Resolving deltas: 100% (631/631), done.

There are three main parts to this command:

• git submodule add – This simply tells Git that we are adding a submodule. This syntax will always remain the same.
• git@mygithost:billboard – This is the external repository that is to be added as a submodule. The exact syntax will vary depending on the setup of the Git repository you are connecting to. You need to ensure that you have the ability to clone the given repository.
• lib/billboard – This is the path where the submodule repository will be added to the main repository.

Let’s check to see how the repository is doing.

[user@office SampleTheme]$ git status
# On branch master
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#       new file:   .gitmodules
#       new file:   lib/billboard
#

Notice how the supplied path was created and added to the changes to be committed. In addition, a new file called .gitmodules was created. This new file contains the details we supplied about the new submodule. Out of curiosity, let’s check out the contents of that new file:

[user@office SampleTheme]$ cat .gitmodules
[submodule "lib/billboard"]
path = lib/billboard
url = git@mygithost:billboard

Being able to modify this file later will come in handy later.

All that is left to do now is to commit the changes and then push the commit to a remote system if necessary.

Using Submodules

Having submodules in a repository is great and all, but if I look in my repository, all I have is an empty folder rather than the actual contents of the submodule’s repository. In order to fill in the submodule’s path with the files from the external repository, you must first initialize the submodules and then update them.

First, we need to initialize the submodule(s). We can do that with the following command:

[user@office SampleTheme]$ git submodule init
Submodule 'lib/billboard' (git@mygithost:billboard) registered for path 'lib/billboard'

Then we need to run the update in order to pull down the files.

[user@office SampleTheme]$ git submodule update
Initialized empty Git repository in ~/git_dev/SampleTheme/lib/billboard/.git/
remote: Counting objects: 26, done.
remote: Compressing objects: 100% (22/22), done.
remote: Total 26 (delta 5), reused 0 (delta 0)
Receiving objects: 100% (26/26), 17.37 KiB, done.
Resolving deltas: 100% (5/5), done.
Submodule path 'lib/billboard': checked out '1c407cb2315z0847facb57d79d680f88ca004332'

Looking in the lib/billboard directory now shows a nice listing of the needed files.

Removing Submodules

What happens if we need to remove a submodule? Maybe I made a mistake. It could also be that the design of the project has changed, and the submodules need to change with it. No problem, I’ll simply run “git submodule rm [submodule path]” and everything will be great, right?

[user@office SampleTheme]$ git submodule rm lib/billboard
error: pathspec 'rm' did not match any file(s) known to git.
Did you forget to 'git add'?
 b8ff8f68eb56938b9b4bf993619218fa848c5848 lib/billboard (1.2.25)

Unfortunately, this is wrong. Git does not have a built in way to remove submodules. Hopefully this will be resolved in the future, because we now have to do submodule removal manually.

Sticking with the example, we’ll remove the lib/billboard module from SampleTheme. All the instructions will be run from the working directory of the SampleTheme repository. In order, we need to do the following:

1. Remove the submodule’s entry in the .gitmodules file.Since lib/billboard is the only submodule in the SampleTheme repository, we can simply remove the file entirely by running “git rm lib/billboard”.If lib/billboard isn’t the only submodule, the .gitmodules file will have to be modified by hand. Open it up in vi, or your favorite text editory, and remove the three lines relevant to the submodule being removed. In this case, these lines will be removed:
   [submodule "lib/billboard"]
   path = lib/billboard
   url = git@mygithost:billboard
2. Remove the submodule’s entry in the .git/config. This step isn’t strictly necessary, but it does keep your config file tidy and will help prevent problems in the future.The submodule’s entry in .git/config will only be present if you’ve run “git submodule init” on the repository. If you haven’t, you can skip this step.In this example, the following lines will be removed:
   [submodule "billboard"]
   url = git@mygithost:billboard
3. Remove the path created for the submodule. This one is easy. Simply run “git rm –cached [plugin path]“. In this example, I will run “git rm –cached lib/billboard“.As I’ve seen noted elsewhere, do not put a trailing slash as the command will fail. For example, if I run “git rm –cached lib/billboard/“, I get an error: “fatal: pathspec ‘lib/billboard/’ did not match any files“.

   [user@office SampleTheme]$ git rm --cached lib/billboard
   rm 'lib/billboard'

Updating Submodules

There is an aspect about submodules that some may not realize when first working with Git submodules. When you add the submodule, the most recent commit of the submodule is stored in the main repository’s index. That means that as the code in the submodule’s repository updates, the same code will still be pulled on the repositories relying on the submodule.

This makes a lot of sense when you consider how your code will have been tested and verified (or at least should be) against a specific version of the submodule code, but the main repository’s code may not work well with new submodule updates before the changes are tested.

Unfortunately, like removing submodules, Git does not make it clear how to update a submodule to a later commit. Fortunately though, it’s not that tough.

1. Initialize the repository’s submodules by running “git submodule init” followed by “git submodule update“.

   [user@office SampleTheme]$ git submodule init
   Submodule 'lib/billboard' (git@mygithost:billboard) registered for path 'lib/billboard'
   [user@office SampleTheme]$ git submodule update
   Initialized empty Git repository in ~/git_dev/SampleTheme/lib/billboard/.git/
   remote: Counting objects: 26, done.
   remote: Compressing objects: 100% (22/22), done.
   remote: Total 26 (delta 5), reused 0 (delta 0)
   Receiving objects: 100% (26/26), 17.37 KiB, done.
   Resolving deltas: 100% (5/5), done.
   Submodule path 'lib/billboard': checked out '1c407cb2315z0847facb57d79d680f88ca004332'

2. Change into the submodule’s directory. In this example, “cd lib/billboard“.

   [user@office SampleTheme]$ cd lib/billboard
   [user@office SampleTheme/lib/billboard]$ 

3. The submodule repositories added by “git submodule update” are “headless”. This means that they aren’t on a current branch.To fix this, we simply need to switch to a branch. In this example, that would be the master branch. We switch with the following command: “git checkout master“.

   [user@office SampleTheme/lib/billboard]$ git status
   # Not currently on any branch.
   nothing to commit (working directory clean)
   [user@office SampleTheme/lib/billboard]$ git checkout master
   Previous HEAD position was b8ff8f6... re-ordering
   Switched to branch 'master'
   Your branch is behind 'origin/master' by 8 commits, and can be fast-forwarded.
   [user@office SampleTheme/lib/billboard]$ git status
   # On branch master
   # Your branch is behind 'origin/master' by 8 commits, and can be fast-forwarded.
   #
   nothing to commit (working directory clean)

4. Next, we simply need to update the repository to ensure that we have the latest updates. We can do that with a pull: “git pull“.

   [user@office SampleTheme/lib/billboard]$ git pull
   remote: Counting objects: 31, done.
   remote: Compressing objects: 100% (24/24), done.
   remote: Total 24 (delta 15), reused 0 (delta 0)
   Unpacking objects: 100% (24/24), done.
   From mygithost:billboard
      b8ff8f6..5cab93f  master     -> origin/master
    * [new tag]         1.2.28     -> 1.2.28
   From mygithost:billboard
    * [new tag]         1.2.26     -> 1.2.26
    * [new tag]         1.2.27     -> 1.2.27
   Updating c547e0d..5cab93f
   Fast-forward
    billboard.php                           |  109 ++++++++++++++-
    classes/view_gettingstarted.php         |  107 ++++++++++++++
    classes/view_gettingstarted_content.php |   38 +++++
    css/admin.css                           |   26 ++++
    history.txt                             |   22 +++-
    js/admin.js                             |   17 +++
    lib/updater/get.php                     |   94 +++++++-----
    lib/updater/history.txt                 |    9 ++
    lib/updater/updater.php                 |  241 ++++++++++++++++++-------------
    9 files changed, 519 insertions(+), 144 deletions(-)
    create mode 100644 classes/view_gettingstarted.php
    create mode 100644 classes/view_gettingstarted_content.php
    create mode 100644 css/admin.css
    create mode 100644 js/admin.js
    create mode 100644 lib/updater/history.txt

5. Now switch back to the root working directory of the repository. In our example, we are two directories in, so we run “cd ../..“.

   [user@office SampleTheme/lib/billboard]$ cd ../..
   [user@office SampleTheme]$ 

6. Everything is now ready to be commit and pushed back in (if there is a remote repository to push to that is). If you run “git status“, you’ll notice that the path to the submodule is listed as modified. This is what you should expect to see. Simply add the path to be commit and do a commit. When you do the commit, the index will update the commit string for the submodule.

   [user@office SampleTheme]$ git status
   # On branch master
   # Changed but not updated:
   #   (use "git add ..." to update what will be committed)
   #   (use "git checkout -- ..." to discard changes in working directory)
   #
   #	modified:   lib/billboard (new commits)
   #
   no changes added to commit (use "git add" and/or "git commit -a")
   [user@office SampleTheme]$ git add lib/billboard
   [user@office SampleTheme]$ git status
   # On branch master
   # Changes to be committed:
   #   (use "git reset HEAD ..." to unstage)
   #
   #	modified:   lib/billboard
   #

Closing Thoughts

I’ve learned a lot in my short time with Git. Expect to see more details about working with Git in the future. I have a series of pitfalls I’ve discovered that I should organize together and post about. I’ve also created some really slick scripts to help me automate numerous things when working with the repositories that I’d like to share.

If there is anything specfic you’d like to know about Git, please add a comment or contact me.

I recently worked on a project where I had to sort a set of rows returned from a MySQL query. The problem is that most of the data in the field being sorted is numeric yet the field type is varchar since some of the entries contained characters.

The reason that this is a problem is that MySQL sorts character fields using a method that will produce undesirable results with numeric data. For example, sorting 4, 10, and 50 as character data produces 10, 4, and 50. In most applications, this is highly undesirable.

The solution to this is to force a sorting order that is commonly referred to as a natural sort. Natural sort is just a term that refers to how humans would commonly sort a set of information (numbers as numbers and non-numeric characters alphabetically). Fortunately, this isn’t difficult to achieve in MySQL.

To further illustrate the problem, here is a simple table description:

> DESC SampleData;



Field
Type


data_char 
varchar(5)

I filled up the table with sample data. The following example query and resulting data shows the problem clearly:

> SELECT * FROM SampleData ORDER BY data_char;



data_char


10


11


120


21


3


a1

As you can see, the results aren’t exactly usable. If we simply modify the order by declaration slightly (add “+0″ to the order by field), you can force MySQL to sort the field naturally.

> SELECT * FROM SampleData ORDER BY data_char+0;



data_char


3


10


11


21


120


a1

There you have it. To force a natural sort, just add a 0 onto the field you wish to be naturally sorted.

Web applications developers such as myself often have a hard time keeping up with everything that’s going on. There’s always some new programming or scripting language, new standards, new browsers, new technologies, new paradigms, new social networks, and on and on. Every day, something new happens. The end result of all of this always ends up being very similar: people demand faster applications that deal with ever-increasing amounts of data which end up putting massive stress on the server architecture.

As we toil to improve the performance of the applications and their snappy response times, it becomes easy to forget about how we can tweak settings on a low level to provide massive speed improvements on the front-end. For example, most people don’t know that you can configure MySQL to take better advantage of the resources that the server has available.

By default, MySQL is configured to consume a relatively limited amount of memory resources. Start giving MySQL more memory to work with, and your application’s performance can improve greatly.

Unfortunately, I’m not a MySQL configuration guru. I’ve never read through the source code or any low-level technical documents about how it functions. So most of the configurations options are a complete mystery to me, and I don’t know if changing a specific option could benefit me at all.

Fortunately, I don’t have to be a MySQL configuration guru to get better performance. There is an amazing tool created by Matthew Montgomery called the MySQL performance tuning primer script.

Matthew Montgomery’s script does an amazing job of giving me information about how my MySQL configuration may be inappropriate for the queries being executed and provides information about what variables to modify in order to better optimize my configuration. For example, the “TEMP TABLES” section of the output tells me the following:

TEMP TABLES
Current max_heap_table_size = 512 M
Current tmp_table_size = 512 M
Of 1684 temp tables, 10% were created on disk
Effective in-memory tmp_table_size is limited to max_heap_table_size.
Created disk tmp tables ratio seems fine

Previously, I had my max_heap_table_size and tmp_table_size variables set to default settings and had up to 60% of my temp tables created on disk. As much as possible, temp tables should be created in memory to reduce the performance penalty of using the disk for random access to such data rather than memory which is much faster.

Now this doesn’t mean that you should set your variables to the same settings as I have. The server that this is running on is dedicated to running a dispatching system that has many tables containing hundreds of thousands of rows each. The value of the script is that it will help you tailor your settings to best use your hardware without having MySQL consume too many resources that other processes (such as you web server) could use.

The script is provided as a standard Linux shell script. Download the script into a folder of your choosing and run “sh tuning-primer.sh“.

Good luck with your MySQL optimization. I hope that you get as great of results as I have. Keep in mind that if your table structures and queries are inefficient to begin with, that configuration optimization can only do so much to improve the performance.

Further Reading

• Tuning LAMP systems, Part 3: Tuning your MySQL server
  This is a great read that should help most novice database administrators understand some of the basics about tuning their database’s performance.
• MySQL Performance Blog
  A blog by the authors of High Performance MySQL (also highly recommended). This blog is updated frequently with great tips that will help you develop higher-performance apps.

Many clients have shared concerns with me about using the built-in Update Services feature of WordPress to automatically ping services like Ping-O-Matic. Why are they concerned? They have heard horror stories from fellow bloggers or read random stories you can find on the web about WordPress sites being blocked from these sites due to a variety of different reasons. Unfortunately, there is much more information out there about the problems and very little information about solutions. In this post, I aim to address the major concerns and provide solutions where solutions are needed.

Some WordPress users will be tempted to not use the Update Services feature in order to avoid this situation. Other WordPress users will just dismiss the problems as something that doesn’t affect them. Both of these reactions are poor solutions to the problem since pinging can bring in quality traffic to your blog with little to no effort. That said, you do have to do a little bit of work to make sure that you aren’t going to get blocked by the pinging services.

Future Posting

The biggest concern that people have and the one that is widely reported as the major issue is scheduling posts for a future date. Scheduling posts ahead of time has many great benefits: posts can always come out at a specific time, you can batch many days’ worth of posts so that you don’t have to write every day, etc. However, it has been reported that the combination of scheduling posts for a future date and using Update Services have horrible consequences.

What’s the problem? The idea behind this fear is that scheduling a future post causes the ping to go through the moment you hit the Publish button. This would cause the pinging service to look poorly upon your blog since you are telling them about non-existent material (since the post hasn’t been visibly published yet).

What’s really happening? This problem was very real not too long ago. Versions of WordPress prior to 2.1 would ping the moment you published the post, irregardless of whether or not the post was visible yet. However, as of WordPress version 2.1 on, this has not been a problem. In these newer versions, a ping will not be sent until the post is visible.

What’s the solution? If you are still running a version of WordPress prior to 2.1, I highly recommend that you upgrade. Not only do the latest versions have great features that will make your life as a blogger easier, but they also include numerous security fixes and bug fixes such as this one.

Editing and Updating

Have you ever published a post just to make a quick change minutes or hours later? Have you ever had so many little mistakes in a post that you’ve found yourself going back time and time again to make “just one last fix?” How about clicking the Publish button and then seeing a mistake before the article even finishes publishing? Yeah… Neither have I. According to some people out there, all these little edits and updates can get your blog banned from pinging services.

What’s the problem? WordPress’s Update Services feature wants to tell the world that your blog is out there and active; however, sometimes this feature gets overzealous and pings these services when you really don’t want it to. Basically, the Update Services feature will ping every site in your list each and every time you save a published post (after the posting date) no matter how big or small the edit to the content was. So, that time that you made ten changes to the content within a matter of minutes after publishing the post, you sent out an additional ten pings to your Update Services list.

What’s really happening? In this case, WordPress is behaving exactly as reported. When you make those numerous tiny tweaks to your content right after publishing, you are sending more and more duplicate pings to your pinging services. Depending on the service, this can get your temporarily or permanently banned from their service very quickly.

What’s the solution? Fortunately, many great solutions for the problems with WordPress’ auto-ping feature exist. My personal favorite is Ultimate Plugins’ Smart Update Pinger plugin. This plugin not only prevents ping services from getting hit each time you edit your post, but it also allows you to manually ping the services in case you make a large edit, such as an update on the post topic, later on that you would like to notify the ping services about.

Conclusion

As you can see, WordPress has offered a great tool to help your blog get noticed, but it is not without its problems. Adding a plugin such as the Smart Update Pinger can really help you take advantage of pinging services without running the risk of getting banned by those services for abusing their system.

If everyone is interested enough, I’ll make another post in the future about the value of pinging and how to best take advantage of pinging to help maximize your blog’s potential.

Recommended Reading

• Update Services on the WordPress Codex
• Ping Technorati using WordPress
• WordPress Compressed All-Inclusive Ping List
• Ping (blogging) on Wikipedia (technical)