I was eager to try out Google’s AppEngine for Java, but I was soon disappointed to find out that the AppEngine is just a partial implementation of the Java APIs. The biggest problem with the missing APIs is that a lot of 3rd party software and libraries simply won’t work, which means that you loose all the benefits of the mature Java ecosystem. Porting an existing Java application to AppEngine is simply out of question.

Another major problem is persistence. You cannot deploy your favourite DBMS on AppEngine, you have to use Google’s Datastore, which is not a common relational DB. Google makes available JDO and JPA interfaces to access the Datastore. However, these are also partial implementations which provide just a familiar syntax for a substantially different persistence mechanism and create a false sense of familiarity. This is particularly true when you try to refer to the JDO documentation for troubleshooting, but you discover that the semantics of Google’s JDO implementation are quite different. It would have been much better to stick with a proprietary persisntece API and not pretend to fill the gap to reach JDO or JPA semantics.

Another important missing feature are Threads, which makes AppEngine a poor choice for massive computations since paralellization of subtasks is not possible, at least until Google implement the AppEngine Map/Reduce service.

Lastly the overall sense of a finished product is not there. Things that one would expect to work, fail for some obscure reason. Error messages are often cryptic. Apart from an introductionary tutorial, documentation is quite scarce. I guess this is justifiable since AppEngine is still a beta release, but I would rather consider it a pre-alpha. I was expecting much more considerate choices from the smart Google engineers, who have amazed us many times so far.

There were a few things I did like about the app engine. For example, the Eclipse plugin simplifies configuration, testing and deployment. Integration with other Google services are a promissing factor. All in all, Google AppEngine is an interesting toy, but compared to other solutions it’s remains just a toy. If you want to play with it, I suggest you should read this.

In the previous part we have implemented a ThreadPoolExecutor that accepts tasks and executes them in parallel. In this part we will implement a parallel for loop.
The parallel for needs to iterate over a collection of items and invoke the specified closure on every item. It has to perform these invocations in parallel and the next instruction should be executed only after all the elements have been processed. When used, it should look something like this:

ForEach(distributionList, (destination) => { Message msg = new Message(destination.Address); msg.Content = Encrypt(Content, destination.PublicKey); msg.Send(); Console.WriteLine("sent message to" + destination.Name);
}

So the signature of the method should be:

public static void ForEach(ICollection<T> collection, Action<T> action)

We know that we need to use the ThreadPoolExecutor, enqueue all the actions and execute them and then wait for the executor to finish. But we have a mismatch. The ForEach() method takes a parameterized action, while the thread executor takes an action without any arguments. What we need to do is construct a set of parameterless actions by adding each element of the collection as the parameter of the parameterized action.

action(x) -> action1, action2, action3… actionN

We can do it with one simple line of code:

Action parameterlessAction = (() => parameterizedAction.Invoke(element));

This was first invented in lambda calculus, and it was called a closure, because the function gets closed over the free parameter. Hence the (slightly misnamed) term closure that the rest of us programmers use. Most of the programmers would be more familiar with the term currying to define this operation.

Our code would take the following form:

public static void ForEach(ICollection<T> collection, Action<T> action) { ThreadPoolExecutor executor = new ThreadPoolExecutor(); foreach (T element in collection) { Action parameterlessAction = (() => parameterizedAction.Invoke(element)); executor.AddTask(parameterlessAction); } executor.Finish(); } executor.Finish();
}

However, this code has a well hidden and nasty bug. The bug is caused by a certain property of closures, which makes them dangerous in the wrong hands. This is also one of the major reasons why many Java developers don’t want closures. Don’t you see it? Hmmm… Are you ready for using closures?
Closures require that their free variables have an extent at least as long as the lifetime of the closure itself.
In our scenario we are referring to element inside the parameterlessAction, but the value of element changes with each iteration. So by the time we invoke the closure unexpected results can happen. Fortunately enough, in our case, Visual Studio was able to detect this situation through static analysis and shyly display a warning in the form of a blue squiggly underline. The solution is to assign element to a temporary variable, and the compiler will be smart enough to allocate that variable on the heap instead of the stack, so that the variable has a longer lifetime than the method invocation.
So here’s the final version of the code:

public static void ForEach(ICollection<T> collection, Action<T> action) { ThreadPoolExecutor executor = new ThreadPoolExecutor(); foreach (T element in collection) { T parameter = element; Action parameterlessAction = (() => parameterizedAction.Invoke(parameter)); executor.AddTask(parameterlessAction); } executor.Finish(); } executor.Finish();
}

This is the first of the two posts that shows you how to build a parallel for loop in C#.

In this part we will start building a rudimentary ThreadPoolExecutor that will be the core of the parallel execution. It will have has 2 methods:

• AddTask(Action a) – it queues up a task to be executed one of the threads in the pool.
• Finish() – signals the executor to stop accepting any other tasks and wait till all tasks are completed.

The implementation is based on the BlockingQueue implemented in the previous post. It uses 10 worker threads that constanty get tasks from the queue and execute them. Since it is a blocking queue, the workers will block untill someone puts a task in the queue. The queue is thread safe, so every task will be processed only by one worker.

We will start by implementing the logic that queues up the tasks and the worker threads that execute the tasks, later we will thing about termination.

 public class ThreadPoolExecutor { private readonly BlockingQueue tasks = new BlockingQueue(); private readonly Thread[] workers; public ThreadPoolExecutor() { workers = new Thread[10]; for (int i = 0; i < workers.Length; i++) { workers[i] = new Thread(run); workers[i].Start(); } } public void AddTask(Action task) { tasks.Enqueue(task); } private void run() { while (true) { tasks.Get().Invoke(); } } }

Now we need to add the termination condition. Let’s start by just not accepting new threads, and later we will think about waiting for the tasks to be processed. We will use a boolean that indicates whether the ThreadPoolExecutor is open or closed. If it is open, it can accept new tasks. Once the Finish() method gets called, the ThreadPoolExecutor becomes closed and doesn’t accept any new task.

