Gitg has much the same feel as gitk does, but feels much more polished and is well worth a look. I find it quite handy to view the history of projects to get a visual representation as to what has happened in the history. It also has the ability to stage and commit changes.

Definitely check it out if this sounds like something you would find useful and you are using the gnome desktop environment.

There certainly are some good things to be said for it. It has an impressive feature set, and an intuitive interface which allows the store admins flexible control over discounts, pricing, taxes, etc. However there are some strong drawbacks to consider before taking the plunge and integrating it on a site.

First off, it is fairly resource hungry. If you are in a shared hosting environment, I would not consider it a viable option at all. Page load times will be significant, and adding an item to a cart will require the patience of Job. On a dedicated environment there are a number of tweaks that can be implemented to bring this down to a much more acceptable level however.

Secondly, nail down your requirements for the store first. If Magento doesn’t do what you need out of the box, or there aren’t any modules available in the community that meet your needs, anticipate a steep learning curve. Magento is developed using the EAV data structure, so don’t expect to be doing many direct SQL queries yourself to access data. Also, the object API is poorly documented, and in some cases broken.

Templating can be a bit of a bear until you learn which files to edit. Even then, a single page may be split across about a dozen files. Be sure to enable the theme developer hints in the configuration. This will help you out immensely in tracking down where content is coming from.

Lastly, I would recommend checking out the magento forums. There are so many threads that start with “Has anyone gotten magento to do x?” followed up with “I would like to know as well… anyone?”. The development team doesn’t seem to be able to keep up with the requests for features and isn’t the most communicative.

However, if you have your own server (or a good level of control over the environment and resources the project is being deployed in), and only need the features that are available through the interface, it can be a great solution to put in place.

Has anyone else had experience in Magento they wish to share? I’ve been told I should start a support group.

ssh -l some_user -i ~/.ssh/other_key.pub example.com

After having a few servers and starting to lose the commands in my history, I figured there must be a better way to keep track of this. Turns out there is (surprise surprise). Inside your home directory, there’s a .ssh folder where you can drop a config file. So, to recreate the above example you would add the following section:

Host example.com
    User some_user
    IdentityFile ~/.sh/other_key.pub

and now I can connect with

ssh example.com

There is a whack of documentation about how this can make your life easier. Check out the man pages

man ssh_config

Fearing a faulty motherboard, or inproper CPU installation, I decided to watch what was happening to the temperature in the BIOS. The temp was staying quite low ( < 30 C for both the CPU and motherboard) but, the system would still lock up… even in the BIOS screen. At this point I had detached everything except for the video card, 1 stick of RAM, and the hard drive and was still getting the same problem.

As a last ditch attempt, I swapped out the final stick of RAM for one of the other ones in the pile of components sitting beside the case. And what do you know, it worked!

Now, the only conclusion I can come to is that the RAM was overheating after about 2 minutes or so of use, and then completely ceasing to function. The bad memory addresses must have been quite close the beginning since even in the BIOS screen (where I’m assuming it doesn’t do all that much with RAM) would lock up.

Has any one else ever experienced something like this? For the record it was a Corsair 2GB stick.

Doing a bit of researching, I found that using git it is possible to commit some of your changes instead of all of them. To do this I have found the interactive commit command the most straight forward to use.

To begin an interactive commit,  issue the command with the –interactive flag (note, that’s two dashes, not the one long one)

git commit --interactive
           staged     unstaged path
  1:    unchanged        +3/-0 index.php
 
*** Commands ***
  1: [s]tatus	  2: [u]pdate	  3: [r]evert	  4: [a]dd untracked
  5: [p]atch	  6: [d]iff	  7: [q]uit	  8: [h]elp
What now

As you can see it gives you a number of options. In this case we want to patch the file so we hit ‘5′ and then hit enter.

What now 5
           staged     unstaged path
  1:    unchanged        +3/-0 [i]ndex.php
Patch update

This is showing us a list of files that we can choose to patch from. Hitting 1 will select index.php for patching. You have to hit return again to begin the process after a file has been selected.

Patch update 1
           staged     unstaged path
* 1:    unchanged        +3/-0 [i]ndex.php
Patch update
diff --git a/index.php b/index.php
index 90ea18f..e2f84ef 100644
--- a/index.php
+++ b/index.php
@@ -1,7 +1,10 @@
 this is a test of how to commit partial files
+this is the first addition to the file
 some more changes
+and another line goes here
 testing
 and some more testing here... this is fun!
 
 adding some content to the bottom of the file
+okay, last one for now
 and a couple more
 
Stage this hunk [y/n/a/d/s/?]?

Hitting ’s’ will split the current hunk and show you the changes to the file one hunk at a time giving you the option to stage the change or not.

After you are satisfied with how you have things set up, hit 7 to quit when given the option and git will bring you to the familiar comment adding screen.

Doing a git diff right after doing this will show you that only the staged changes got committed, the rest are still waiting there for whenever you’re ready to commit them as well.

It turns out this is being caused by a pre-commit hook. There are two options you can go with to circumvent the issue.

git commit --no-verify .

The –no-verify will bypass the pre-commit hooks. This only works on the current commit thought, so you have to add the flag each time you want to commit.

I’ve found that if you

cd .git/hooks/
chmod -x pre-commit

will disable the pre-commit hooks permanently by removing the executable rights on the file.

Apparently they are disabled by default in newer releases.

Hope this helps someone else out as well.

One thing that I have found while working with git is that there isn’t a wide selection of graphical tools to interact with the repository. There is gitk which comes with a default install of git. This program gives you a visual representation of the workflow of the repository that you’re currently working on. From your checkout folder typing gitk should bring up a window similar to this one.

