Editing CSS in Emacs is very easy since the standard CSS mode comes included by default. But developer Julien Danjou created this nice minor mode called rainbow-mode which will display the color of the code as the background of the code’s text. It is very useful to immediately see the colors right there in the style sheet instead of trying to remember each code and then test in the browser window.

One of the problems I had was when opening any CSS file, it would open by default css-mode, but I had to manually load rainbow-mode every time. The elisp function auto-mode-alist is used to detect a file type by its name and running a function associated with it, generally the function to enable a major mode to edit that type of file. For minor modes I couldn’t find anything that would allow me to launch them without inhibiting the mayor mode’s startup.

So since auto-mode-alist takes a regular expression for the file type and only one function as its arguments, I wrote a function that will run both and use that as the second argument to execute.

;; CSS and Rainbow modes 
(defun all-css-modes() (css-mode) (rainbow-mode)) 

;; Load both major and minor modes in one call based on file type 
(add-to-list 'auto-mode-alist '("\\.css$" . all-css-modes)) 

Hope you find it useful and you like the combination of css-mode and rainbow-mode as much as I do.

Share/Bookmark

Related posts:

1. Animate your webpage fast and easy with Facebook Animation Library
2. Easy PHP code test development with SimpleTest unit testing framework
3. PHP syntax check as you type with Emacs

Share/Bookmark

Related posts:

1. Random links from my bookmarks
2. Easy PHP code test development with SimpleTest unit testing framework
3. The importance of Web frameworks in startup development teams

In a start-up environment, things happen so fast that there’s very little time to polish your tools. Code gets done undocumented, development team members come and go with different programming styles and tools, and the chaos just builds up as the business goes.

At some point, you can’t finish or maintain something because one team member left the company with the knowledge of the code and without documenting. You either have to spend time figuring out what was done and how it works, or rewrite all that unmanageable code. I’ve seen this scenario happen too many times.

Just as the saying goes: “Stand in the shoulders of giants”, using an open source development framework is essential for the following reasons:

• Access to lots of documentation, tutorials, forums, etc
• Proven working code by a large user community
• Everyone knows where to look when a certain change is needed
• Development teams scale faster because new hires or people switching project teams can catch up and integrate to the team quickly
• Benefit from patches and upgrades from outside your development team
• Improve team productivity by not having to spend time writing basic common components from scratch every time

Even when using a closed source framework, you still get most of the benefits. Some companies prefer to build their own tools and frameworks. This approach will work out as long as they stay consistent and everybody agrees to use them in a standard way. But unless you’re addressing a very specific problem or facing a special situation, I recommend you not to reinvent the wheel and use one of the many existing open source development frameworks out there.

Here’s an old video of a chat with Steve Jobs, where he talks on how to improve productivity and saving time and resources in a development team, by eliminating lines of code to write and taking advantage of what is already out there.

Photo: SPNP #52 is Creative Commons by J_P_D on Flickr

Share/Bookmark

Related posts:

1. Easy PHP code test development with SimpleTest unit testing framework
2. command line tools for web developers
3. From my reading links: HTML5 forms and Django, Google API playground and Python development tips

Testing is a task every developer has to do eventually on any programming project. You can do it manually after writing all your code to see if it works as you intended, or better yet, before writing your code, using test driven development techniques that will save you time and frustrations down the road. One of those techniques is called Unit Testing.

Ideally, unit testing takes place before writing any code. Its a way to plan out how your functions, classes and objects will behave. The basic idea is that you plan the outcomes of each part of your program, then you write those parts to provide that outcome. So think of it as a black box that you will give some input and expect some output. This way you know how objects will be organized, what methods to write in each class, what needs to be their input and how are they going to output the results. Having all your code in tests will help you add new features, change or refactor parts of your code faster without the fear of breaking something else in your software. If you changed something and all your tests still pass, you’re good to go, if not, you can easily track down where the error is and what got affected.

PHP is famous for having spaghetti code and being too flexible that you can mess things out pretty fast, specially when you’re not an experienced programmer, or you have a team of developers with different programming styles and experience working on several components of the same project.

Although there are several unit testing frameworks for PHP, I’ll talk about SimpleTest since its very light, easy to install and easy to learn. Also, if you’re a Drupal developer, its the testing framework of choice.

Setup

To install it, go to the Simpletest download page and get the latest version. Extract the files to your PHP path, or use require_once() calls to the autorun file:

<?php 
require_once('simpletest/autorun.php');

Usage

Here’s an example of a class’ tests (testfile.php):

<?php
/* SimpleTest framework 
 set the path to where your simpletest folder is located.
 in this case, its in the same directory as the test file */
require_once('simpletest/autorun.php');

/* The class file I want to test */
require_once('myclass.php');

class MyclassTest extends UnitTestCase {

    function testGetList() {
       /* Create instance of class */
       $obj = new MyClass();

       /* call method to test */
       $result = $obj->getList(5);

       /* test result is an array */
       $this->assertTrue(is_array($result));

       /* test correct number of output elements */
       $this->assertEqual(count($result), 5);

       /* make a different call with different parameter */
       $result = $obj->getList();

       /* confirm that output is always an array, even with 0 elements */
       $this->assertTrue(is_array($result));
    }
}

Now you have a basic skeleton of you methods and their behaviors, now you can go ahead and write the real code (myclass.php).

