now he can’t find the ‘find’ file when i route to it in the webbrowser. The other files does work in the browser when i route to them.

Could someone help me?

find.html.erb:

Listing client_workouts for

Trainer
Duration mins
Date of workout
Paid amount

‘Are you sure?’, :method => :delete %>

client_workouts controller

class ClientWorkoutsController @client_workouts }
end
end

# GET /client_workouts/1
# GET /client_workouts/1.xml
def show
@client_workout = ClientWorkout.find(params[:id])

respond_to do |format|
format.html # show.html.erb
format.xml { render :xml => @client_workout }
end
end

# GET /client_workouts/new
# GET /client_workouts/new.xml
def new
@client_workout = ClientWorkout.new

respond_to do |format|
format.html # new.html.erb
format.xml { render :xml => @client_workout }
end
end

# GET /client_workouts/1/edit
def edit
@client_workout = ClientWorkout.find(params[:id])
end

# POST /client_workouts
# POST /client_workouts.xml
def create
@client_workout = ClientWorkout.new(params[:client_workout])

respond_to do |format|
if @client_workout.save
flash[:notice] = ‘ClientWorkout was successfully created.’
format.html { redirect_to(@client_workout) }
format.xml { render :xml => @client_workout, :status => :created, :location => @client_workout }
else
format.html { render :action => “new” }
format.xml { render :xml => @client_workout.errors, :status => :unprocessable_entity }
end
end
end

# PUT /client_workouts/1
# PUT /client_workouts/1.xml
def update
@client_workout = ClientWorkout.find(params[:id])

respond_to do |format|
if @client_workout.update_attributes(params[:client_workout])
flash[:notice] = ‘ClientWorkout was successfully updated.’
format.html { redirect_to(@client_workout) }
format.xml { head :ok }
else
format.html { render :action => “edit” }
format.xml { render :xml => @client_workout.errors, :status => :unprocessable_entity }
end
end
end

# DELETE /client_workouts/1
# DELETE /client_workouts/1.xml
def destroy
@client_workout = ClientWorkout.find(params[:id])
@client_workout.destroy

respond_to do |format|
format.html { redirect_to(client_workouts_url) }
format.xml { head :ok }
end
end

def find
@client_workouts = ClientWorkout.find(:all,
:conditions=>["client_name = ? OR trainer = ?", params[:search_string], params[:search_string]])
end
end

client_workouts model

class ClientWorkout < ActiveRecord::Base
attr_accessible :client_name, :trainer, :duration_mins, :date_of_workout, :paid_amount
end

hope you can help me :)

It’s actually not that hard to come up with MECE lists. Almost any categories will do, as long as you follow some simple rules. Let’s say that you have some coloured balls and you make some categories for them: Red, Blue and Yellow. Now, if you have balls of primary colours, then your categories are MECE. But let’s say a purple ball comes along. Now the categories no longer seem Mutually Exclusive.

To solve this, firstly identify some primary categories for the entities of interest. A primary category is a predicate: a property (a feature) that your objects either have or don’t have. Now ensure that the primary categories are “multi-selectable”. That is, for any object you will select all the primary categories that are applicable. We can now build general categories from the evaluation of the bundles of primary categories. For example, treat Red, Blue and Yellow as primary categories. A general category is then the evaluation of the bundle of the three primary colour categories. One such general category is (Red=yes, Blue=no, Yellow=no). Another general category, known as “purple”, is (Red=yes, Blue=yes,Yellow=no). The three primary colours lead to 8 categories in total.

These categories are mutually exclusive, due to the binary nature of predicates. Of course, proper interpretation of the primary categories is necessary. For example, if a ball is Red today and Blue tomorrow, then you have to decide whether your categories mean colour on all days, or a specific day… or perhaps decide to add some more predicates to handle time.

These categories are also collectively exhaustive, as long as you include all possible evaluations of the predicates. In other words, all yes/no combinations across all primary categories.

However, we need to add one more item: what Scotus referred to as “indicating”. That is, our categories need to be relevant to the entities that we’re categorising and there need to be such entitites in the first place. So, our example categorisation is appropriate for coloured balls, but not for, say, types of numbers (nor for certain types of logical puzzles, such as Russell’s paradox… but that’s another story).

So,the recipe for better MECE lists is to use Multi-Selectable, Indicating Categories (MuSIC).