public class ThreadPoolExecutor { private bool open = true; // open to accept new tasks private readonly BlockingQueue tasks = new BlockingQueue(); private readonly Thread[] workers; ... public void AddTask(Action task) { if (open) { tasks.Enqueue(task); } else { throw new Exception("Queue is closed"); } } public void Finish() { open = false; } private void run() { while (true) { tasks.Get().Invoke(); } } }

The problem with this implementation is that the Finish() method doesn’t wait for all tasks to be processed, but returns immediately. The tasks to be processed include the ones in the queue along with the ones being currently processed by the workers. We will introduce a counter to keep track of this number. The Finish() method will block until that counter reaches 0. For blocking we will use System.Threading.Monitor and we will synchronize on “this”. Moreover, once all the tasks have been processed, we’ll interrupt all the worker threads that are blocked on the queue.

using System;
using System.Collections.Generic;
using System.Threading; namespace Concurrent { public class ThreadPoolExecutor { private bool open = true; // open to accept new tasks private readonly BlockingQueue tasks = new BlockingQueue(); private readonly Thread[] workers; private int pendingTasks; // the number of tasks in the queue public ThreadPoolExecutor() { workers = new Thread[10]; for (int i = 0; i < workers.Length; i++) { workers[i] = new Thread(run); workers[i].Start(); } } public void AddTask(Action task) { lock (this) { if (open) { tasks.Enqueue(task); pendingTasks++; } else { throw new Exception("Queue is closed"); } } } public void Finish() { lock(this) { open = false; // wait till all tasks are finished while (pendingTasks > 0) { Monitor.Wait(this); } // kill the workers waiting for more tasks foreach (Thread worker in workers) { worker.Interrupt(); } } } private void run() { try { while (true) { lock (this) { if (!open && pendingTasks == 0) break; // if we're not open anymore and there are no tasks in queue, break the loop } // don't block other threads while processing the task tasks.Get().Invoke(); lock (this) { pendingTasks--; Monitor.PulseAll(this); // notify waiting threads that the tasks are all processed } } } catch(ThreadInterruptedException) {} } }
}

In order to parallelize your program, divide it in concurrently executable tasks and wrap every task in an Action object. For convenience you can also use closures. Add all the tasks to the ThreadPoolExecutor and wait for them to finish by calling the Finish() method.

In the next post we will be adding some syntactic sugar to implement a parallel for construct.

Here’s a simple implementation of a blocking queue in C#. This can be used for consumer producer scenarios, buffered messaging, worker pools etc.

using System.Collections.Generic;
using System.Threading; namespace BlockingQueue{
public class BlockingQueue<T> { private Queue<T> q = new Queue<T>(); public void Enqueue(T element) { q.Enqueue(element); lock (q) { Monitor.Pulse(q); } } public T Get() { lock(q) { while (q.Count == 0) { Monitor.Wait(q); } return q.Dequeue(); } }
}
}

Have you ever asked yourself how much time during the day in the office do you spend looking at funny youtube videos, reading emails, taking coffee or doing some boring administrative task that keeps you from getting your work finished? I’ve actually been asking myself that for what it feels my entire life. I always tought that a well organized and productive 3 hours could be more valuable than a whole day of distractions. I always wanted to measure that productivity in detail and see what things I’m spending my time on and how much. Now I finally can.

A few months ago I found out on Lifehacker about this software called RescueTime that tracks how you spend your time on a computer. It’s free and you run it in the background. It categrorizes your activities in Communication, Development Tools, Reference/Search etc. If you are using a browser it is smart enough to distinguish which sites are you accessing, so reading The Server Side and Failblog.org are considered two different activities.

One downside of RescueTime is that it posts your usage statistics to their servers, so if you don’t want anyone to see how much time you spent… watching porn in the office, you might choose to disable RescueTime for a couple of hours. On the other side, your usage statistics are accessible only by you, so your boss can’t detract from your salary every 5 mins you spent checking your private mail.

Another downside is that it doesn’t show you when exactly did you start working with a particular program and when were you AFK. So you can’t distinguish between a meeting and a lunch break.

Both of these problems are solved by ManicTime. Manic time works only locally and gives you information on what did you do at an exact moment of the day: 

 

 

The only downside of ManicTime is that it is too fine grained so you don’t get the quick overview that you can get in RescueTime. Currently I’m using both of them until I decide which one is better or one of them implements the functionalities of the other.

In the distributed systems research area replication is mainly used to provide fault tolerance. The entity being replicated is a process. Two replication strategies have been used in distributed systems: Active and Passive replication.

In active replication each client request is processed by all the servers. Active Replication was first introduced by Leslie Lamport under the name state machine replication. This requires that the process hosted by the servers is deterministic. Deterministic means that, given the same initial state and a request sequence, all processes will produce the same response sequence and end up in the same final state. In order to make all the servers receive the same sequence of operations, an atomic broadcast protocol must be used. An atomic broadcast protocol guarantees that either all the servers receive a message or none, plus that they all receive messages in the same order. The big disadvantage for active replication is that in practice most of the real world servers are non‐deterministic. Still active replication is the preferable choice when dealing with real time systems that require quick response even under the presence of faults or with systems that must handle byzantine faults.

In passive replication there is only one server (called primary) that processes client requests. After processing a request, the primary server updates the state on the other (backup) servers and sends back the response to the client. If the primary server fails, one of the backup servers takes its place. Passive replication may be used even for non‐deterministic processes. The disadvantage of passive replication compared to active is that in case of failure the response is delayed.

We have received measurements from one of the remaining level 3 applications. It’s Immo’s implementation based on Ruby + Ramaze + MySQL. Here are the updated results:

As soon as we confirm the measurements and get the numbers for the ASP implementation we will publish the updated point chart.

Ever wondered what is the best technology stack for building web applications? I’m sure you have.

Last week my company went on a workshop, during which we tried to answer that question. I wrote a requirements specification for a simple web application. Everyone had to choose the technology stack they’re most familiar with and implement the application. Everyone received a benchmark script for the application and at the end of the day we compared the performance results. The application was just enough complex to require at least a day to implement. In the end we multiplied the performance by the level of functionality implemented.

The Application

The webapp I chose is the same one for the couldspeed project. It is based on the model of social networking applicatins. Once registered and logged in, users can add other users as friends and submit posts. The homepage will display the 20 most recent posts from all user’s friends including the user himself.

There are 2 entities each with 2 attributes:

• users(email, password)
• post(date, content)

and there are 2 relationships

• users are friends with other users (n to n)
• each post is written by a user (1 to n)

there are 2 web pages: login and home.

From the login page, users can register themselves or log in.

The home page displays the number of friends, the 20 most recent posts (for each post, the date, author and content) and allows users to add posts, friends or logout.

Information has to be persisted somehow.

The Benchmark

Each developer got a copy of JMeter and 3 scripts. The 3 scripts excercized 3 different levels of functionality:

1. Register Users – registered a number of users (100)
2. Make Friends – created around 10 friends per user
3. Post Stuff – posted messages

For the first level of functionality, the developer had to implement the functionality behind the Register button. Registered users had to be persisted. This level had a multiplier of 1.

For the second level of functionality, developers had to implement logging in, keeping session information, and the friendship relationship. The homepage should have shown the number of friends. This level had a multiplier of 3.

For the third level of functionality, developers had to implement everything: posting messages and showing the messages from all friends. Since this functionality included a complex query that ate a lot of processing power, the multiplier was 50.

The Contenders

Ben: Erlang + CouchDB

Team 2: Java + Spring + Hibernate + Postgres

Team 3: Java + Spring + Hibernate

Team 4: Ruby On Rails + MySQL

Team 5: ASP with Visual Basic + SQLServer

Immo: Ruby + Ramaze + MySQL

The Results

Only three of the contenders implemented level 3 of functionality, but we were able to measure the performance only for the erlang implementation. The other 2 that made it to the 3rd level were ASP+SQLServer and Ramaze. We will soon publish the results of the two missing level 3 implementations. 

The winner was Ben with 1111.1 points. Erlang + CouchDB proved to be quite fast and productive in the right hands.

Conclusions

Allthough just one day of development is not nearly enough to measure productivity, we noticed that choosing a particular language that promised a high level of productivity wasn’t as important as choosing the language you’re most familiar with.

Alltough Level 1 of functionality does not provide a meaningful scenario to measure performance, we can see that most of the implementations had the same performance, including Ruby, which has been measured to be 100 times slower than C++, but in our scenario it actually showed the best performance.

Allthough we must point out that both ruby implementations and the ASP implementation showed instability. Errors ranging from 15% to 30% were reported during the benchmarks.

As a comparison, I have done some java implementations before the competition. They all provide level 3 functionality. They all use Servlets in the web tier, but the DAO tier changes: we have JDBC with MySQL, EJB3 with MySQL and pure in memory.

Compared to the Erlang implementation wich serves 15 req/s I have similar results for the JDBC (15 req/s). A “heavyweigth” stack such as EJBs actually manages to produce 38 req/s, but by far the fastest solution is keeping everything in memory that brings us to an impressive 2000 req/s. Obviously the in memory solution cannot be compared to the others because it doesn’t satisfy the persistence requirement. But can still be used as a comparison to see how much performance do we loose on the persistence layer.

Future Work

We have had requests from other people that were not taking part of the competition to submit their implementations. Since we have no way to measure productivity, all submissions now require level 3 of functionality. All implementations will be published on the cloudspeed website. If you wish to contribute by improving an implementation or submitting your own just send me an email or leave a comment here.

Currently the benchmark is adapted to quickly give a very aproximative measure. 100 users is not a realistic number even for a small website. Our next goal is to create a benchmark that will register up to millions of users, have an average of 100 friends per user and post several million messages.

The final goal is to port these implementations to the cloud and measure their scalability. We don’t only want to see the performance on a single machine, but also how will the performance be when we reach the limits of a single server. Ideally we want to try to run these applications on clusters as big as we can get.

Stay tuned for updates…

Zuhlke Engineering is hosting a corporate networking event at Canada Square on the 20th November. There will be an informative one hour presentation, followed by lunch and a networking session.

Here is a short snippet from the leaflet:
Zuhlke will share thier experience in successfully helping CIO’s and Programme / Project Managers in Top Tier Banks and other Corporates to:

• Get the business on your side by capturing requirements in their language but with the precision you need
• Win the battle for budgets, ensuring the right level of project funding throughout
• Get compliance and audit without the pain
• Corner suppliers into delivering only high quality software

The speakers at the event are:
Prof. Dr. Wolfgang Emmerich (Chairman, Zuhlke UK)
Wolfgang is a Partner in the Zuhlke Technology Group of Switzerland. He was also co-founder of Zuhlke Engineering GmbH, Germany in 1998 and Zuhlke Engineering Ltd, London in 2001, where he is currently Chairman and part-time Principal Consultant, primarily to the investment banking sector.

Keith Braithwaite (Head of Zuhlke’s Centre for Agile Practice)
Keith is a Principal Consultant and Business Unit Leader with Zuhlke in the UK. He has trained, coached and managed development teams from New York to Sydney working on systems ranging from mobile telephone applications to enterprise scale financial systems. He is a regular presenter at conferences around the world.

This is a free event and seats are limited. If you would like to attend this event then please contact me.

Regards, Daryn

During my evaluation of highly scalable technologies I incurred in some performance problems with the EJB3 implementation. It seems to me that it is a quite common problem

Yesterday I was getting very dissappointing results from the benchmarks of the EJB3 implementation of the sample application. I have discovered some nice hints for optimizing Hybernate and EJB3 applications and a very good video on EJB3. This hepled me understand why my EJBs were not updated properly, but most of all why I was getting such poor performance.

The performance problem was due to the use of eager fetching on a many to many relationship. The relationship in question was friendship between users. This is a many to many relationship with itself. This means eager fetching is propagated transitively, so each time I loaded a user, all the friends were loaded as well, and also the friends of the friends and the friends of… basically the whole table.

By default many to many relationships use lazy fetching, but I changed this to eager when I wrote the application. The reason I had eager fetching on this relationship is that when I tried to get the number of friends a user had, my appserver was complaining that it couldn’t be done with lazy fetching. My error was in performing this through user.getFriends().size(). What I’m doing now instead is asking the database to give me the number of friends by using a query like “SELECT count(f) FROM user u JOIN u.friends f WHERE…”.

After that I changed some transaction attributes so that read only operations do not require transactions. Given the semantic of the methods I don’t require a strong level on consistency, so it’s relatively safe to do this. This minimizes delays due to contention and increases the paralellizability (try pronouncing this aloud) of the applications.

The result was that now my application runs 10 times faster. Now I’m getting 79 requests per second if I run the server on an EC2 instance and the client on my machine. This is just a little slower than the 100 requests per second obtained by the pojo in memoty solution, which means that EJB3 is pretty fast. I still have to test this without the communication bottleneck to be sure of the actual performance.

I have started a project for benchmarking highly scalable technologies. My plan is to use cloud computing platforms and implement the same application using different stacks of technologies. The aspect I want to evaluate is performance when the number of nodes grows a lot.

Application specification
The application I’m using for benchmarking is a simplified model of Facebook.

Implementations
Currently I have 2 implementations:
Servlets + EJB3
Servlets + in memory Java

Benchmark
As benchmarking client I’m using JMeter.
The benchmark looks like this: a number of threads will start iterating over the following sequence

1. load first page (redirection)
2. load login page
3. login
4. load main page
5. add post
6. add friend
7. logout

There are no pauses so in theory, this should test the capacity of the server.

Ideally there would be a very large number of threads (users) performing requests occasionally.

Configurations tested
I have tested everything on my machine before deploying on EC2. I have used JBoss and MySql for the EJB solution.
The performance I obtained was around 10 requests per second, which is dissapointing. Probably I have a bottleneck somewhere and need to configure things properly.
The In Memory Java implementation achieves more than 1000 requests per second, which is 100 times faster than using EJBs. However it occasionally throws ConcurrentModificationExceptions because I’m not synchronozing properly (fixing this will lower performance).

Then I deployed everything on one EC2 instance.
When I run the client on the outside I get around 100 requests per second, which may be due to my internet connection speed. But when I execute the client on another EC2 instance, I expect no communication bottlenecks. Instead I get 3 requests per second. Either there is a huge traffic jam on the EC2 internal network or I have misconfigured the benchmark client.
Running the benchmark on the EJB3 implementation shows a performance of 7 requests per second.

Next thing I need to do is some EJB3 tuning. I have the feeling I have not set up transactions correctly.
If you have any suggestion or wish your technology stack to be evaluated or perhaps want to contribute, please leave a comment.

Index | Part 1 | Part 2 | Part 3 | Part 4 | Part 5

5. Development and Debugging Tools

5.1. Documenting JavaScript

JSDoc is an open source tool used to add inline documentation to JavaScript source files. JSDoc is based on the javadoc tool. Many of the javadoc characteristics have been included in JSDoc. An example of using JSDoc can be found here.

5.2. Firefox Tools & Extensions

DOM Inspector is included in the Mozilla Suite and Firefox browser. This tool provides a graphical user interface that enables a user to brows the document object model of any site. One can view, update and insert DOM attributes dynamically. In order to assist JavaScript developers, DOM Inspector can be switched to JavaScript Object mode. This shows all the properties and methods available to a JavaScript for a particular mode. DOM Inspector provides a JavaScript evaluation window that allows the user to execute JavaScript against selected nodes. There is the option to use CSS Style Rules and Computed Style information. This allows a user to examine the CSS attributes associated with different page elements.

Firefox JavaScript Console is a tool that logs JavaScript errors found on a page when the page is rendered. The Firefox JavaScript Console gives ‘compiler-type’ messages. It describes the error that occurred and the gives the line number.

Firebug integrates with Firefox and provides many development tools. Firebug has a version of a DOM inspector that enables a developer to find elements. CSS support allows settings to be altered and viewed. Firebug allows one to monitor the network activity in order to determine how long it takes for different sections of a page to download. A JavaScript Debugger allows one to debug and step through the JavaScript at runtime.

HTML Validator is a Mozilla extension that performs HTML validation within Firefox and Mozilla. HTML Validator validates the HTML locally and does not use a remote third party. The number of errors of a HTML page is seen on the form of an icon in the status bar when browsing. HTML Validator offers a set of tools to assist in validating and correcting HTML tags.

Checky is Firefox extension tool for validating HTML. In addition to HTML, Checky can validate XHTML, CSS, RDF, RSS, XML and many more formats. Checky sends the source to third-party cites to be validated. The third-party cites may be free or commercial services.

Pederick’s Firefox Web Developer extension offers a large set of tools for a website developer. Web Developer provides an extensive set of tools, from highlighting table cells to converting ‘GET’ requests to ‘POST’ requests. This toolbar contains more than 80 tools and is an essential commodity.

5.3. JavaScript Syntax Checking

JSLint is an online tool that evaluates JavaScript code. JSLint scans the JavaScript code and identifies syntax errors, structural problems and questionable coding-style conventions.

5.4. Compression and Obfuscation

MemTronic’s FREEWARE HTML/JavaScript Cruncher-Compressor is a freeware tool that can perform both compression and obfuscation. The MemTronic’s website provides the following information. The tool can Crunch, Compress and Obfuscate. Crunching removes all comments and whitespace. Crunching has a bandwidth saving between 20%-50%. Compressing will compress the script with a real compression-scheme, with auto decompression added to the file. This results in bandwidth savings between 40% – 90%. The obfuscator has not been released at this stage. Once complete this tool will encode the script into a format that humans can not easily read. When using Compress, the file will undergo a level of obfuscation.

Index | Part 1 | Part 2 | Part 3 | Part 4 | Part 5

Posted in AJAX, Technologies Tagged: AJAX, JavaScript, Tools ]]> Daryn http://feedproxy.google.com/~r/ItsNotPersonal/~3/mIvfs16AqCg/its-not-personal-darren-on-flex.html <img src="http://feeds.feedburner.com/~r/ItsNotPersonal/~4/mIvfs16AqCg" height="1" width="1"/> noreply@blogger.com (Darren Bishop) tag:blogger.com,1999:blog-3826577489563855618.post-7772317346601653485 Mon, 22 Sep 2008 12:38:00 -0700 http://feedproxy.google.com/~r/ItsNotPersonal/~3/3ZlWzc0Z-TA/darren-on-flex-overloading-constructor.html <img src="http://feeds.feedburner.com/~r/ItsNotPersonal/~4/3ZlWzc0Z-TA" height="1" width="1"/> noreply@blogger.com (Darren Bishop) tag:blogger.com,1999:blog-3826577489563855618.post-891141856223849476 Sun, 21 Sep 2008 03:45:00 -0700 http://feedproxy.google.com/~r/ItsNotPersonal/~3/qvA3lLdLnPc/darren-on-flex-new-flexunit-out.html <img src="http://feeds.feedburner.com/~r/ItsNotPersonal/~4/qvA3lLdLnPc" height="1" width="1"/> noreply@blogger.com (Darren Bishop) tag:blogger.com,1999:blog-3826577489563855618.post-8796253195330868124 Sat, 20 Sep 2008 01:41:00 -0700 http://change-challenge.blogspot.com/2008/09/basics-of-web-site-optimisation-rule-12.html This post is mainly aimed at small to medium businesses that are just starting out and are keen to get something going, or have just gone live. I can't tell you how many times I have taught people over the past few years just a handful of strategically important things. So...here goes again, this time in a way that I can now simply refer to. As for my credibility - I would rather not divulge that here, read my <a rel="nofollow" target="_blank" href="http://change-challenge.blogspot.com/search/label/web%20site%20optimisation">Web Site Optimisation Rules</a> and you decide. They are, after all, common sense, and common knowledge....like most things I blog about!<br /><br /><strong>My number 12 rule: Test your own site with multiple web browsers!</strong><br /><br />These days it takes just a few minutes to download and install different web browsing possilibities and I recommend you do it to test your own site. Nothing compares to a quick visual check that your web site still looks okay, or better, than doing so in a browser that you maybe do not often use.<br /><br /><a rel="nofollow" target="_blank" href="http://change-challenge.blogspot.com/2008/07/basics-of-web-site-optimisation-rule-4.html">Analyse your web traffic analysis reports</a> to check which browsers account for 90-95% of your traffic and then make sure that 90-95% of the time your site renders/displays as you wish it to. <br /><br />Also using your traffic analysis reports, you can verify which of your visitors turned into form submitters and became potential customers. Make sure your forms work correctly in their browsers before you publish changes!!<br /><br /><span style="font-weight:bold;">Reasoning:</span><br />1. It is just so darn tricky to know for sure that even if you are following the standards perfectly, the web browsers may not be. Best to check it out visually, using the tools that your clients use.<br />2. It is very quick and simple to do - so do it. You will also see your site in new ways that might lead to further design benefits.<br /><br />And that is my Rule 12. I will be uploading the others as time allows!<div class="blogger-post-footer"><img width='1' height='1' src='https://blogger.googleusercontent.com/tracker/6989989674376899020-2710034772162741011?l=change-challenge.blogspot.com'/></div> Rob Brown tag:blogger.com,1999:blog-6989989674376899020.post-2710034772162741011 Mon, 08 Sep 2008 09:00:00 -0700 http://21ccw.blogspot.com/2008/09/iterative-and-agile-venn-diagram-of.html <div>I'm seeing a bit of this lately:<span class="Apple-tab-span" style="white-space:pre;"> </span></div><div><span class="Apple-style-span" style="font-style:italic;"><br /></span></div><div><span class="Apple-style-span" style="font-style:italic;">"Iterative software development is Agile software development."</span></div><div><span class="Apple-style-span" style="font-style:italic;"><br /></span></div><div>and I have to say that I disagree quite strongly. The Venn diagram actually looks more like this:</div><div><br /></div><div><img src="http://1.bp.blogspot.com/_bXDgUoT7V7o/SOI-BbG_ZmI/AAAAAAAAAIE/DfiQYsrWfI0/s400/agile_venn.png" style="display:block;margin:0px auto 10px;text-align:center;cursor:pointer;cursor:hand;" border="0" alt="" id="BLOGGER_PHOTO_ID_5251828309645289058"/></div><div><br /></div><div>This post has been prompted by two things. First, a few weeks ago a SCRUMmer made some comments along the following lines:<br /></div><div><ul><li><span class="Apple-style-span" style="font-style:italic;">"We don't allow changing the iteration plan once the iteration has begun" </span><br /></li><li><span class="Apple-style-span" style="font-style:italic;">"All the requirements for the stories for the iteration must have been gathered before it starts."</span><br /></li><li><span class="Apple-style-span" style="font-style:italic;">"If the customer want something else, they have to wait for the next iteration"</span></li></ul></div><div>And some <a rel="nofollow" target="_blank" href="http://www.infoq.com/news/2008/09/Short-Iterations-Mishkin-Berteig">articles</a>/<a rel="nofollow" target="_blank" href="http://agile-commentary.blogspot.com/2008/09/shorten-your-iteration.html">blogs</a> about iteration lengths that jogged my memory about what I disagreed with. The root of my discomfort in equating iterative development to agile development is because</div><div><br /></div><div><span class="Apple-style-span" style="font-style:italic;">agile software development is a set of values, it is not a process. </span></div><div><br /></div><div>In fact, one of the core values of Agile development is to <span class="Apple-style-span" style="font-style:italic;">not</span> value you process too much. There are some processes that try to embody Agile values, and they have different interpretations and practicalities around those values, but these <span class="Apple-style-span" style="font-style:italic;">processes</span> are not what defines <span class="Apple-style-span" style="font-style:italic;">Agile</span> development. </div><div><br /></div><div>Here's a <a rel="nofollow" target="_blank" href="http://agilemanifesto.org/">reminder</a> of what it means to be agile:</div><div><div><ul><li><span class="Apple-style-span" style="font-weight:bold;">Individuals and interactions</span> over processes and tools <br /></li><li><span class="Apple-style-span" style="font-weight:bold;">Working software</span> over comprehensive documentation <br /></li><li><span class="Apple-style-span" style="font-weight:bold;">Customer collaboration</span> over contract negotiation <br /></li><li><span class="Apple-style-span" style="font-weight:bold;">Responding to change</span> over following a plan <br /></li></ul></div></div><div>It's very possible to do iterative development without embodying <span class="Apple-style-span" style="font-style:italic;">any</span> of these values. Treating each iteration like a waterfall with the usual waterfall suspects (requirements up front, little room for manoevering, opressive specification and documentation) is a case in point. And to me, valuing your plan over your customer by not responding to their needs is <span class="Apple-style-span" style="font-style:italic;">not</span> Agile.</div><div><br /></div><div>You are, of course, invited to disagree...</div><div><br /></div><div class="blogger-post-footer"><img width='1' height='1' src='https://blogger.googleusercontent.com/tracker/7435412383881764254-5384711924776737130?l=21ccw.blogspot.com'/></div> Benjamin Nortier tag:blogger.com,1999:blog-7435412383881764254.post-5384711924776737130 Sun, 07 Sep 2008 22:31:00 -0700 http://21ccw.blogspot.com/2008/09/me-and-my-dog-on-google-chrome.html Like every man and his dog I feel compelled to say something about <a rel="nofollow" target="_blank" href="http://www.google.com/chrome">Chrome</a>, Google's new browser. Most impressions I have read have been favourable, and my personal experience so far is very positive. Most reviews I have scanned have been thumbs-up, and have focussed on the usual suspects, i.e. rendering and javascript performance, stability, usability etc. etc.<div style="text-align:center;"><br /></div><div>For me, there is something subtle and extremely powerful that comes with Chrome. It fields a combination of features with very powerful implications. A "whole being more that the sum of the parts" kind of situation.<br /></div><div style="text-align:center;"><br /></div><div>In the past year or two there has been a lot of focus in the "richer" web experience, and on ways of getting the web to feel more like the desktop. Newish technologies like Flex and Silverlight have received significant attention, and DHTML (Javascript+CSS+DOM+HTML) seems to have become the cousin that you are obliged to invite to your wedding party (or application party), but don't really want to. I believe that part of the reason for this has been Javascript performance, but there are several efforts underway (e.g. TraceMonkey and now Chrome's V8 Javascript engine) that will bring huge leaps in performance to Javascript. Also, I prefer to support non-proprietary technologies such as DHTML over vendor-based alternatives like Flex and Silverlight.</div><div style="text-align:center;"><br /></div><div>The second feature that's important in Chrome is process isolation for tabs. This enables each tab to be completely isolated from other processes. One tab going down doesn't take the whole browser with it (which is something that has plagued my Firefox quite a bit).</div><div style="text-align:center;"><br /></div><div>Thirdly, we have "application-like" OS integration in Chrome. Chrome has the ability to make a single tab look like an application window, with normal window decorations:</div><div><br /></div><div><img src="http://3.bp.blogspot.com/_bXDgUoT7V7o/SMUU8kz1zyI/AAAAAAAAAH8/B0hxkM8SvUQ/s400/titlebar.png" style="display:block;margin:0px auto 10px;text-align:center;cursor:pointer;cursor:hand;" border="0" alt="" id="BLOGGER_PHOTO_ID_5243620372048629538"/></div><div><br /></div><div>In your taskbar it looks like an application, there is quick lauch icon for you app:</div><div><br /></div><div><img src="http://4.bp.blogspot.com/_bXDgUoT7V7o/SMUTlKE0ksI/AAAAAAAAAHs/P4OOCC6YjoI/s400/taskbar.png" style="display:block;margin:0px auto 10px;text-align:center;cursor:pointer;cursor:hand;" border="0" alt="" id="BLOGGER_PHOTO_ID_5243618870223475394"/>There's also a Start Menu item (not shown) and a Desktop icon:</div><div><br /></div><img src="http://3.bp.blogspot.com/_bXDgUoT7V7o/SMUT16R0EhI/AAAAAAAAAH0/pMHvbHYvCzI/s400/shortcut.png" style="display:block;margin:0px auto 10px;text-align:center;cursor:pointer;cursor:hand;" border="0" alt="" id="BLOGGER_PHOTO_ID_5243619158040777234"/><div><br />The combination of these three is a significant step towards blurring the lines between the desktop and the web. Chrome is an application platform with (potentially) desktop-like application performance (DHTML + V8), process isolation (a key feaure of an application platform) and the web apps look like desktop apps (Operating system integration). And it's all standards based.<br /><br />There have been some rumours of a Google OS...<br /><br />You're looking at it.<br /></div><div class="blogger-post-footer"><img width='1' height='1' src='https://blogger.googleusercontent.com/tracker/7435412383881764254-4962382545561174872?l=21ccw.blogspot.com'/></div> Benjamin Nortier tag:blogger.com,1999:blog-7435412383881764254.post-4962382545561174872 Wed, 03 Sep 2008 02:29:00 -0700 http://change-challenge.blogspot.com/2008/09/basics-of-web-site-optimisation-rule-11.html This post is mainly aimed at small to medium businesses that are just starting out and are keen to get something going, or have just gone live. I can't tell you how many times I have taught people over the past few years just a handful of strategically important things. So...here goes again, this time in a way that I can now simply refer to. As for my credibility - I would rather not divulge that here, read my <a rel="nofollow" target="_blank" href="http://change-challenge.blogspot.com/search/label/web%20site%20optimisation">Web Site Optimisation Rules</a> and you decide. They are, after all, common sense, and common knowledge....like most things I blog about!<br /><br /><strong>My number 11 rule: Do not use JavaScript for navigation effects, especially not dynamic menus</strong><br /><br />JavaScript is a small very powerful programming language for programming web sites in order to give them more functionality than is available in straight static HTML. It is a fantastic language from many perspectives that I will not go into on this entry. People use it to do form validations, image manipulation, dynamic menus and other miscellaneous bits that need to respond to whatever the visitor is doing, or where the visitor comes from in order for the visitor to have an interactive experience with the web site.<br /><br />Read more about JavaScript at <a rel="nofollow" target="_blank" href="http://en.wikipedia.org/wiki/JavaScript">wikipedia</a>.<br /><br />I follow the mantra "Use as little JavaScript as possible, whilst still making the web site look good, and work well." I use <a rel="nofollow" target="_blank" href="http://change-challenge.blogspot.com/2008/07/basics-of-web-site-optimisation-rule-7.html">CSS</a> as much as possible to make it look good, and as little JavaScript as possible to provide a little tasteful motion, and to do some form validation in order to partially constrict the flood of the requests that could otherwise be submitted via the contact <a rel="nofollow" target="_blank" href="http://change-challenge.blogspot.com/2008/07/basics-of-search-engine-optimisation.html">forms</a>.<br /><br /><span style="font-weight:bold;">Reasoning:</span><br />1. Search engines can not follow dynamic Java Script menus, thus large parts of your site will go unindexed.<br />2. Your site will appear smaller and less important to the search engines when they rank you against your competitors.<br />3. Your site will appear badly organised and less usable to the search engines when they rank you against your competitors.<br />4. Different versions of browsers treat JavaScript differently, meaning even more testing and "fiddling" in order to get your JavaScript to work correctly and consistently across all your targetted browsers.<br /><br />And that is my Rule 11. I will be uploading the others as time allows!<div class="blogger-post-footer"><img width='1' height='1' src='https://blogger.googleusercontent.com/tracker/6989989674376899020-8506782475946997983?l=change-challenge.blogspot.com'/></div> Rob Brown tag:blogger.com,1999:blog-6989989674376899020.post-8506782475946997983 Tue, 02 Sep 2008 11:00:00 -0700 http://change-challenge.blogspot.com/2008/09/getting-around-in-locked-down.html I probably should not really be blogging this little entry, but I just can't help myself! Please continue reading or using these little details at your own peril.<br /><br />Recently I discovered myself in a "locked down" environment, yet I still had a tonne of software to install, and I desperately needed it installed "today" rather than after 1 month. (the contract in this case was for this primary purpose - installations, configurations and support) (something completely different to what I've been doing for many years now, but not so different from what I was doing 10 odd years ago, so I had the skills)<br /><br />My first step in any new site is to meet as many people as I can, and then to make friends with those that I desperately need, in the order that I need them. It is a hard cold fact, and they know it, and I know it. I am ... for want of a better word ... using them. By doing this though, I suddenly start avoiding official processes, official documents filled out in triplicate, and actually get things done rather quickly. Which makes me look good, compared to the rule followers.<br /><br />So with enough friends on my side, around day 2, I learned 1 useful tidbit about the so-called "locked down environment".... it is not so locked down as made out to be. Thanks to XP's security model, the thing that really enforces lockdown policies is done via LDAP ... when you login or logout of the domain.<br /><br />And again, with enough friends on my side, I managed to secure just a slightly better than completely useless level of workstation usage. And here comes the fun bit. Many of the GUI widgets for changing a workstation are stripped out of your view, and some that could not be stripped throw you an error message if you try to access them.<br /><br />So ... you find the command line equivalent and use that instead. No security to stop you. Thank goodness for XP! I have no idea what I'll do if I find myself in a Vista or better security modelled domain with the same deadlines - probably make even more friends instead, and take them to the pub every other lunch!<br /><br />Here are the 4 that I am using frequently:<br /><br />regedit - reg.exe<br />Data Sources (ODBC) - odbcad32.exe<br />RemoteDesktop - mstsc.exe<br />Add/Remove programs - MSIexec<br /><br />I am sure there are others, but fortunately I have not needed more than these so far!<div class="blogger-post-footer"><img width='1' height='1' src='https://blogger.googleusercontent.com/tracker/6989989674376899020-6106976009202070178?l=change-challenge.blogspot.com'/></div> Rob Brown tag:blogger.com,1999:blog-6989989674376899020.post-6106976009202070178 Tue, 02 Sep 2008 07:57:00 -0700 http://change-challenge.blogspot.com/2008/08/basics-of-web-site-optimisation-rule-10.html This post is mainly aimed at small to medium businesses that are just starting out and are keen to get something going, or have just gone live. I can't tell you how many times I have taught people over the past few years just a handful of strategically important things. So...here goes again, this time in a way that I can now simply refer to. As for my credibility - I would rather not divulge that here, read my <a rel="nofollow" target="_blank" href="http://change-challenge.blogspot.com/search/label/web%20site%20optimisation">Web Site Optimisation Rules</a> and you decide. They are, after all, common sense, and common knowledge....like most things I blog about!<br /><br /><strong>My number 10 rule: Create a web site/shortcut icon</strong><br /><br />This is one of the simplest and most overlooked goodies in a web site's "bag of tricks"!<br /><br />Ever wonder why some web sites have a little icon in the address bar? For instance the little white-on-orange background "B" in the address bar right now? It is because they have created a "favicon.ico" in the root of their web directory. Not only is it displayed by the browser in the address bar when your visitor visits, but if the visitor bookmarks it, it is displayed in the bookmark view as well - which makes your site stand out from all the others without favicon.ico's! (and vice-versa, makes your site stand out stand out negatively, if all the others do)<br /><br />The favicon.ico's that I have created were all based on the old specification of 16x16 pixels in the icon format. These days it is possible to use bigger images, with different formats, but I am still preferring the older specification as it is a very small overhead for your visitor and whatever old browser they may be using 5 years from now. Read more on <a rel="nofollow" target="_blank" href="http://en.wikipedia.org/wiki/Favicon">wikipedia's Favicon entry</a>!<br /><br /><span style="font-weight:bold;">Reasoning:</span><br />1. This is more a marketing and branding tool/optimisation than a search engine optimisation. It is extremely subtle in the world of too many messages and by using it, you have an opportunity to reinforce your company/site's brand in the visitor's mind - a very good thing. In the world of marketing, brand awareness is key - no one is going to buy "you" if they don't even "know you" - so first seek to build awareness, then start your "trust campaign". <br />2. It looks professional and is becoming expected these days<br />3. And a reminder waiting for each bookmarker is a great place to be<br /><br />And that is my Rule 10. I will be uploading the others as time allows!<div class="blogger-post-footer"><img width='1' height='1' src='https://blogger.googleusercontent.com/tracker/6989989674376899020-4459796110543026020?l=change-challenge.blogspot.com'/></div> Rob Brown tag:blogger.com,1999:blog-6989989674376899020.post-4459796110543026020 Sun, 24 Aug 2008 23:00:00 -0700 http://feedproxy.google.com/~r/ItsNotPersonal/~3/oVTZKG9XIIE/whiteboarding-with-rails-and-tomcat.html <img src="http://feeds.feedburner.com/~r/ItsNotPersonal/~4/oVTZKG9XIIE" height="1" width="1"/> noreply@blogger.com (Darren Bishop) tag:blogger.com,1999:blog-3826577489563855618.post-4227173962273152031 Sun, 24 Aug 2008 02:30:00 -0700 http://feedproxy.google.com/~r/ItsNotPersonal/~3/fRLb68OxsSk/ror-passengermodrails-tomcat6comet-part.html <img src="http://feeds.feedburner.com/~r/ItsNotPersonal/~4/fRLb68OxsSk" height="1" width="1"/> noreply@blogger.com (Darren Bishop) tag:blogger.com,1999:blog-3826577489563855618.post-5330744053238147188 Sun, 24 Aug 2008 01:54:00 -0700 http://change-challenge.blogspot.com/2008/08/basics-of-web-site-optimisation-rule-9.html This post is mainly aimed at small to medium businesses that are just starting out and are keen to get something going, or have just gone live. I can't tell you how many times I have taught people over the past few years just a handful of strategically important things. So...here goes again, this time in a way that I can now simply refer to. As for my credibility - I would rather not divulge that here, read my <a rel="nofollow" target="_blank" href="http://change-challenge.blogspot.com/search/label/web%20site%20optimisation">Web Site Optimisation Rules</a> and you decide. They are, after all, common sense, and common knowledge....like most things I blog about!<br /><br /><strong>My number 9 rule: Use these 9 Meta Tags</strong><br /><br />These are probably "over kill" as far as Meta Tag usage is concerned, but I prefer this approach to lesser, until I learn something concrete that differs from my experience which has seen some rapid and sustained visitor rate growth where I applied them.<br /><br />Place Meta Tags in all of your page header sections. There are smart tools for generating the content-related ones, but it is better if they fit into your whole marketing and supporting web site design approach, making them very manageable in a manual way on static web sites. On dynamic, use a clever algorithm to assist you in carefully crafted statements.<br /><br />Make sure the web page content, including words, links, image names - everything where you can specify text, all aligns with the Keywords, Description and Abstract Meta Tags!<br /><br />&lt;META name="Keywords" content="<span style="font-style:italic;">[5 comma separated keywords that are present at least twice or more on the page!]</span>"&gt;<br /><br />&lt;META name="Description" content="<span style="font-style:italic;">[enter a short statement containing as many of the keywords as possible]</span>"&gt;<br /><br />&lt;META name="Date" content="<span style="font-style:italic;">[last update date]</span>"&gt;<br /> - NOT STRICTLY meta tag legitimate or required but I use it to track the date I last made a change to the page - and use this date to facilitate track which page version search engines have in their cache<br /><br />&lt;META name="abstract" content="<span style="font-style:italic;">[enter a short statement containing as many of the keywords as possible, possibly reusing the Description meta tag]</span>"&gt;<br /><br />&lt;META name="revisit-after" content="<span style="font-style:italic;">[a number that is tuned to the amount of maintenance you do on the site - initially I use 7 because I perform so much tuning and generally I roll out content in a staged approach to ensure high quality and maintain control over the site's visitor growth]</span> days"&gt;<br /><br />&lt;META name="rating" content="<span style="font-weight:bold;">general</span>"&gt; <br /> - there are a number of options here for instance "adult", but I only use general<br /><br />&lt;META name="next" content="<span style="font-style:italic;">[choose or use your site metrics to research the next web page from your site that most visitors normally go to]</span>"&gt;<br /> - some web browsers (Firefox) will pre-cache the html page you specify here, making the user experience of your web site seem quicker, if they actually follow your "directions". Very difficult to get right without careful web site design, and if wrong actually wastes your visitors' bandwidth and makes their internet experience slower unnecessarily.<br /><br />&lt;META name="robots" content="<span style="font-weight:bold;">index,follow</span>"&gt;<br /> - instruct search engines to index this web page, and follow all links on the page<br /> - in the old days of restricted bandwidth, and depending on what I was marketing on the site, I would instruct the search engine to "noindex"<br /><br />&lt;META content="<span style="font-weight:bold;">text/html; charset=ISO-8859-1</span>"&gt;<br /> - very important to clarify to the web browsers what the page content is, and which character set is intended otherwise some foreign visitors could end up with strange symbols unintentionally, making your web site difficult to use<br /><br />Reasoning:<br />1. By using Meta Tags at all the search engines will rank you higher<br />2. By using the correctly completed Meta Tags, the search engines will rank you even higher<br />3. They should repeat your key messages you are trying to convey to your visitors - they serve as a check point for detecting if your message is clear and the page is correctly aligned to achieve maximum impact at the search engines AND visitors<br />4. Search engine spiders, web crawling bots, web caching servers and even web site blocker software use the tags in their "decision" software to decide whether to analyse, cache, or allow the page to be displayed. <br /><br />And that is my Rule 9. I will be uploading the others as time allows!<div class="blogger-post-footer"><img width='1' height='1' src='https://blogger.googleusercontent.com/tracker/6989989674376899020-5779119171363209219?l=change-challenge.blogspot.com'/></div> Rob Brown tag:blogger.com,1999:blog-6989989674376899020.post-5779119171363209219 Sat, 23 Aug 2008 11:35:00 -0700 http://change-challenge.blogspot.com/2008/08/light-motivational-relief.html <a rel="nofollow" target="_blank" href="http://www.despair.com/viewall.html">Despair.com</a> for wonderful miscellaneous motivational posters and sayings....all twisted into a very cynical viewpoint. It is a really good laugh!<div class="blogger-post-footer"><img width='1' height='1' src='https://blogger.googleusercontent.com/tracker/6989989674376899020-698758842934802105?l=change-challenge.blogspot.com'/></div> Rob Brown tag:blogger.com,1999:blog-6989989674376899020.post-698758842934802105 Sat, 16 Aug 2008 06:43:00 -0700 http://change-challenge.blogspot.com/2008/08/basics-of-web-site-optimisation-rule-8.html This post is mainly aimed at small to medium businesses that are just starting out and are keen to get something going, or have just gone live. I can't tell you how many times I have taught people over the past few years just a handful of strategically important things. So...here goes again, this time in a way that I can now simply refer to. As for my credibility - I would rather not divulge that here, read my <a rel="nofollow" target="_blank" href="http://change-challenge.blogspot.com/search/label/web%20site%20optimisation">Web Site Optimisation Rules</a> and you decide. They are, after all, common sense, and common knowledge....like most things I blog about!<br /><br /><strong>My number 8 rule: Register on Web Directories</strong><br /><br />Web Directories are huge databases of links and brief descriptions of web sites, and usually are maintained by actual humans. They are not Search Engines, but in some ways they are similar because they try to get (encourage web masters/site owners) to register on them so that they become ever bigger repositories of information that is similar to library catalogues.<br /><br />To be accepted, your site needs to be up to a certain standard - which is a good thing! The editors of these Web Directories see 1000's of sites and it should be reassuring to you that someone has assessed your application form, and your web site, and found you/your idea/your web site acceptable to the rest of the world!<br /><br />For more up to the date information of the Web Directories, access wikipedia's <a rel="nofollow" target="_blank" href="http://en.wikipedia.org/wiki/List_of_web_directories">List of Web Directories</a> and get registered everywhere suitable!<br /><br />Your time is obviously limited and therefore over time it is apparent that in general the most important one is the <a rel="nofollow" target="_blank" href="http://dmoz.org/">Open Directory Project</a>. Be very careful to select the right categorisation for your web site. VERY CAREFUL! Like all good information clustering, and all good search engine ranking systems, things need to be as aligned as possible for optimal benefit. Be as specific with your categorisation as possible, and make sure your web site is reflecting that profile!!<br /><br /><strong>Reasoning:</strong><br />1. All of the major search engines use the web directories as a starting point for their "entire web crawl". <br />2. Search engines rate sites that are reviewed by real human editors of various Web Directories and accepted in them, quite highly. <br />3. Search engines will use the web directory classification of your web site to create a cluster for your site, and clustered information/sites rank more highly than complete "unknowns" for search engines.<br />4. While you are registering, and you are accepted, you will find competitor web sites that you can examine for marketing insights.<br />5. After you are accepted, it should be possible for you to form alliances (link swap) with some of the other sites registered in the same area, or in similar but alternate categories of the web directory - a very good thing!<br /><br />And that is my Rule 8. I will be uploading the others as time allows!<div class="blogger-post-footer"><img width='1' height='1' src='https://blogger.googleusercontent.com/tracker/6989989674376899020-6676775685111844526?l=change-challenge.blogspot.com'/></div> Rob Brown tag:blogger.com,1999:blog-6989989674376899020.post-6676775685111844526 Fri, 15 Aug 2008 05:00:00 -0700 http://change-challenge.blogspot.com/2008/07/basics-of-web-site-optimisation-rule-7.html This post is mainly aimed at small to medium businesses that are just starting out and are keen to get something going, or have just gone live. I can't tell you how many times I have taught people over the past few years just a handful of strategically important things. So...here goes again, this time in a way that I can now simply refer to. As for my credibility - I would rather not divulge that here, read my <a rel="nofollow" target="_blank" href="http://change-challenge.blogspot.com/search/label/web%20site%20optimisation">Web Site Optimisation Rules</a> and you decide. They are, after all, common sense, and common knowledge....like most things I blog about!<br /><br /><span style="font-weight:bold;">My number 7 rule: Use Cascading Style Sheets (CSS) to configure your site's look and feel and store in separate files</span><br /><br />Most of the target audience of these rules I am writing up, commission web sites from friends, or friend-of-friends, or recommendations of small web site development shops ... who don't seem to know, or know enough about Cascading Style Sheets (CSS).<br /><br />The basics are that with your CSS stored in a separate file, you can edit the look and feel of your entire web site, without having to know much about what you are doing. CSS is a very simple and easy to understand configurable set of options for which there are a large number of cheap (and free even) tools to help you make your site exactly the way you would like - independently of some technical person. (I once taught a very busy CEO just enough about CSS for him to take ownership of that aspect of his 1000 page web site!). You name the different sets something useful which makes them easier to use throughout your site such as "ProductDescription".<br /><br />People who implement web sites typically are more interested in the underlying functionality and more technical aspects than about how pretty it looks, or how well it matches the site owner's evolving branding efforts. By making use of CSS, anyone can be placed in charge of actually experimenting and figuring out ideal combinations of colours and font styles, text sizes, margins, borders and spacings that work in harmony together to create a truly unique and excellent user web experience.<br /><br />To see what you can do with CSS's, have a look at <a rel="nofollow" target="_blank" href="http://www.csszengarden.com/">The CSS Zen Garden</a>. This site contains beautiful samples of completely different CSS competitive entries for the same web page...and it is completely amazing with what the entrants have come up with - radical differences!<br /><br />In some ways this CSS rule is related to my rule 5: <a rel="nofollow" target="_blank" href="http://change-challenge.blogspot.com/2008/07/basics-of-web-site-optimisation-rule-5.html">Comply with web standards - html</a> as CSS's are also governed by <a rel="nofollow" target="_blank" href="http://www.w3.org/">W3C</a> standards! You can teach yourself about them by following the <a rel="nofollow" target="_blank" href="http://www.w3schools.com/css/">CSS Tutorials</a> from the W3C.<br /><br />And, because there is a standard for them, the W3C have once again provided an online checking facility for you to use to validate your own, or your supplier's efforts: simply submit your HTML or CSS web document to the <a rel="nofollow" target="_blank" href="http://jigsaw.w3.org/css-validator/">Online Cascading Style Sheet (CSS) Checker</a>.<br /><br /><span style="font-weight:bold;">Reasoning:</span><br />1. With CSS you can evolve really really very good looking web sites! It is almost impossible to get a web site perfect in just 1 attempt!<br />2. Anyone can configure and maintain them - making your site's look and feel very easy to update and preferably maintained by someone who really cares!<br />3. Separate your CSS definitions from your HTML web pages by placing them in separate files that you include in your header tags. Web browsers cache the CSS definition files and thus your HTML pages are smaller, easier to maintain, faster to download and even more focussed for search engine optimisation strategies.<br />4. By using CSS's it is possible to test updates of the look and feel against the production web site without having to go live first! It is possible to configure modern web browers to use alternatve CSS definition files against any web site! <br /><br />And that is my Rule 7. I will be uploading the others as time allows!<div class="blogger-post-footer"><img width='1' height='1' src='https://blogger.googleusercontent.com/tracker/6989989674376899020-4491447486111732540?l=change-challenge.blogspot.com'/></div> Rob Brown tag:blogger.com,1999:blog-6989989674376899020.post-4491447486111732540 Mon, 04 Aug 2008 06:57:00 -0700 http://21ccw.blogspot.com/2008/07/scalaris-released.html If you were at the <a rel="nofollow" target="_blank" href="http://www.erlang-exchange.com/">Erlang Exchange</a> in London last month, you should know that one of the hottest talks was given by <a rel="nofollow" target="_blank" href="http://erlang-exchange.com/alexander-reinefeld">Alexander Reinefeld</a>, "<a rel="nofollow" target="_blank" href="http://skillsmatter.com/podcast/erlang/building-a-transactional-distributed-data-store-with-erlang">Building a transactional distributed data store with Erlang</a>"<br /><br />Joe Armstrong seems to like it too:<br /><br />"I might be wrong, but my gut feeling is that what Alexander Reinefeld showed us will be the first killer application in Erlang."<br /><br />"So my take on this is that this is one of the sexiest applications I've seen in many a year. I've been waiting for this to happen for a long while. The work is backed by quadzillion Ph.D's and is really good <span style="font-style:italic;">believe me."<br /><br /></span>- http://armstrongonsoftware.blogspot.com/2008/06/itching-my-programming-nerve.html<br /><br />Well, seems like Scalaris has been released! The link went up on the website in the last 24-48 hours. I haven't had the time to look at it yet, but you can grab it <a rel="nofollow" target="_blank" href="http://code.google.com/p/scalaris/">here</a>.<div class="blogger-post-footer"><img width='1' height='1' src='https://blogger.googleusercontent.com/tracker/7435412383881764254-1549559424813718640?l=21ccw.blogspot.com'/></div> Benjamin Nortier tag:blogger.com,1999:blog-7435412383881764254.post-1549559424813718640 Wed, 23 Jul 2008 21:46:00 -0700 http://darynholmes.wordpress.com/2008/07/12/ajax-fundamentals-part-3/ Index &#124; Part 1 &#124; Part 2 &#124; Part 3 &#124; Part 4 &#124; Part 5 3. Security Issues The XMLHttpRequest object is restricted to run within the browser’s security sandbox. Any resources requested by the XMLHttpRequest object must reside within the same domain from which the calling script originated. Therefore the XMLHttpRequest object is constrained to [...]<img alt="" border="0" src="http://stats.wordpress.com/b.gif?host=darynholmes.wordpress.com&blog=2505811&post=86&subd=darynholmes&ref=&feed=1"/> http://darynholmes.wordpress.com/?p=86 Sat, 12 Jul 2008 01:39:01 -0700