<?php   
class MyClass {
   /**
   * Create a list of numbers
   * @param integer $size The number of elements of the list
   * @return array The list of numbers
   */
   public function getList($size = Null) {
       $list = array();
       if(!$size) {
           return $list;
       } 
       else {
           for($i=0;$i<$size;$i++) {
              $list[] = $i;
           }
       }
       return $list;
   }
}

Run it

Once we’ve written the class, we can test out its methods by running our tests script. You can do that by using the command line, or by viewing the php script in a browser window.

Personally, I prefer to use the command line for convenience and faster testing without needing even to setup any web server. Running it will look like this:

$ php testfile.php 
testfile.php
OK
Test cases run: 1/1, Passes: 3, Failures: 0, Exceptions: 0

Do more

This is a very small and simple test, but you can also test out the interface of your project. SimpleTest has a browser class that can perform some events like simulating browser visits, doing clicks on your interface’s links and checking the HTML structure of the web server responses.

Check out the full documentation, which is very easily laid out as a big tutorial, and start testing all your code!

Share/Bookmark

Related posts:

1. PHP 5 OOP implementation quirks
2. Easy CSS editing with Emacs
3. PHP syntax check as you type with Emacs

Many people are typically afraid of the terminal. Yes, it might look scary for some, retro for others, but for the practical busy programmer, the terminal is the best tool you can have.

Lately for my day job, I’ve been required to work with lots of static web pages, as I’ve mentioned on several of my previous posts. So for my daily tasks, I’ve been using a lot of command line tools on the terminal that make my work a lot faster.

Here are some of the tools that I’ve been using and how I’ve used them:

• find

  Helps me list and filter certain types of files for processing. For example find . -name *.html This will give me a list of all files with .html extension under the current directory and subdirectories.

• sed

  GNU sed is very handy to do all kinds of text manipulation without having to write a whole script about it. For example one common task would be search and replace a text or regular expression pattern on a file. Example: sed -e "s/My Search/My replace/g" myfile.html

• xargs

  This is a ‘piping’ command, it will take the output of one tool and place it as arguments for the subsequent tool in the line. Example: find . -name *.temp -print0 | xargs sed -n -e "s/Hello/Goodbye/g" This will find all .temp files, then on each of them will search the word “Hello” and will replace it with the word “Goodbye”.

• tidy

  When you have a bunch of legacy HTML code or “messy” (X)HTML documents you must parse, a good idea is to first clean up the code before working with it. Tidy is a command line tool that will help you with the task of cleaning, reformatting and indenting any messy (X)HTML document. It even does a good job cleaning MS Word generated HTML files!

• GNU make

  This is an “old school” tool, for the ones that grew up with web development and away from C/C++ development. Make is used to automate certain tasks and in a given order, checking for dependancies. In the web development process, I use make to automate repetitive tasks, such as deploying files to the testing server, making a tag in my version control system and publishing the site on the production server, cleaning up temporary files, and so on. So I write a Makefile with these tasks, and every time I have to upload my code to the testing server I only execute something like make upload and it will do the task. For example, cleaning up all temporary files on my project would involve me doing: find . -name *.temp | xargs rm -rf. I can create a Makefile with the following: clean: find . -name *.temp | xargs rm -rf then every time I need to cleanup my codebase, I simply run make clean Hope you get the idea

• git

  My preferred version control system for the past 4 years has been Git. Its a distributed version control system that is very simple and very practical to use because its extremely fast and doesn’t get in your way while programming. It has lots of features and tools for the everyday tasks and its a very good practice to version control *all* your projects, even if you’re the only developer of them. Since its distributed, you don’t need to setup a server for it and you can replicate your repository on any media and with as many copies you like. Version controlling your projects will save you from troubles like accidentally deleting files, or, using local code branches, you can easily experiment new features without affecting your main “stable” version of your code. There’s a lot to say about version controlling and Git and I guess I haven’t written about it before (strange since its a big topic for me), so I guess I’ll put more of these details for another post. Just take my advice, use git and version control all your projects. You’ll thank me later.

• rsync

  Rsync is a great tool to synchronize files and directories from one location to another. This can be on the same machine or on different (remote) machines. The typicall use of rsync is for automated backups. You can use it as so, or you can also use it to mirror your website on another folder or machine. I use it to deploy my files on the testing and/or production servers. This way I don’t have to be worried about forgetting to upload a file, the whole project can be synchronized with one single command on multiple machines. You can configure rsync to connect through ssh (more on this below) to move your files around in a secure, encrypted file transfer.

• ssh & scp

  You definately don’t want your files to be going through the network in plain sight. I know, some might say: “who cares?” but really, its better to be paranoid and careful about your data. You never know. So the best way to transport your files from one machine to another is through a secure encrypted channel. This is what SSH does for you. With ssh you can connect securely to your server’s command line to execute command there, or you can securely copy files from one machine to another using scp.

There might be several other tools that I use daily but these are the ones more present in my mind as I’ve been using them a constantly.

What command line tools do you use for your web development tasks? Do you have other ideas on which the tools listed here can be used? Send me your comments, this might get interesting and useful for all of us.

Share/Bookmark

Related posts:

1. The importance of Web frameworks in startup development teams
2. Random links from my bookmarks
3. Easy PHP code test development with SimpleTest unit testing framework