You’ll see a list of commits and a line tieing it to the parent commit. If you have a team of developers working on a single project, this can make for some interesting graphs to say the least. Tags are highlighted with a nice yellow flag which makes them stand out. Right clicking on a commit will let you view the differences between it and the currently select commit. Also, you can roll back the master branch to the selected version. In the bottom right pane there is a list of changed files on the currently select commit. Right clicking on one of these will let you bring it up in an external diff tool to view the changes that were made (I recommend meld for this).

If you were looking closely at the previous screen shot, you may have noticed that this was a clone of the Giggle repository. It’s also an sudo apt-get install giggle for simplicity’s sake. Giggle has a nicer interface that fits in with the gnome desktop environment better as you can see from the screen shot.

Also, built in to the giggle interface is the ability to commit directly from there which seems to be lacking from the gitk app unless I’m completely missing something.

The last app I’ll look at for today is qgit4. This program is one that I cloned and compiled locally. You can make a clone of the repo by typing in

git clone git://git.kernel.org/pub/scm/qgit/qgit4.git

Then cd qgit4 and type in

qmake qgit.pro
make
make install

You’ll need the Qt developer libraries installed for this to work, but if all went according to plan, you should have a bin directory with a qgit4 executable in it now. It should looks something kinda like this:

Qgit4 seems to be one of the more full-featured programs I’ve come across yet. It feels like it fits in more with the KDE desktop environment withsince it uses the Qt libraries. However, it lets you create multiple tabs if you want to take a closer look at each file and what changed. Clicking on a revision will show you the list of files that changed in the bottom right pane as well. Then right clicking on a file can open it in an external diff viewer as well.

I think each of these programs has their place. For quick ‘what change in this commit’ gitk seems to fit the bill nicely (albeit rather ugly) and if you’re using gnome, I recommend giggle (if you can bring yourself to using a program named giggle… just don’t tell anyone else).

For typical day-to-day operations like committing, adding files to version control, and tagging I find that using the command line is pretty hard to beat though. However, having tools like these available will make git accessable to a wider audience, and easier to pitch to the team for your next development project.

select * from users where last_name LIKE "%smith%" order by first_name
INTO OUTFILE '/tmp/result.csv'
FIELDS TERMINATED BY ',' OPTIONALLY ENCLOSED BY '"'
LINES TERMINATED BY '\n';

This will write the file /tmp/result.csv in a format that is readable by pretty much any spreadsheet program (Excel, OpenOffice, etc). If you have any specific requirements for your file format (say you want tab separate) play around with the options until you get it just right. As you can see you can do anything you would regularly do in a sql query (joins, where clauses, ordering, etc).

And there you have it, one happy person who can access their data in their favourite program

sudo apt-get install network-manager-pptp pptp-linux

Did the trick and now it was just a matter of entering the server information, username, password. At this point I was still unable to connect to the network. I double and triple checked my info and it was all right. It turned out I had to enable Point to Point Encryption (makes sense) in the advanced section.

Now, I have a nice little ‘locked’ icon on my network status bar.

Who knew it would be that easy?

Apache Benchmark can be a helpful tool to determine response times based on various traffic patterns. It lets you determine how many requests per second your server should be able to handle, and how long each visitor will have to wait to receive a response.

The syntax is pretty straight forward:

ab -c 10 -n 1000 http://yourdomain.com/

(note the trailing / if you are wanting to test your main document). The -c tells ab to make 10 concurrent requests at a time and -n tells it to make 1000 requests total. This will create output similar to

This is ApacheBench, Version 2.3 <$Revision: 655654 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/
 
Benchmarking yourdomain.com (be patient)
Completed 100 requests
Completed 200 requests
Completed 300 requests
Completed 400 requests
Completed 500 requests
Completed 600 requests
Completed 700 requests
Completed 800 requests
Completed 900 requests
Completed 1000 requests
Finished 1000 requests
 
Server Software:        Apache/2.2.9
Server Hostname:        yourdomain.com
Server Port:            80
 
Document Path:          /
Document Length:        240 bytes
 
Concurrency Level:      10
Time taken for tests:   20.824 seconds
Complete requests:      1000
Failed requests:        0
Write errors:           0
Non-2xx responses:      1000
Total transferred:      565000 bytes
HTML transferred:       240000 bytes
Requests per second:    48.02 [#/sec] (mean)
Time per request:       208.238 [ms] (mean)
Time per request:       20.824 [ms] (mean, across all concurrent requests)
Transfer rate:          26.50 [Kbytes/sec] received
 
Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:       59  120 376.0     68    3093
Processing:    61   80  44.0     70     466
Waiting:       61   80  44.0     70     466
Total:        121  200 377.8    144    3165
 
Percentage of the requests served within a certain time (ms)
50%    144
66%    151
75%    156
80%    162
90%    176
95%    203
98%    520
99%   3132
100%   3165 (longest request)

From this we can see that the server tested was able to hand approximately 48 requests per second and was able to process 1000 requests in just under 21 seconds. Whether or not these are acceptable values completely depends on the requirements of your project and application.

You are also able to send in post and cookie data (check the man pages for instructions on how to do that) if you would like to benchmark an authentication process or some form processing.

I’ve found ab to be  a useful tool to determine which pages on a site are taking too long to server / bogging down the server. It’s certainly not the end-all / be-all but can get you pointed in the right direction. After collecting some baseline data though ab, it may give you some ideas as to what code to optimize or where to implement caching on your server.

Remember, be kind and only stress test your own servers. Other people may not take kindly to you hammering their server just to see how they hold up.

edit

Just a quick note about dynamic urls. You can use these if you put single quotes around the entire url. For example:

ab -c 5 -n 2000 ‘http://yourdomain.com/index.php?id=27&action=edit’