Index | Part 1 | Part 2 | Part 3 | Part 4 | Part 5

3. Security Issues

The XMLHttpRequest object is restricted to run within the browser’s security sandbox. Any resources requested by the XMLHttpRequest object must reside within the same domain from which the calling script originated. Therefore the XMLHttpRequest object is constrained to requesting resources that reside within the same domain from which the script was originally served. The W3C states, that in the future The XMLHttpRequest Object specification will define a way of doing cross-site requests.

There is an overabundance of online documentation stating that Ajax introduces multiple security threats. These threats include fake requests, denial of service, cross-site scripting (XSS), reliance on client-side security, and more. Jeremiah Grossman’s article, Myth-Busting AJAX (In)security, maintains that these security issues existed before Ajax and the recommended security best practices remain unchanged. Part of internet security basics is to distrust the client. Ajax is a client side technology and requests need to be treaded with the same caution as all other calls.

4. Disadvantages

4.1. Usability Problems

Web users have become familiar with using classic web pages. Users have become accustomed to using browser features such as the back and next buttons. Ajax calls are not loaded onto the browsers navigation stack. Therefore the back button will not undo the last ‘Ajax operation’. Developers need to explicitly cater for undo operations.

Ajax enabled pages have a notion of state; this state is altered as the user navigates through the site. The browser is unaware of this state, and it is not reflected in the address bar. Therefore users are not always able to book mark a certain page state. Developers need to consider this when deciding on when to use Ajax.

The asynchronous nature may make page updates difficult for the user to notice. The developer needs a way of drawing the user’s attention to the modified section of the page. The ‘yellow-fade technique’ has become common practice. In this technique the changes are highlighted with a yellow background, and the yellow fades gradually. These and other techniques are becoming familiar to web users.

4.2. JavaScript Disabled

If a user has disabled JavaScript no JavaScript will be executed and certainly no Ajax requests will be sent. A site that relies too heavily on JavaScript will be crippled if the user disables JavaScript, Gucci is an example of this. This site used to show a blank white page if a user browsed to it after disabling JavaScript. Now it explains that you need to have JavaScript enabled to use the site.

A site that relies on JavaScript for core functionality restricts its users to those who have JavaScript enabled. Having said that we should look at how many users are allowing JavaScript to run in there browsers. The following statistics from The Counter show JavaScript statistics.

Wed Mar 1 00:01:01 2000 – Fri Mar 17 23:59:01 2000
Javascript 1.2+: 260153365 (79%)
Javascript <1.2: 7790575 (2%)
Javascript false: 59884983 (18%)

Thu Mar 1 00:01:01 2007 – Thu Mar 22 13:58:01 2007
Javascript 1.2+: 56607094 (95%)
Javascript <1.2: 193622 (0%)
Javascript false: 2524217 (4%)

These stats show that most users are using JavaScript, therefore many stake holders would approve of the use of Ajax on their sites. Although there are cases where limiting access is unacceptable.

4.3. Search Engine Indexing

Web crawlers automatically navigate through the web by following link tags e.g. href, src etc. Current web crawlers do not examine client side scripts. Search engines skip the JavaScript code that executes the Ajax calls. Content loaded by Ajax calls will not be indexed by search engines.

Multiple solutions have been proposed to solve this problem. Most of these are workarounds and do not solve the underlying problem. In fact some approaches are considered as cloaking and can get the site black listed by Google. Google have stated that they will improve there searches, at present they do not follow Ajax calls. In order to make sure that specific content will be found by search engines, the site should have standard HTML links that web crawlers can follow.

Index | Part 1 | Part 2 | Part 3 | Part 4 | Part 5

]]> Daryn http://darynholmes.wordpress.com/2008/07/10/private-thinking-in-rails-%e2%80%93-part-1/ Part 0 In this part we look at the basic set of requirements for our text editor. I have no doubt that these requirements will change, but let’s have a quick look to get an idea of the direction we are heading in. Text Editor Requirements As mentioned in part 0, the text editor is going to be [...]<img alt="" border="0" src="http://stats.wordpress.com/b.gif?host=darynholmes.wordpress.com&blog=2505811&post=79&subd=darynholmes&ref=&feed=1"/> http://darynholmes.wordpress.com/?p=79 Thu, 10 Jul 2008 08:55:50 -0700

Part 0

In this part we look at the basic set of requirements for our text editor. I have no doubt that these requirements will change, but let’s have a quick look to get an idea of the direction we are heading in.

Text Editor Requirements

As mentioned in part 0, the text editor is going to be a very basic editor. It will maintain a version history that will allow users to roll back to a previous version of a document. This requirement is what will make this task interesting and worthwhile.

We would like to end up with screens similar to this:

The documents index page:

Clicking ‘show’ will show the related document and give the user an option to edit it.

Clicking ‘edit’ will show a form that allows the user to edit the document. When the user clicks ‘save’, the application creates a new version, without overwriting existing versions.
We will be providing this behaviour with a slight ‘twist of hand’. I will come back to this point when we actually implement it.

Clicking ‘delete’ will completely remove the document and all its versions – this is not a roll back.

If the user clicks on ‘History’ on ‘Second one’. We expect to see a screen similar to this:

Clicking ‘show’ will show the relevant version.
Clicking ‘rollback’ will delete the latest version, thus rolling back to the previous version – this is deleting one version only, not the entire document.

What is next?

Next we will have a quick look at the database schema and then we finally move onto Rails code! We will not be using the scaffolding features of Ruby on Rails. We will create our application from the ground up – generating models, controllers and views independently. We will also be coding using TDD. If you are new to Rails, I am sure you will enjoy the upcoming posts.

Part 1

This is ‘part 0’ as it is an explanation of the tutorial, no Rails code is covered in this part – I still need to write the code. This post explains what you can expect to see in future parts of this tutorial. If there is a topic you would like me to cover then please feel free to make a request…

What is the purpose of this tutorial?

Ruby is not just another OOP language. It has many idioms and constructs which seem foreign at first. Once a developer becomes familiar with these aspects the developer tends to program in a new way – the once foreign code starts to feel very natural.

Moving from Java or .Net to Ruby (and Ruby on Rails) is a challenge, but it is worth the effort. Once you start thinking in the Ruby and Rails way code starts falling into place. To cross the conceptual chasm you need to read many articles, books and as much code as you can. This tutorial aims to assist you as you crossover. Use it as a stepping stone on your path to the land of the ducks.

How did this tutorial come to be?

This tutorial is a spin-off from the ‘Routing in Rails’ tutorial. The ‘text editor’ application covered here was originally intended to be the practical section of part 6. I started developing the application and soon realised that the actual routing work was very small, and was being lost amongst the rest of the code. I felt that the application still covered many useful topics, therefore I decided to move it into its own tutorial – and here it is.

What does this tutorial cover?

This tutorial attempts to answer two questions posted to me in previous comments and emails. One question was with regards to one to many relationships and nested resources. This was covered in part 6 of the ‘Routing Tutorial’ – here we use them to build the ‘text application’ below.

The second question was from Tom made here: “When you get to RESTful routing I would like to see an example of how to add a Save As function. This would allow the user to derive a new record in a table from an existing record. So it would start as an edit function but end as a create action instead of an update action”

The second question poses an interesting REST problem. Some readers may not agree with the solution I am suggesting here. If you have any objections to this solution, please voice your objection in a comment, this will help all of us.

In addition to answering these questions, this tutorial will cover some common Rails problems e.g. using 2 models with 1 form, has many function, YAML, testing in Rails, replacing link_to with button_to etc.

As you can see, this tutorial covers many topics. I do not intend to cover each topic in detail – I would like to, I just don’t have the time. The ‘Rails Routing Tutorial’ focused on one specific topic. This tutorial shows you a bigger picture; the aim is to help you to start thinking in Rails.

What is not covered in this tutorial?

We will not be creating the definitive Rails application. The application being developed here should be thought of as the output of iteration one. While following along you should find yourself thinking: ‘would it not be better to do this?’, ‘if we did this, the test would be much cleaner’, ‘I wonder if we can add this information to the view’. If you start thinking like that, then you are starting to think in the Rails way.

Even though it is a good idea to add CSS to your Rails application from a very early stage, I do not intend to cover CSS. I would rather focus on other topics, at least for the first few parts of this tutorial – I may include it at a later stage.

This tutorial will cover the default Rails testing and not RSpec. RSpec is good and I recommend that you look into it. The only reason I am not using it here is because it requires plug-ins. These plug-ins are version dependant and I would rather avoid the potential versioning conflicts that may result from this. The testing lessons learned here can be carried over to RSpec.

What about the Music Store?

In this tutorial we will not be using the amazing Music Store application from the Routing tutorial. Instead we can create a new application. This new application will be a plain text editor. The text editor will have a version history. This will allow a user to ‘roll back’ to a previous version of the document.

This will be a basic text editor. The intension is not to create a fully fledged text editor. The aim is to familiarise ourselves with the Rails development process so that we begin to think in Rails.

What is next?

Next we look at the basic set of requirements of the text editor application. Please let me know if you would like to know more about a specific Rails topic, I will try to work it into the tutorial.

About a week ago I noticed some incoming links from Computer Weekly.com. I assumed that someone had commented on one of my posts, so I browsed there wondering if it was a positive or negative comment. Once the page loaded, I was completely surprised. It turns out that this blog has been short-listed for the Computer Weekly.com IT Blog Awards! This came as a complete surprise to me.

This blog had really humble beginnings. In fact it was not even my idea to start a blog, it was my work that encouraged me to start one. Initially I felt that I did not have that much to contribute to the world at large. In fact I still don’t feel that my blog is as innovative as some others, although judging by the response to my ‘Routing In Rails Tutorial‘ it appears as if I do have a nice way of explaining things. I guess this is one of the main reasons I have been voted onto the shortlist.

The competition ends on the 31st of July 2008. If you would like to vote please go to this on-line voting page. This blog can be found under the ‘Programming and technical blogs’ drop-down list. It is a surprisingly painless exercise, it takes less then a minute and no registration is required.

Thank you to all of you who have voted for this blog.

Daryn

In part 5 we looked at RESTful routing. In this part we continue to explore RESTful routing, by examining nested resources.

I originally planned to cover nested routes and to cover two questions posted to me in previous comments and emails. One question was with regards to ‘one to many relationships’ e.g. an album has many songs. The second question was from Tom in part 3; this was about adding save as functionality.

In trying to answer these questions I created a new application – a text editor with a version history. This has turned out to be a fairly interesting piece of work. I then changed my mind and decided to include it in a follow up post. I am hoping to have that out later this week (before Friday the 11th of July). As the ‘follow up’ post will have a practical example of nested resources, this post will not have the usual practical section with the experiments.

Part 6

Introduction to Nested Resources

The Nested URI

Returning to the familiar Music Store application, imagine we added songs to the application. Like Albums, Songs are resources and we could expect to access a song with this URI:

/songs/124

We could then perform the required CRUD operations on that URI based on the REST API as discussed in part 5.

An album has many songs. We can express this within the URI e.g.

/albums/10/songs/124

Once again we could make use of the HTTP verbs to perform CRUD in a RESTful way.

In this particular implementation, this URI does not mean that this is the 124^th song of album 10 - it is possible for it to be the fist song of album 10. The URI is pointing to the 124^th song in the system.

If we wanted the URI to state the song\track number of the specified album then we could alter the above implementation. Then we could expect to see URIs of:

/albums/10/songs/5
and
/albums/11/songs/5

This would not result in a URI conflict.

Implementing Nested resources in Rails

If we decided to add songs to the Music Store application, we could start off by aiming for a URI of:

/songs/124

As you may recall, we can achieve this by declaring this resource in the routes.rb file:

map.resources :songs

This will give us access to helper methods such as songs_url, song_url (@song) etc. This was discussed in part 5 under ‘Experiment 5.2 Showing the Index Page’.

Next we could aim for a nested URI:

/albums/10/songs/124

To achieve this we use the following construct:

 map.resources :albums do |albums| albums.resources :songs end

Note that it is albums.resources :songs and not map.resources.

With this routing rule, Rails will generate slightly different helper methods. To view these routes we could use the method described in part one. There is also a more convenient rake task: rake routes.
This is one of the ‘things’ I have been meaning to mention. You may have read it in a previous comment.

If you use ‘rake routes’ you will notice that there are a quite a lot helper methods being generated, more than the 7 I pointed out in part 5. The ‘extra’ methods are there to create URIs for different formats.

Below is filtered output from ‘rake routes’

 album_songs GET /albums/:album_id/songs {:action=>"index", :controller=>"songs"} POST /albums/:album_id/songs {:action=>"create", :controller=>"songs"} new_album_song GET /albums/:album_id/songs/new {:action=>"new", :controller=>"songs"} edit_album_song	GET /albums/:album_id/songs/:id/edit {:action=>"edit", :controller=>"songs"} album_song GET /albums/:album_id/songs/:id {:action=>"show", :controller=>"songs"} PUT /albums/:album_id/songs/:id {:action=>"update", :controller=>"songs"} DELETE /albums/:album_id/songs/:id {:action=>"destroy", :controller=>"songs"}

As you can see, we now have helper methods which look like album_songs_url and album_song_url(@song). The path versions are also available.

Inside the view we could have:
link_to ‘Edit’, edit_album_song(@album, @song)

Looking at the rake routes output above, we can see that the songs controller can get access to the album ID via params[:album_id]. The song ID can be obtained using params[:id].

Now we have helper methods that generate URIs of the form:

/albums/10/songs/124

Our routing system also knows how to deal with incoming URIs of that form.
Now we would like an implementation that allows us to use URIs like:

/albums/10/songs/5

Where song 5 really is the 5th song in album 10. Therefore we could have:

/albums/10/songs/5
and
/albums/20/songs/5

As with most things, it is easy once you know how. To achieve this we simply need to override the ‘to_param’ method in the song model. I imagine that would look something like this:

def to_param
number # number is the track number of this song on the album
end

After this change we would need to modify the controller as params[:id] would return the song number and not the song id. The controllers would need to use

@song = Song.find_by_number(params[:id])
and not
@song = Song.find(params[:id])

There will be more on this in the follow up text editor post.

Deep Nesting

Jamis Buck recommends that resources should never be nested more than one level deep. You can find his original post about that here. The Rails community seems to be divided about this ‘rule of thumb’. I recommend that you follow this guideline – although remember it is just a guideline, you can use deeper nesting if the need arises.

End of Part 6

This was a quick and short introduction to nested resources. There is a bit more to them, but this enough to start writting Rails applications.

In the follow up, ‘plain text editor’, post we will see a nested route being used a slightly larger application. In that post we will look far more than just routing, that is why I took it out of this part. I will finish that up ASAP. I hope you have enjoyed this post…

- Thank you, Daryn

Over engineering is a major problem within the software industry. This problem has led to the adoption of ‘lean software development’ – at least amongst the agile folk. Lean software development is writing code to support the current set of requirements and nothing more. This is not as easy to do as one might think.

As developers we naturally tend to make assumptions as to what the user, or system, will need. In truth, it is very difficult to accurately predict the future requirements of a system. Coding to meet our assumptions will inevitably lead to over engineering.

We should not let our intuition guide us into false requirements. As strange as it may sound, it takes a concious effort to stop ourselves from doing extra work. We need to adopt a ‘lean coding culture’. We need to constantly remind our selves to stick to lean software development. In agile teams it is common to hear developers reminding each other with certain acronyms and expressions e.g. ‘do the simplest thing that works’.

‘Do the simplest thing that works’ is in-line with lean software development, although it can be misleading. Some people interpret this as ‘do the first thing that comes to mind’ e.g. slap on another if statement – that is a simplistic solution and not a simple solution. If you take a quick and dirty simplistic approach you will end up with a big ball of mud. You need to do the simplest thing that works. The thing that works is something that can be tested, it is something that does not add unnecessary complexity. Therefore the simplest thing that works is not necessarily the quickest and easiest thing to do.

When talking about lean software development we often refer to KISS (Keep It Simple Stupid). I agree with keeping things simple but I don’t like to be called stupid, the truth hurts. I prefer to use: Keep It Simple and Sensible. This is more positive and the sensible part indicates that we should give some thought to our code. For example, instead of littering your code with conditional statements you could refactor the code to use an established design pattern. Having said that, design patterns are not always a good idea.

You should not implement a design pattern unless there are real signs indicating that you need a smarter solution. It can be detrimental to implement a design pattern for the sake of having one. You are likely to implement the wrong pattern and that code will be a hindrance. Only do what you really need to do. This is also referred to as YAGNI.

YAGNI (You Ain’t Gonna Need It) – This is a term used by Russ Olsen in Design Patterns in Ruby. In this book, Russ Olsen does a fantastic job of explaining design patterns. He also explains when not to use certain patterns and the problems that come with using each pattern – After all, software is about trade off’s.

Russ Olsen explains that we should not write code or implement patterns in anticipation of a requirement that might emerge. Firstly that requirement may never surface, and if it does it may have a stipulation which makes the pre-emptive solution void. It is safer to code to meet the current and real requirements of the system. To drive this point home, here is a delightful paragraph from Russ Olsens’ Design Patterns in Ruby:

“Look at it this way: Barring a sharp blow to the head, as you stand here today you are as dumb as you ever will be. We are all learning, getting smarter every day. This is especially true in software projects: You can be sure that you will have a better grasp of the requirements, technology, and design of any software that you work on at the end of the project then at the beginning. Whenever you put in a feature before you really need it, you are guilty of programming while stupid; if you wait until you really do need the thing, you are likely to have a better understanding of what you need to do and how you should go about doing it.”

The moral is: Don’t be guilty of programming while stupid

Part 6

In part 4 we explored named routes. In this session we move onto Rails’ REST.

Part 5

The Critics

Before we begin you should know that there are many critics of the Rails implementation of REST. There are many reasons for arguments against Rails’ REST e.g. Rails uses server side session state and client side cookies. Some people say that this is not REST compliant. Rails’ REST might not be 100% REST compliant, but you can still benefit from using REST in your Rails applications. In The Rails Way, Obie Fernandez explains that the benefits from using Rails’ REST fall into two categories:

• Convenience and automatic best practices for you
• A REST interface to your application for the rest of the world

Therefore it is worth learning and using Rails’ REST.

The Standard Introduction

Representational State Transfer (REST) is an architectural style. It was first introduced by Roy Fielding in his PhD thesis. Roy Fielding is one of the principal authors of HTTP.

The Mindset

When developing a Rails application in the RESTful way it helps to change your mindset. You should not think that you are developing a web site for users accessing the site via a browser. It is better to think of the application as being a service. The service performs actions for clients. These clients may be humans or other machines on the network.

This service will typically be placed on the internet. Therefore we could call it a web service. When I hear the term web service I immediately start thinking about SOAP and all the WS-* specifications. Let’s be clear, we are not talking about ‘those’ web services. We are talking about RESTful web services. These two technologies provide similar functionality, but RESTful web services are simple and sensible.

The Terminology

As previously stated, programming in REST requires a change in the way we think about the system. This naturally leads to a change in the way we talk about the system. The following provides a brief description of some of the key terms used in discussions about REST and HTTP.

A resource is one of the key concepts in REST. Many discussions on REST claim that a resource is anything and everything. This is neither true nor helpful. Let’s examine this concept with the aid of an example.

Let’s assume that the music store has started selling albums. The database may have the following schema:

The data in the database is the raw data. There is data which, given in isolation, is of no real value to a client. For instance it is unlikely that a client will want only one row from the LineItems table. This means that a LineItem (on its own) is not a resource within the context of the music store service.

A client would want all the information pertaining to an order. This would include data from one or more tables. Some data would not be included e.g. database keys. Some information may be added e.g. the total cost of the order might be calculated and included in the ‘order information’. This ‘order information’ is an example of a resource. Order resource is the type, there will be one order resource instance for each order made.

Each resource must be given a globally unique identifier. This is done using a URI. This could look like this:

http://www.example.com/orders/65

A client, in an admin role, may want a list of all the orders. This collection of orders would be another resource. Following the REST architecture, the orders resource would be assigned the following URL:

http://www.example.com/orders

It is important to note that these resources are not HTML documents. Roy Fielding describes a resource as a conceptual mapping. As a resource is a conceptual entity it can not be used by a client. The service provides the client with a representation of the resource.

When the client is a browser, the service typically provides an HTML representation of the resource. If the client is another machine then the service may provide an XML representation of the resource. Other representations could include a PDF file, an image, csv etc. A representation is only supported by the service if it is applicable and required.

Resources are often referred to as nouns. This is often done when talking about HTTP to assist learning. The term ‘noun’ is more abstract. For our purposes, resources and ‘nouns’ are synonymous.

HTTP also has the notion of verbs. These are the HTTP operations. We are all familiar with the POST and GET operations. In addition to these two operations, HTTP also supports: DELETE and PUT.

There are a few more terms to cover, but we can do that later. The core terms have been explained.

Joining The Dots…

REST is an architecture style which makes full use of HTTP. Some say that it makes proper use of HTTP.

As previously explained, HTTP supports GET, POST, DELETE and PUT. One of the main ideas behind REST is to use these HTTP operations to determine the correct action to perform. Let’s clarify this with an example.

If the RESTful music store server receives a URL of: /albums/4 sent with a GET, then the server will invoke the show action of the albums controller. The response may be an HTML page showing details of the 4th album.

If the server receives a URL of: /albums/4 sent with a DELETE, then the server will invoke the destroy action of the albums controller. This will result in the 4th album being deleted.

Note that the URL did not contain explicit ‘show’ or ‘delete’ information. The server was able to infer the action by examining the HTTP operation. Therefore show and delete were implicitly called.

The form of that URL is REST compliant. If the music store had to include Artists and Songs, we could expect to see URLs like this:
/artists/2
/songs/8

As you can see a consistent API is forming, this is the REST API. It becomes intuitive once you start getting familiar with it. For instance I am sure you can tell what would happen if we did a DELETE on this URL:
/songs/154

An application typically performs the full set of CRUD operations – Create Read Update and Delete. The following table shows the mapping between database CRUD operations, the HTTP verbs, and REST compliant URLs.

When creating a new album, the plural /albums is used. This is because we are adding a one new album to the collection of albums.

In previous posts in this series, creating and editing an album has always involved two controller actions being invoked. When we create an album we:

1. Call the new action to retrieve a form with empty fields
2. Call the create action which creates a new album extracting the information from that form

When doing an update we:

1. Call the edit action to get a form with fields filled in with data from the relevant album
2. Call the update action which then performs the actual database update

This is the typical behaviour of a website. We need to fit this behaviour in with REST. When doing an edit we can’t obtain the albums details by doing a GET on /album/1 – that is already used for showing an album.

This functionality is achieved with modifiers (also called adjectives). The modifiers we need are ‘new’ and ‘edit’. This results in the following mapping:

Note the last line which calls the index action.

As you can tell, we are moving towards Rails specific terminology. I guess this means it is time to step into the code…

Experiment 5.0 Preparation

In part 4 we created named routes. The routes.rb file looked like this:

ActionController::Routing::Routes.draw do |map| map.albums 'albums', :controller => "albums", :action => "index" map.album 'album/:id', :controller => "albums", :action => "show" map.edit_album 'albums/:id/edit', :controller => "albums", :action => "edit" map.update_album 'albums/:id/update', :controller => "albums", :action => "update" map.destroy_album 'albums/:id/destroy', :controller => "albums", :action => "destroy" map.new_album 'albums/new', :controller => "albums", :action => "new" map.create_album 'albums/create', :controller => "albums", :action => "create" #map.connect ':controller/:action/:id' #map.connect ':controller/:action/:id.:format' end

In this session we move from named routes to RESTful routing. Therefore we can delete these named routes. Empty the routes.rb file:

ActionController::Routing::Routes.draw do |map| #map.connect ':controller/:action/:id' #map.connect ':controller/:action/:id.:format' end

Once again we have a broken music store. Let’s fix it and make it REST compliant.

Experiment 5.1 Including REST Routes

We want the music store application to be REST compliant. At the moment we don’t make use of the HTTP operations, instead we explicitly state the intentions within the URL. At the end of part 4 the site worked like this:

The application was fairly similar to REST. This is because the named routes created in part 4 were based on the REST style. To make the application more RESTful we need to make use of the HTTP verbs. We could update each of our named routes to explicitly state the HTTP operation e.g.

 map.albums 'albums', :controller => "albums", :action => "index", :method => "get" 

Rails has made this easier for us. Update the routes.rb file to:

ActionController::Routing::Routes.draw do |map| map.resources :albums #map.connect ':controller/:action/:id' #map.connect ':controller/:action/:id.:format' end

Thanks to this one line, Rails will create a set of named routes – intelligent named routes. They are intelligent because they examine the request URL as well as the specified HTTP operation. Therefore the same URL can be routed to deferent controller actions.

As you may recall from part 4, when you use named routes Rails dynamically generates routing helper methods. These helper methods are also available on these new ‘intelligent’ named routes.

Experiment 5.2 Showing the Index Page

Let’s have a look at the table:

To show a list of albums we need to perform a GET with a URL of /albums. We can perform a get by simply typing the URL into the browser and pressing enter. If you try that you should end up with an error.

undefined method `destroy_album_path’ for #

This is good news as we did not get a route not found error. To get the index page up and running we need to replace the named route helper methods we introduced in part 4 with the helper methods created by ‘map.resources :albums’. The following table shows these ‘new’ helper methods.

This table shows methods ending with _url, the _path versions also exist. This was explained in part 4. By making use of these helper methods we can update the index.html.erb.

Thanks to our foresight in part 4, we only need to change the call to delete, from:

link_to ‘Destroy’, destroy_album_path(album.id), :confirm => ‘Are you sure?

To

link_to ‘Destroy’, album_path(album), :confirm => ‘Are you sure?’, :method => :delete

Just to be clear, the index.html.erb should look like this:

<h1>Listing albums</h1>
<table>
<tr>
<th>Title</th>
<th>Review</th>
</tr>
<% for album in @albums %>
<tr>
<td><%=h album.title %></td>
<td><%=h album.review %></td>
<td><%= link_to 'Show', album_path(album) %></td>
<td><%= link_to 'Edit', edit_album_path(album) %></td>
<td><%= link_to 'Destroy', album_path(album), :confirm => 'Are you sure?', :method => :delete %></td>
</tr>
<% end %></table>
<%= link_to 'New album', new_album_path %>

A URL of /albums should show the index page – test it if you like.

Alert!
Link_to obtains the URL by making use of another Rails method called ‘url_for’. The following quote is from the Rails documentation and it refers to the parameters being passed into url_for.

“If you instead of a hash pass a record (like an Active Record or Active Resource) as the options parameter, you‘ll trigger the named route for that record. The lookup will happen on the name of the class. So passing a Workshop object will attempt to use the workshop_path route”

This means that we can replace
link_to ‘Show’, album_path(album)
with
link_to ‘Show’, album

And
link_to ‘Destroy’, album_path(album), :confirm => ‘Are you sure?’, :method => :delete
with
link_to ‘Destroy’, album, :confirm => ‘Are you sure?’, :method => :delete

I am sure this bit of Rails magic has been the cause of much confusion.
This magic is also used in other methods e.g. redirect_to, form_for etc.

The index.html.erb can now look like this:

<h1>Listing albums</h1>
<table>
<tr>
<th>Title</th>
<th>Review</th>
</tr>
<% for album in @albums %>
<tr>
<td><%=h album.title %></td>
<td><%=h album.review %></td>
<td><%= link_to 'Show', album %></td>
<td><%= link_to 'Edit', edit_album_path(album) %></td>
<td><%= link_to 'Destroy', album, :confirm => 'Are you sure?', :method => :delete %></td>
</tr>
<% end %></table>
<%= link_to 'New album', new_album_path %> 

A URL of /albums should now render the index page.

Experiment 5.3 The RESTful Show

Thanks to the naming convention we used in part 4, we do not need to do anything to make show work. Show.html.erb remains like this:

 <b>Title:</b> <%=h @album.title %> <b>Review:</b> <%=h @album.review %> <%= link_to 'Edit', edit_album_path(@album) %> |
<%= link_to 'Back', albums_path %> 

Experiment 5.4 Edit RESTfully

To fix update we need to make use of the following methods in the edit view.

The form_for allows us to use more syntactic sugar.

We could use:
form_for (@album), :url => album_path(@album)

Or we could use:
form_for (@album)

This means the edit.html.erb should look like this:

<h1>Editing album</h1>
<%= error_messages_for :album %> <% form_for (@album) do |f| %> <b>Title</b> <%= f.text_field :title %> <b>Review</b> <%= f.text_area :review %> <%= f.submit "Update" %> <% end %> <%= link_to 'Show', @album %> |
<%= link_to 'Back', albums_path %>

Experiment 5.5 Putting Delete to REST

This was fixed when we modified the index.html.erb.

The line was:

link_to ‘Destroy’, album, :confirm => ‘Are you sure?’, :method => :delete

Experiment 5.6 A RESTful Addition

In order to restore the ‘new’ functionality, make new.html.erb look like this:

<h1>New album</h1>
<%= error_messages_for :album %> <% form_for (@album) do |f| %> <b>Title</b> <%= f.text_field :title %> <b>Review</b> <%= f.text_area :review %> <%= f.submit "Create" %> <% end %> <%= link_to 'Back', albums_path %>

Experiment 5.7 Updating the Controller to use the Syntactic Sugar

When using a resource the controller must implement these specific methods:
index, show, new, edit, create, update, destroy.
Our controller already meets this condition.

Although the music store is fully operational, we can make some minor modifications in the controller. This is just to leave the controller in the way Rails generated it in part 1. These changes are in the create and update actions e.g. redirect_to(@album)

The controller should look as follows:

 class AlbumsController < ApplicationController # GET /albums # GET /albums.xml def index @albums = Album.find(:all) @cont = "The controller is:" + params[:controller] respond_to do |format| format.html # index.html.erb format.xml { render  ml => @albums } end end # GET /albums/1 # GET /albums/1.xml def show @album = Album.find(params[:id]) respond_to do |format| format.html # show.html.erb format.xml { render  ml => @album } end end # GET /albums/new # GET /albums/new.xml def new @album = Album.new respond_to do |format| format.html # new.html.erb format.xml { render  ml => @album } end end # GET /albums/1/edit def edit @album = Album.find(params[:id]) end # POST /albums # POST /albums.xml def create @album = Album.new(params[:album]) respond_to do |format| if @album.save flash[:notice] = 'Album was successfully created.' format.html { redirect_to(@album) } format.xml { render  ml => @album, :status => :created, :location => @album } else format.html { render :action => "new" } format.xml { render  ml => @album.errors, :status => :unprocessable_entity } end end end # PUT /albums/1 # PUT /albums/1.xml def update @album = Album.find(params[:id]) respond_to do |format| if @album.update_attributes(params[:album]) flash[:notice] = 'Album was successfully updated.' format.html { redirect_to(@album) } format.xml { head  k } else format.html { render :action => "edit" } format.xml { render  ml => @album.errors, :status => :unprocessable_entity } end end end # DELETE /albums/1 # DELETE /albums/1.xml def destroy @album = Album.find(params[:id]) @album.destroy respond_to do |format| format.html { redirect_to(albums_url) } format.xml { head  k } end end
end

And that is that – our music store is exactly how it was when we generated it in part 1.

End of Part 5

To keep things ‘simple’ I have been skipping over certain aspects of routing. I will draft one more post in this series where I will mention some of these topics. Some of the readers have asked questions, I will still answer those questions but they won’t form part of this tutorial.

That concludes part 5. Hopefully you have a better understanding of what is going on under the hood.

Thank you, Daryn

Part 6

Part 5

The routes we have discussed so far are known as simple routes. I have been referring to them as custom routes, but ‘simple routes’ is the correct term. The default route we discussed in part 3 is also a simple route. The aim is to move onto RESTful routes, sometimes called resource routes. RESTful routes are built on top of named routes. Therefore we must first cover named routes, and that is what part 4 is all about.

Part 4

Introduction

Referring back to part 1, the routing system has two main functions:
Interpreting a request URL
Generating a request URL

We had a detailed look at route generation and interpretation in part 2, but let’s have another quick look at it. Let’s assume, for some insane reason, that we defined the following route in the music_store routes.rb file:

map.connect ‘apples/bananas/:id’, :controller => “albums”, :action => “show”

link_to would use this rule to generate a URL, this can be seen in the following line extracted from index.html.erb:

link_to ‘Show’, :controller => “albums”, :action => “show”, :id => album.id

This could generate a URL of: http://localhost:3000/apples/bananas/7
And when given this request, Rails would handle it correctly e.g. the show action will be called on the albums controller and the show view will be sent as the response to the browser.

Coming back to the real world, we are more likely to define the routing rule like this:
map.connect ‘albums/show/:id’, :controller => “albums”, :action => “show”

link_to (and friends) would then generate a URL like this:
http://localhost:3000/albums/show/7.

To show the index (the listing of the albums) we could define a rule like this:
map.connect ‘albums/index’, :controller => “albums”, :action => “index”

The matching link_to in edit.html.erb is:
link_to ‘Back’, :controller => “albums”, :action => “index”

Looking at the last example, there is some repetition. Both lines contain:
:controller => “albums”, :action => “index”

The link_to method needs this (controller, action) information to obtain the URL. If we had the URL stored as some global variable, or method, then we could simply pass that into link_to. link_to could use this ‘literal’ URL without needing to generate one.
This could look something like: link_to ‘Back’, albums_index_url
This is one of the main ideas behind named routes.

Named Routes

Named routes provide a way to ‘clean up’ code, specifically the code within link_to and other similar functions. When a named route is defined, new helper methods are dynamically generated. These helper methods provide a simplified way of obtaining the required request URL. The names of these helper methods are based on the name of the route. Let’s clarify this by coding.

Experiment 4.0 Preparation

At the end of part 3 the routes.rb had the default route in it:

ActionController::Routing::Routes.draw do |map| map.connect ':controller/:action/:id' end

It is common to accompany the default route with this:
map.connect ‘:controller/:action/:id.:format’
We can think of this as a default route which allows clients to request a different format for the response. :format was discussed in part 1, under the title of Experimenting 1 – View the generated routes.

To prepare for this session, we want to remove all the routes and completely break the site. Therefore you should make your routes.rb look like this:

ActionController::Routing::Routes.draw do |map| # map.connect ':controller/:action/:id' # map.connect ':controller/:action/:id.:format' end

Now the site is good for two things, serving up routing errors and learning about named routes…

Experiment 4.1 Adding a Named Route for the Albums Index

In part 2 we defined a route which invoked the index action on the albums controller. That route looked like this: map.connect ‘music’, :controller => “albums”, :action => “index”

To follow Rails convention, we should write it like this:
map.connect ‘albums’, :controller => “albums”, :action => “index”

Making it more readable we could write it like this:
map.connect ‘albums’,
:controller => “albums”,
:action => “index”

The pattern string is ‘albums’, therefore a URL of /albums would match.

In order to name this route, we need to decide what to name or call it. A top down approach is recommended for this. We want to show a list of albums, so it seems reasonable to call the route ‘albums’.

To name the route, we make a small change to our route definition. We change the route definition from:

map.connect ‘albums’,
:controller => “albums”,
:action => “index”

To:

map.albums ‘albums’,
:controller => “albums”,
:action => “index”

All we had to do is change map.connect to map.albums. Modify your routes.rb file to look like this:

 ActionController::Routing::Routes.draw do |map| map.albums 'albums', :controller => "albums", :action => "index" # map.connect ':controller/:action/:id' # map.connect ':controller/:action/:id.:format' end

Once this file is saved, you will have created a named route. We are still missing most of the routes our site requires therefore we can’t run the site just yet. Let’s simplify the index page. Make the index.html.erb look like this:

<h1>Listing albums</h1> <table> <tr> <th>Title</th> <th>Review</th> </tr> <% for album in @albums %> <tr> <td><%=h album.title %></td> <td><%=h album.review %></td> </tr>
<% end %>
</table>
<br />

Now you should be able to see the simplified index page. Next we will take a look at the methods that Rails generates when using named routes.

Experiment 4.2 Exploring the ‘Named Route’ Generated Methods

When a named route is defined, Rails will dynamically generate two methods, these are:
name_url and name_path (where name is the name of the route). name_url will return the fully qualified URL, name_path returns the relative path – it does not include the protocol and host.

In our case, we have a route named albums. When we run the site, rails will generate albums_url and albums_path. Let’s make the view display these values, change the index.html.erb to this:
I had to use different formatting to stop WordPress from getting up to its shenanigans…

<h1>Listing albums</h1> <table> <tr> <th>Title</th> <th>Review</th> </tr> <% for album in @albums %> <tr> <td><%=h album.title %></td> <td><%=h album.review %></td> </tr>
<% end %>
</table>
<br />
albums_url: <%= albums_url %>
<br />
albums_path: <%= albums_path %>

Brows to http://localhost:3000/albums and you should see:
albums_url: http://localhost:3000/albums
albums_path: /albums

Now that we have seen the output of these methods, you can now remove those last three lines.

Academically speaking it is probably more correct to use name_url but name_path also works in most cases. The Rails way is to use name_path if you can. These methods are available in the views and controllers.

Experiment 4.3 Defining a Named Route for Show

Showing the index is fairly straight forward as it is basically a static URL. Now we look at defining a named route for show. Show needs to pass through the ID of the specific album. When defining a simple route, we could use:

map.connect ‘album/:id’,
:controller => “albums”,
:action => “show”

Once again, we can convert this into a named route by replacing connect with the name of the route. Let’s name the route ‘album’. Update the routes.rb to look as follows:

ActionController::Routing::Routes.draw do |map| map.albums 'albums', :controller => "albums", :action => "index" map.album 'album/:id', :controller => "albums", :action => "show" # map.connect ':controller/:action/:id' # map.connect ':controller/:action/:id.:format' end

Rails realises that it needs a value for :id, therefore the helper methods accept a parameter to be assigned to it. Therefore link_to can use album_url(3). This will hard code 3, but it illustrates the point.

In the code we are likely to use:
link_to ‘Show’, album_path(album.id)
Thanks to some syntactic sugar we can also use:
link_to ‘Show’, album_path(album)

Let’s get the ‘show’ functionality working again. Update index.erb.html to look like this:

<h1>Listing albums</h1> <table> <tr> <th>Title</th> <th>Review</th> </tr> <% for album in @albums %> <tr> <td><%=h album.title %></td> <td><%=h album.review %></td> <td><%= link_to 'Show', album_path(album) %></td> </tr>
<% end %>
</table>
<br />

And update show.erb.html to:

<p> <b>Title:</b> <%=h @album.title %>
</p> <p> <b>Review:</b> <%=h @album.review %>
</p> <%= link_to 'Back', albums_path %>

We have removed the link to ‘edit’, we will replace it later.

At this stage the site should be able:

• to show the list of albums in the index page
• show a single album

Experiment 4.4 Defining a Named Route for Edit

Now lets fix the edit functionality. Update routes.rb to look like this:

ActionController::Routing::Routes.draw do |map| map.albums 'albums', :controller => "albums", :action => "index" map.album 'album/:id', :controller => "albums", :action => "show" map.edit_album 'albums/:id/edit', :controller => "albums", :action => "edit" map.update_album 'albums/:id/update', :controller => "albums", :action => "update" # map.connect ':controller/:action/:id' # map.connect ':controller/:action/:id.:format' end 

You may have noticed that I am using slightly different pattern strings to what we have been using. The pattern strings (and URLs) that I am using now are fairly close to those used in REST. Therefore we are already getting familiar with the RESTful interface.

Update the index.erb.html to:

 <h1>Listing albums</h1> <table> <tr> <th>Title</th> <th>Review</th> </tr> <% for album in @albums %> <tr> <td><%=h album.title %></td> <td><%=h album.review %></td> <td><%= link_to 'Show', album_path(album) %></td> <td><%= link_to 'Edit', edit_album_path(album) %></td> </tr>
<% end %>
</table>
<br /> 

Edit.erb.html should look like this:

<h1>Editing album</h1> <%= error_messages_for :album %> <% form_for (@album), :url => update_album_path(@album) do |f| %> <p> <b>Title</b><br /> <%= f.text_field :title %> </p> <p> <b>Review</b><br /> <%= f.text_area :review %> </p> <p> <%= f.submit "Update" %> </p>
<% end %> <%= link_to 'Show', album_path(@album) %> |
<%= link_to 'Back', albums_path %>

Add the edit link back to show.erb.html

 <p> <b>Title:</b> <%=h @album.title %>
</p> <p> <b>Review:</b> <%=h @album.review %>
</p> <%= link_to 'Edit', edit_album_path(@album) %> |
<%= link_to 'Back', albums_path %>

At this stage the site should be able:

• to show the list of albums in the index page
• show a single album
• Edit an existing album

Experiment 4.5 Defining a Named Route for Destroy

Update the routes.rb to this:

ActionController::Routing::Routes.draw do |map| map.albums 'albums', :controller => "albums", :action => "index" map.album 'album/:id', :controller => "albums", :action => "show" map.edit_album 'albums/:id/edit', :controller => "albums", :action => "edit" map.update_album 'albums/:id/update', :controller => "albums", :action => "update" map.destroy_album 'albums/:id/destroy', :controller => "albums", :action => "destroy" # map.connect ':controller/:action/:id' # map.connect ':controller/:action/:id.:format' end

The index.erb.html should look like this:

<h1>Listing albums</h1> <table> <tr> <th>Title</th> <th>Review</th> </tr> <% for album in @albums %> <tr> <td><%=h album.title %></td> <td><%=h album.review %></td> <td><%= link_to 'Show', album_path(album) %></td> <td><%= link_to 'Edit', edit_album_path(album) %></td> <td><%= link_to 'Destroy', destroy_album_path(album.id), :confirm => 'Are you sure?' %></td> </tr>
<% end %>
</table>
<br />

I am sure that you are getting a feel for named routes now…

At this stage the site should be able:

• to show the list of albums in the index page
• show a single album
• Edit an existing album
• Delete an album

Experiment 4.6 Defining a Named Route for New

Change the routes.rb file to this:

ActionController::Routing::Routes.draw do |map| map.albums 'albums', :controller => "albums", :action => "index" map.album 'album/:id', :controller => "albums", :action => "show" map.edit_album 'albums/:id/edit', :controller => "albums", :action => "edit" map.update_album 'albums/:id/update', :controller => "albums", :action => "update" map.destroy_album 'albums/:id/destroy', :controller => "albums", :action => "destroy" map.new_album 'albums/new', :controller => "albums", :action => "new" map.create_album 'albums/create', :controller => "albums", :action => "create" # map.connect ':controller/:action/:id' # map.connect ':controller/:action/:id.:format' end

The index.erb.html should now be:

<h1>Listing albums</h1> <table> <tr> <th>Title</th> <th>Review</th> </tr> <% for album in @albums %> <tr> <td><%=h album.title %></td> <td><%=h album.review %></td> <td><%= link_to 'Show', album_path(album) %></td> <td><%= link_to 'Edit', edit_album_path(album) %></td> <td><%= link_to 'Destroy', destroy_album_path(album.id), :confirm => 'Are you sure?' %></td> </tr>
<% end %>
</table>
<br /><%= link_to 'New album', new_album_path %>

To stop WordPress from deleting my code, I put link_to ‘New album’ on the same line as the br tag. They are on separate lines in my actual code.

With new.erb.html looking like this:

 <h1>New album</h1> <%= error_messages_for :album %> <% form_for :album, @album, :url => create_album_path do |f| %> <p> <b>Title</b><br /> <%= f.text_field :title %> </p> <p> <b>Review</b><br /> <%= f.text_area :review %> </p> <p> <%= f.submit "Create" %> </p>
<% end %> <%= link_to 'Back', albums_path %>

At this stage the site should be able:

• to show the list of albums in the index page
• show a single album
• Edit an existing album
• Add a new album

Are we done? What about the controller?

Experiment 4.7 Using Named Route Helper Methods in the Controller

Open the controller and look at the destroy action, you will notice this line:

format.html { redirect_to(:controller => “albums”, :action => “index”) }

This shows you that we can still generate routes as if we were using the simple routes. We have defined named routes, we can use the helper methods in the controller, so we might as well.

Make the controller look like this:

class AlbumsController < ApplicationController # GET /albums # GET /albums.xml def index @albums = Album.find(:all) respond_to do |format| format.html # index.html.erb format.xml { render  ml => @albums } end end # GET /albums/1 # GET /albums/1.xml def show @album = Album.find(params[:id]) respond_to do |format| format.html # show.html.erb format.xml { render  ml => @album } end end # GET /albums/new # GET /albums/new.xml def new @album = Album.new respond_to do |format| format.html # new.html.erb format.xml { render  ml => @album } end end # GET /albums/1/edit def edit @album = Album.find(params[:id]) end # POST /albums # POST /albums.xml def create @album = Album.new(params[:album]) respond_to do |format| if @album.save flash[:notice] = 'Album was successfully created.' format.html { redirect_to(album_path(@album)) } format.xml { render  ml => @album, :status => :created, :location => @album } else format.html { render :action => "new" } format.xml { render  ml => @album.errors, :status => :unprocessable_entity } end end end # PUT /albums/1 # PUT /albums/1.xml def update @album = Album.find(params[:id]) respond_to do |format| if @album.update_attributes(params[:album]) flash[:notice] = 'Album was successfully updated.' format.html { redirect_to(album_path(@album)) } format.xml { head  k } else format.html { render :action => "edit" } format.xml { render  ml => @album.errors, :status => :unprocessable_entity } end end end # DELETE /albums/1 # DELETE /albums/1.xml def destroy @album = Album.find(params[:id]) @album.destroy respond_to do |format| format.html { redirect_to(albums_path) } format.xml { head  k } end end
end

Sure we have a larger routes.rb file, but I am sure you will agree that redirect_to(albums_path)

is much better than redirect_to(:controller => “albums”, :action => “index”)

The End of Part 4

I hope this has helped you to get familiar with named routes. There is a lot more to them, and there is also a lot more syntactic sugar. Once I have completed the section on RESTful routing, I might do a summary post. This would be a recap and it will show some tips and tricks that I skipped over in these posts. I am skipping certain topics as I would like to get onto RESTful routing as soon as possible.

Speaking of RESTful routing, the way we have named the routes is very close to the RESTful way. You will see this in the next post.

It is very easy to make mistakes when writing a tutorial like this. Especially with the gremlins inside of the WordPress formatting engine. If you are one of the first to complete this session successfully then please inform me. More importantly, if you find a problem please let me know.

Thank you, Daryn

Part 5

This tutorial shows the first steps how to test the cvs2svn tool in a Windows environment requiring minimal knowledge about CVS and SVN. The steps described have the purpose introduce you in the simplest ways how to create a CVS and a SVN repository and migrate CVS repositories to SVN repositories.

To run the cvs2svn tool and make use of some Linux tools, I opted to use a Linux-like environment for Windows called cygwin.

You can make all the steps simply using cygwin. However, as a Windows user, I think using the clients TortoiseCVS and TortoiseSVN could be more convenient, so is up to you to choose the most convenient way for you.

The commands mentioned in this tutorials that begin with $ are for cygwin, the ones that begin with > are for MS-DOS.

Tools required

• Install cygwin (with python, cvs, svn, gnutls, optionally rxvt, which I recommend). If you want to use rxvt on top of cygwin, create an icon with following target and start it: C:\cygwin\bin\rxvt.exe -bg black -fg yellow -cr blue -bd pink -fn “Lucida Console-16″ -ls -st -sr -sl 2000 -tn xterm -e /usr/bin/bash –login -i
• Install TortoiseCVS and TortoiseSVN.
• Install the SVN Server for windows (or optionally use the svn server in cygwin)
• Install cvs2svn using cygwin: download the cvs2svn file and unpack (e.g. in C:/Program Files).
$ cd /c/Program\ Files/cvs2svn-2.1.0/
$ make install

Create a CVS repository

Using MS-DOS:

> set CVSROOT=C:/CVSServer
> cvs init

Using cygwin:

$ export CVSROOT=C:/CVSServer
$ cvs init

Create and checkout a new CVS Module

Using cygwin:

$ cd <path to a directory that contains initial data to be uploaded to the new module>
$ cvs import -m “First new module” MyFirstModule sts start
$ cd <path to the directory where the new module shall be checked out>
$ cvs co MyFirstModule

Using TortoiseCVS:

• Create a new folder
• In Windows Explorer right click this folder and choose the option “CVS -> Make New Module…”
• Choose the protocol “Locally mounted folder (:local:)”, enter the repository path “C:/CVSServer” and enter the name of the new module. The CVSROOT field will be automatically build as “:local:C:/CVSServer”. After clicking OK, this folder will automatically be checked out.
• Copy some initial data into the new folder, mark the content, right click and choose the option “CVS Add…” and then “CVS Commit….”

Migrate the CVS repository into SVN

Now we can run the cvs2svn tool to migrate the previously created CVS repository to a new SVN repository. Try the following command in cygwin:

$ /c/Program\ Files/cvs2svn-2.1.0/cvs2svn –svnrepos /c/SVNServer/ /c/CVSServer/MyFirstModule

After performing the command above, a new directory should have been created (C:\SVNServer\). Now the new SVN repository needs to be configured.

Configure the new SVN repository

Open the file C:\SVNServer\conf\svnserve.conf and uncomment the following settings:

[general]
anon-access = read
auth-access = write
password-db = passwd

Open the file C:\SVNServer\conf\passwd and uncomment the following settings:

[users]
harry = harryssecret
sally = sallyssecret

Start the SVN server

You have a few different ways how to make the new SVN repository available for check outs.

One way is making the repository available as a SVN server – so, the repository will be available within your local network:

$ svnserve –daemon –root /c/SVNServer

Alternatively you can start the SVN server as a windows service – open the MS-DOS console and enter the following command:

> sc create svnserve binpath= “\”C:\Program Files\Subversion\bin\svnserve.exe\” –service -r C:\SVNServer” displayname= “Subversion Server” depend= Tcpip start= auto

Checkout the migrated SVN repository

If you have started the SVN server, you can use the address svn://localhost/trunk for the checkout. If you would rather like just to use the file system, you can use the address file:///C:/SVNServer/trunk.

Using cygwin or MS-DOS:

cd <path to the directory where the repository shall be checked out>

svn co <svn address as described above>

After performing the command above, a new directory should have been created with the same name as in the command argument.

Using TortoiseSVN

• Create a directory that will contain a copy of the files in the SVN repository
• Right-Click on the new created folder and choose option “SVN Checkout…”
• Enter the address as described above and press the OK button.

How to create a new SVN repository and import initial data

To create a new SVN repository, you can use the following command:

$ svnadmin create /c/NewSVNServer

Now you can enter the folder that contains initial data that will be uploaded and then perform the import command.

$ cd <directory with initial data>

$ svn import -m “Import initial data” svn://localhost/trunk/

]]> ruthklempel http://21ccw.blogspot.com/2008/04/ie7-page-zoom-broken.html We use <a rel="nofollow" target="_blank" href="http://www.xplanner.org/">XPlanner</a> at work for some projects, and we noticed that there seems to be a problem with the hyperlinks in Internet Explorer (version 7.0.5730.11) when the pages are zoomed in (you can zoom pages in IE with Ctrl +). The horizontal areas for the links were not aligned to the actual text, which means that some links seem <span style="font-style:italic;">can't be clicked correctly</span>, but you <span style="font-style:italic;">can</span> click white space (look carefully at the first image, you can see the normal I-beam cursor):<br /><br /><a rel="nofollow" target="_blank" href="http://3.bp.blogspot.com/_bXDgUoT7V7o/SAjcyclT7uI/AAAAAAAAAG8/uXDb8m13Ddo/s1600-h/one.png"><img style="margin:0px auto 10px;display:block;text-align:center;cursor:pointer;" src="http://3.bp.blogspot.com/_bXDgUoT7V7o/SAjcyclT7uI/AAAAAAAAAG8/uXDb8m13Ddo/s400/one.png" alt="" id="BLOGGER_PHOTO_ID_5190641329768754914" border="0"/></a><br /><a rel="nofollow" target="_blank" href="http://4.bp.blogspot.com/_bXDgUoT7V7o/SAjcyslT7vI/AAAAAAAAAHE/r-iBAhrJyJU/s1600-h/two.png"><img style="margin:0px auto 10px;display:block;text-align:center;cursor:pointer;" src="http://4.bp.blogspot.com/_bXDgUoT7V7o/SAjcyslT7vI/AAAAAAAAAHE/r-iBAhrJyJU/s400/two.png" alt="" id="BLOGGER_PHOTO_ID_5190641334063722226" border="0"/></a><br /><br /><br />I shouldn't be surprised, since it does <a rel="nofollow" target="_blank" href="http://21ccw.blogspot.com/2008/03/acid3-test-released.html">so badly in the Acid3 test</a>. I couldn't find any other reports of this issue, and will be happy to link to them if you post a comment.<br /><br />P.S. Firefox, Opera and Safari don't have this problem.<div class="blogger-post-footer"><img width='1' height='1' src='https://blogger.googleusercontent.com/tracker/7435412383881764254-3297377195562942494?l=21ccw.blogspot.com'/></div> Benjamin Nortier tag:blogger.com,1999:blog-7435412383881764254.post-3297377195562942494 Fri, 18 Apr 2008 03:13:00 -0700 http://21ccw.blogspot.com/2008/04/getting-started-with-distributed-erlang.html <a rel="nofollow" target="_blank" href="http://www.erlang.org/doc/apps/mnesia/index.html">Mnesia</a> is a distributed database that forms part of the <a rel="nofollow" target="_blank" href="http://www.erlang.org/">Erlang</a> release. One of the features that I think is potentially powerful, is <span style="font-style:italic;">transparent</span> table relocation across machines. With Mnesia, you can replicate tables to any nodes you wish in your network, and Mnesiatakes care of all the back end bits for you. With "transparent", I mean that you don't need to do anything in your clients to make them "aware" of the new tables. Reads that were taking place from a table on one machine, will now be distributed across multiple nodes (where the nodes reside on single or multiple machines).<br /><br />I wanted to see how difficult it is to achieve this. For the setup, I installed two virtual Ubuntu 7.10 machines using <a rel="nofollow" target="_blank" href="http://www.vmware.com/products/player/">VMware Player</a>. You can get images for most Ubuntu distros at <a rel="nofollow" target="_blank" href="http://isv-image.ubuntu.com/vmware/">http://isv-image.ubuntu.com/vmware/</a>. FYI, the username and password for these images is ubuntu:ubuntu. I named the two nodes<br /><br />node1.21ccw.blogspot.com and<br />node2.21ccw.blogspot.com<br /><br />You'll need to edit the network configurations with the IP addresses if you want to reproduce this experiment. If you need some help, post a question as comment :)<br /><br />I now had two machines that could ping each other using the full names, and a warm and fuzzy feeling inside:<br /><br /><a rel="nofollow" target="_blank" href="http://3.bp.blogspot.com/_bXDgUoT7V7o/R_4bNw2zkfI/AAAAAAAAAG0/by5WJ18M21A/s1600-h/vms.jpg"><img style="margin:0px auto 10px;display:block;text-align:center;cursor:pointer;" src="http://3.bp.blogspot.com/_bXDgUoT7V7o/R_4bNw2zkfI/AAAAAAAAAG0/by5WJ18M21A/s400/vms.jpg" alt="" id="BLOGGER_PHOTO_ID_5187613744044413426" border="0"/></a><br />The next step was to start up an Erlang node on each machine. There's a catch here though. I got some problems using erl -sname, probably because of the way I set up the hostnames of the machines. So, <span style="font-style:italic;">I had to specify the fully qualified names manually</span>:<br /><br /><pre class="consoleA"><br />ubuntu@node1:~/node1$ erl -name 'node1@node1.21ccw.blogspot.com'<br />Erlang (BEAM) emulator version 5.5.5 [source] [async-threads:0] [kernel-poll:false]<br /><br />Eshell V5.5.5 (abort with ^G)<br /></pre><br /><pre class="consoleB"><br />ubuntu@node2:~/node2$ erl -name 'node2@node2.21ccw.blogspot.com'<br />Erlang (BEAM) emulator version 5.5.5 [source] [async-threads:0] [kernel-poll:false]<br /><br />Eshell V5.5.5 (abort with ^G)<br />(node1@node1.21ccw.blogspot.com)1&gt; nodes().<br />[]<br /></pre><br /><br />Notice the output of the <span style="font-style:italic;">nodes() </span>command. This will return a list of <span style="font-style:italic;">other</span> Erlang nodes that this node is aware of. Initially there's no awareness. To let a node know of another node, you can use net_adm:ping/1 to ping the other node. Both nodes will then become be aware of each other:<br /><br /><pre class="consoleA"><br />(node1@node1.21ccw.blogspot.com)4&gt; net_adm:ping('node2@node2.21ccw.blogspot.com').<br />pong<br /><br />(node1@node1.21ccw.blogspot.com)5&gt; nodes().<br />['node1@node1.21ccw.blogspot.com']<br /></pre><br /><pre class="consoleB"><br />(node2@node2.21ccw.blogspot.com)1&gt; nodes().<br />['node1@node1.21ccw.blogspot.com']<br /></pre><br /><br />Cool. Now the nodes know of each other. To get Mnesia started, you have to create a schema on each node. A schema is located on the file system, in the same location where the actual disc-copies of tables will reside. [node()|nodes()] creates a list of the current node and all the other connected nodes. ls() shows the directory that Mnesia has created for the database.<br /><br /><pre class="consoleA"><br />(node1@node1.21ccw.blogspot.com)5&gt; mnesia:create_schema([node()|nodes()]).<br />ok<br /><br />(node1@node1.21ccw.blogspot.com)6&gt; ls().<br />Mnesia.node1@node1.21ccw.blogspot.com<br />ok<br /></pre><br /><br /><pre class="consoleB"><br />(node2@node2.21ccw.blogspot.com)2&gt; ls().<br />Mnesia.node2@node2.21ccw.blogspot.com<br />ok<br /></pre><br /><br />Now we have to start Mnesia on both nodes. You will notice that when we do an mnesia:info on node2 at this point, that it shows both nodes as being running database nodes.<br /><br /><pre class="consoleA"><br /><br />(node1@node1.21ccw.blogspot.com)8&gt; mnesia:start().<br />ok<br /></pre><br /><br /><pre class="consoleB"><br />(node2@node2.21ccw.blogspot.com)3&gt; mnesia:start().<br />ok<br /><br />(node2@node2.21ccw.blogspot.com)4&gt; mnesia:info().<br />...<br />running db nodes = ['node1@node1.21ccw.blogspot.com','node2@node2.21ccw.blogspot.com']<br />...<br /></pre><br />Next we'll create an actual database table, and populate it with some data. We define a record using rd(), then create a table on node1 (by default, this table will reside in RAM and have a disc copy), write a record to it and then read the record again. The primary key of the table is the first field of the record, i.e. the name.<br /><br /><pre class="consoleA"><br />(node1@node1.21ccw.blogspot.com)9&gt; rd(person, {name, email_address}).<br />person<br /><br />(node1@node1.21ccw.blogspot.com)10&gt; mnesia:create_table(person, [{attributes, record_info(fields, person)}, {disc_copies, [node()]}]).<br />{atomic,ok}<br /><br />(node1@node1.21ccw.blogspot.com)11&gt; mnesia:transaction(fun() -&gt; mnesia:write(#person{name = "John", email_address = "john@21ccw.blogspot.com"}) end).<br />{atomic,ok}<br /><br />(node1@node1.21ccw.blogspot.com)14&gt; mnesia:transaction(fun() -&gt; mnesia:read({person, "John"}) end).<br />{atomic,[#person{name = "John",email_address = "john@21ccw.blogspot.com"}]}<br /><br />(node1@node1.21ccw.blogspot.com)15&gt; mnesia:info(). ...<br />...<br />[{'node1@node1.21ccw.blogspot.com',disc_copies}] = [person]<br />...<br /></pre><br /><br />What happens when we do the same read on node2? Remember that node has access to the person table <span style="font-style:italic;">only</span> via the network, since it resides in RAM and on disc on node1.<br /><pre class="consoleB"><br />node2@node2.21ccw.blogspot.com)5&gt; mnesia:transaction(fun() -&gt; mnesia:read({person, "John"}) end).<br />{atomic,[{person,"John","john@21ccw.blogspot.com"}]}<br /></pre>Nice. Mnesia has transparently read the record from a table that's on another machine :)<br /><br />Now we decide to copy the table to node2. This requires a single command. Mnesia does the copying of the actual data for you to the other machine, and when you look at the file system on node2, there will now be "person.DCD" file, which is the disc copy of the table.<br /><br /><pre class="consoleA"><br />(node1@node1.21ccw.blogspot.com)15&gt; mnesia:add_table_copy(person, 'node2@node2.21ccw.blogspot.com', disc_copies).<br />{atomic,ok}<br /></pre><br /><br /><pre class="consoleB"><br />(node2@node2.21ccw.blogspot.com)9&gt; ls("Mnesia.node2@node2.21ccw.blogspot.com").<br />DECISION_TAB.LOG LATEST.LOG person.DCD<br />schema.DAT<br />ok<br /></pre><br /><br />At this point, when you do a query on the person table, the actual data can come from either node. I'm not sure how Mnesia decides how to distribute the data, that's something to investigate further.<br /><br />Since the table is resident on both nodes, we can actually delete it from node1, and doing a read on node1 will now read the table over the network from node2:<br /><br /><pre class="consoleA"><br />(node1@node1.21ccw.blogspot.com)23&gt; mnesia:del_table_copy(person, node()).<br />{atomic,ok}<br /><br />(node1@node1.21ccw.blogspot.com)19&gt; mnesia:info().<br />...<br />[{'node2@node2.21ccw.blogspot.com',disc_copies}] = [person]<br />...<br /><br />(node1@node1.21ccw.blogspot.com)18&gt; mnesia:transaction(fun() -&gt; mnesia:read({person, "John"}) end).<br />{atomic,[#person{name = "John",email_address = "john@21ccw.blogspot.com"}]}<br /></pre><br />Cool.<br /><br />What I've show is how to start up an Erlang/Mnesia node on two machines that are networked together, create tables on either node, and move the tables to other nodes by copy