One of the best scripts for file uploading is valums/file-upoader.

Valums Ajax Upload Plugin Overview

This plugin uses XHR for uploading multiple files with progress-bar in FF3.6+, Safari4+, Chrome and falls back to hidden iframe based upload in other browsers, providing good user experience everywhere.

Features

• multiple file select, progress-bar in FF, Chrome, Safari
• drag-and-drop file select in FF, Chrome
• uploads are cancellable
• no external dependencies
• doesn’t use Flash
• fully working with https
• keyboard support in FF, Chrome, Safari
• tested in IE7,8; Firefox 3,3.6,4; Safari4,5; Chrome; Opera10.60;

Setup File Uploader plugin on ASP.NET MVC site

Here is step-by-step instructions how to setup file-uploader script on your page on ASP.NET MVC site.

- Download the script from github.

- Save files to the root of your project (or any folder you want). You need these three files:

/js/fileuploader.js

/css/fileuploader.css

/img/loading.gif

- Put the script on your page (view):

Source code

<link href="@Url.Content("~/css/fileuploader.css")" rel="stylesheet" type="text/css" />
<script src="@Url.Content("~/js/fileuploader.js")" type="text/javascript"></script>
 
<div id="file-uploader">
<noscript>
<p>Please enable JavaScript to use file uploader.</p>
</noscript>
</div>
 
<script type="text/javascript">
var uploader = new qq.FileUploader({
element: document.getElementById('file-uploader'),
action: '@Url.Action("upload")' // put here a path to your page to handle uploading
//,allowedExtensions: ['jpg', 'jpeg', 'png', 'gif'] // user this if you want to upload only pictures
sizeLimit: 4000000, // max size, about 4MB
minSizeLimit: 0, // min size
 
 });
</script>

- Create an ASP.NET MVC  controller which will handle the file uploading and save the file to some location on the server:

Source code

public class HomeController : Controller
{
..
[HttpPost]
public ActionResult Upload(HttpPostedFileBase qqfile)
{
if (qqfile != null)
{
// this works for IE
var filename = Path.Combine(Server.MapPath("~/app_data"), Path.GetFileName(qqfile.FileName));
qqfile.SaveAs(filename);
return Json(new { success = true }, "text/html");
}
else
{
// this works for Firefox, Chrome
var filename = Request["qqfile"];
if (!string.IsNullOrEmpty(filename))
{
filename = Path.Combine(Server.MapPath("~/app_data"), Path.GetFileName(filename));
using (var output = System.IO.File.Create(filename))
{
Request.InputStream.CopyTo(output);
}
return Json(new { success = true });
}
}
return Json(new { success = false });
}
}

Note that the controller action must return JsonResult.

Also note that there are two different ways to handle uploads from IE and other (Firefox/Chrome) browsers. The issue here that IE uploads uses multipart-mime while other browsers use Octet-Stream. And Valums Ajax plugin sends an application/octet-stream instead of multipart/form-data which is what the default model binder can work with.

Fine more examples on github.

Some discussions on stackoverflow about known issues:

- http://stackoverflow.com/questions/4884920/mvc3-valums-ajax-file-upload

- http://stackoverflow.com/questions/9882692/valums-file-uploader-doesnt-work-under-internet-explorer-9

- http://stackoverflow.com/questions/4888632/mvc-valums-ajax-uploader-ie-doesnt-send-the-stream-in-request-inputstream

The following code connects to mysql database and retrieves some data.

Source code

require 'mysql2'
 
    db = Mysql2::Client.new(:host => 'localhost', :username => 'root', :password=> 'password', :database => 'db_name'   )
 
    res = db.query("select * from users")
    res.each do |row|
      col1 = row['id']
      col2 = row['email']
 
   ..
    end

Install Redis server under Windows

Redis was primarily developed on *NIX operating systems. If you’re looking to install on a *NIX platform the best place to download Redis is still from the redis project website.

Start from Redis project download page. The Redis project does not directly support win32/win64. Unofficial versions of Redis for Windows are available for downloading:

• A Native win32/win64 port created by DuÅ¡an Majkić.
• A patch released by Microsoft based on libuv.

Seems like the Windows Redis port by Dušan Majkić is the most popular. You can download it from here.

Install Redis server as a service under Windows

If you run Redis on Windows machine, the best option is to run each Redis instance as Windows service.

You can install the Windows Redis port by Dušan Majkić as follows:

- Download the Windows Redis port by Dušan Majkić.

- Extract it to C:\Program Files\Redis or any other directory.

- Download the Windows Redis service program by Konstantin Cherenkov and put it into the same directory. So you have the file

C:\Program Files\Redis\RedisService.exe

- Run the following to install the service:

Source code

sc create Redis start= auto DisplayName= Redis binpath= "\"C:\Program Files\Redis\RedisService.exe\" \"C:\Program Files\Redis\redis.conf\""

where “Redis” can be any name of your service.

- Run the service. Go to your Windows Management / Services and run the service and/or make it run Automatically after the system starts.

- To uninstall service run

Source code

sc delete Redis

where “Redis” is the name of the installed service.

The instructions are taken from How to Run Redis as a Service under Windows and Run Redis as Service on Windows.

C# .NET Client Library

ServiceStack client library:

ServiceStack’s C# Redis Client is an Open Source C# Redis client based on Miguel de Icaza previous efforts with redis-sharp.

Download ServiceStack from  github page.

Also you can download the Redis Client in any one of the following ways:

• Packaged by default in ServiceStack.dll
• Available to download separately as a stand-alone ServiceStack.Redis.dll
• As Source Code via Git: git clone git://github.com/ServiceStack/ServiceStack.Redis.git
• For those interested in having a GUI admin tool to visualize your Redis data should check out the Redis Admin UI

Overview of  ServiceStack

ServiceStack has several interfaces:

• ICacheClient – If you are using Redis solely as a cache, you should bind to the ServiceStack’s common interface as there already are In-Memory an Memcached implementations available in ServiceStack, allowing you to easily switch providers in-future.
• IRedisNativeClient – For those wanting a low-level raw byte access (where you can control your own serialization/deserialization) that map 1:1 with Redis operations of the same name.

For most cases if you require access to Redis-specific functionality you would want to bind to the interface below:

• IRedisClient – Provides a friendlier, more descriptive API that lets you store values as strings (UTF8 encoding).
• IRedisTypedClient – created with IRedisClient.GetTypedClient<T>() – it returns a ‘strongly-typed client’ that provides a typed-interface for all redis value operations that works against any C#/.NET POCO type.

Classes:

• The RedisNativeClient exposes raw byte[] apis and does no marshalling and passes all values directly to redis.
• The RedisClient assumes string values and simply converts strings to UTF8 bytes before sending to Redis
• The RedisTypedClient provides a generic interface allowing you to add POCO values. The POCO types are serialized using .NETs fastest JSON Serializer which is then converted to UTF8 bytes and sent to Redis.

Read the tutorial about using ServiceStack here.

Examples

Caching using Redis and ServiceStack client library:

Source code

using ServiceStack.Redis;
//
RedisClient redisClient = new RedisClient("localhost");
// store some value in cache for one hour
RedisClient.Set("mykey_1" + name, 15, TimeSpan.FromSeconds(3600));
// get typed value from cache
int valueFromCache = RedisClient.Get<int>("mykey_1"); // must be = 15

You can find a lot of examples on ServiceStack github page

One of the common tasks in programming web applications on Rails is finding a row in a table by several columns and creating a new row in case of row is missing.

Find by one attribute

This will find a row by ‘name’ column in table ‘Products’ and will create a new row if not found.

Source code

Product.find_or_create_by_name('name here')

If you want a new row to be created with many other attributes then you can pass them as a hash:

Source code

Product.find_or_create_by_name('namehere', :category_id=>1,  :enabled=>true, :in_stock=>0, :price=>100)

Find by multiple attributes

If you want to find by multiple attributes you can use model’s methods like find_or_create_by_field1_and_field2(field1_value, field2_value).

Source code

Product.find_or_create_by_name_and_category_id('namehere', 10)

If you want to pass multiple attributes to a new row to be created then you can use the following syntax:

Source code

Product.find_or_create_by_name_and_category_id('namehere', 10) do |r|
r.price= 100
r.available = true
r.enabled=1
r.in_stock=0
end

Notice that you cannot pass extra parameters to Product.find_or_create_by_name_and_category_id method because it expects only two parameters. Thanks Rails this method can be passed a block with your code and this code will be invoked for the new row to be initialized.

Without all that Ruby’s magic the task could be achieved with the following code:

Source code

attr = { :enabled=>true, :in_stock=>0, :price=>100}
row = Product.find_by_name_and_category_id('namehere', 10) || Product.create(attr)

You must agree that this code looks not so elegant and concise.
Details are here on Github

Ruby has a lot of metaprogramming features allowing you to create your own custom methods on the fly which can be used the same as att_accessor.

dynamic method definition – define_method

Use the following code to define a new method in your class on the fly:

Source code

class Myclass
define_method("your_method_name_here") do
# your code here
end
end

Custom attr_accessor method accessible from all classes

To create a method that will be accesible from all classes you need to add code to the Class class. In Ruby a class is simply an object of class Class. Ruby provides a method class_eval that takes a string and evaluates it in the context of the current class, that is, the class from which you’re calling your attr_accessor.

Source code

class Class
def my_custom_attr_method(attr_name)
# your code here
end
end
# you can use this method in any of your classes
class Myclass
my_custom_attr_method :attr1
end

attr_accessor

Ruby’s method attr_accessor uses metaprogramming to create getters and setters for object attributes on the fly.

It creates the code like this:

Source code

class Class
 
def my_attr_accessor(*args)
 
    # iterate through each passed in argument...
    args.each do |arg|
 
        # getter
        self.class_eval("def #{arg};@#{arg};end")
 
        # setter
        self.class_eval("def #{arg}=(val);@#{arg}=val;end")
 
    end
 
end
end

Examples

Below is some examples of using metaprogramming.

Create custom attr_accessor to track the history of values

Define a method attr_accessor_with_history that provides the same functionality as attr accessor but also tracks every value the attribute has ever had.

This method was taken from the home work task of the class ‘Software as a service’ – https://www.coursera.org/saas/auth/welcome.

Source code

class Class
 
  def attr_accessor_with_history(attr_name)
    attr_name = attr_name.to_s
    attr_hist_name = attr_name+'_history'
 
    #getter
    self.class_eval("def #{attr_name};@#{attr_name};end")
 
    #setter
    self.class_eval %Q{
      def #{attr_name}=(val)
        # add to history
        @#{attr_hist_name} = [nil] if @#{attr_hist_name}.nil?
        @#{attr_hist_name} << val
 
        # set the value itself
        @#{attr_name}=val
      end
 
      def #{attr_hist_name};@#{attr_hist_name};end
 
                    }
 
  end
 
end

Usage of this accessor:

Source code

class Foo
attr_accessor_with_history :bar
def initialize(some_bar_value)
self.bar = some_bar_value
end
end
 
f = Foo.new
f.bar = 3
f.bar = :wowzo
f.bar = 'boo!'
puts f.bar_history # => [nil, 3, :wowzo, 'boo!']

Note! You should use self.bar in the initializer method so it calls our custom setter to track the history.

If you write bar=some_bar_value then it will create a local variable ‘bar’ that doesn’t do what is intended.

Strongly typed attr_accessor

Source code

class Myclass
  def self.typesafe_accessor(name, type)
 
  define_method(name) do
    instance_variable_get("@#{name}")
  end
 
  define_method("#{name}=") do |value|
    if value.is_a? type
      instance_variable_set("@#{name}", value)
    else
      raise ArgumentError.new("Invalid Type")
    end
  end
end
 
typesafe_accessor :foo, Integer
 
end
 
# usage
 
f = Foo.new
f.foo = 1
f.foo = "bar" # an exception thrown here!

You can modify this code to create an accessor so it can be used in all classes. To do this – move this code to class Class and modify it a little like in the first example.

This code is based on this explanation: http://stackoverflow.com/questions/7988410/attr-accessor-strongly-typed-ruby-on-rails

Read more:

- Meta-programming in Ruby – http://learnbysoft.blogspot.com/2010/10/meta-programming-in-ruby-part-1-alias.html

- Screencasts on The Ruby Object Model and Metaprogramming – http://pragprog.com/screencasts/v-dtrubyom/the-ruby-object-model-and-metaprogramming

Rules of naming of variables and methods:

- Use meaningful names.

For example “value”, “equals”, “data”, etc are not valid names of variables for any case.

Variable name must define the exact explanation of its content.

Method name must specify the exact action of the method and for most cases must start with a verb. (e.g. createPasswordHash)

Use meaningful names for method parameters, so it can documentate itself in case of no documentation.

- Use short enough and long enough variable names in each scope of code.

Generally length may be 1 char for loop counters, one word for condition/loop variables, 1-2 words for methods, 2-3 words for classes, 3-4 words for globals.

- Don’t reuse same variable name in the same class in different contexts: e.g. in method, constructor, class.

- Don’t use same variable for different purposes in a method, conditional etc. Create a new and different named variable instead.

- Don’t use non-ASCII chars in variable names.

- Use one natural language for naming, e.g. using mixed English and German names will be inconsistent and unreadable.

• Writing Code (programming, coding, hacking away)
• Overhead (Building, Deploying, Hardware, Software)
• Communication (Meetings, Chats, Teleconferences, etc)
• Problem-Solving (Debugging, Profiling, Performance Tuning)
• Firefighting (Crashes, Slowdowns, Security, etc)
• QA (Manual & Automatic Testing, Code Reviews)
• Strategy (Architecture, Refactoring, Thinking)
• Process (Bureaucracy, Reporting, Time-keeping, etc)
• Procrastination (slashdot.org, reddit.com,. Twitter, Facebook)

It means that

• Devs spend less time writing code than you might think. The median is 15 hours, programmers spend about 3 hours each work day writing code.
• Devs spend more time on non-development activities than you might think. For each coding hour, devs spend nearly 30min in meetings, reporting, writing emails and dealing with timesheets
• Devs spend more time fighting fires than building solutions

Information is taken from

http://zeroturnaround.com/blog/developer-productivity-report-part-1-developer-timesheet/

Ruby:

- elegant code

- not easy to learn

PHP:

- easy to learn for former C programmers

Rails has no direct way for doing this.

The solution can be as follows:

Source code

def before_save
  @was_a_new_record = new_record?
  return true
end
 
def after_save
  if @was_a_new_record
    ...
  end
end

update_attribute

Updates a single attribute and saves the record without going through the normal validation procedure. This is especially useful for boolean flags on existing records. The regular update_attribute method in Base is replaced with this when the validations module is mixed in, which it is by default.

Also note that

• Validation is skipped.
• Callbacks are invoked.
• updated_at/updated_on column is updated if that column is available.
• Updates all the attributes that are dirty in this object.

update_attributes

Updates all the attributes from the passed-in Hash and saves the record. If the object is invalid, the saving will fail and false will be returned.

Examples:

Source code

Object.update_attribute(:only_one_field, "Some Value")
Object.update_attributes(:field1 => "value", :field2 => "value2", :field3 => "value3")
Object.update_attributes(params[:user])

All of these will update an object in a database without having to explicitly tell AR to update.

update_attribute can update only one column with this and updated_at is not updated.

Validation

Use update_attribute to skip callbacks and validations.

The difference between two is update_attribute use save(false) where as update_attributes uses save or you can say save(true).

Callbacks

If perform_validation is false while calling save then it skips validation, and it also means that all the before_* callbacks associated with save.

Update attributes without saving

update_column(name, value)

Updates a single attribute of an object, without calling save.

• Validation is skipped.
• Callbacks are skipped.
• updated_at/updated_on column is not updated if that column is available.

Raises an ActiveRecordError when called on new objects, or when the name attribute is marked as readonly.

.attributes property

Use .attributes to update attributes of the model without saving it to a database.

Source code

@car = Car.new(:some_field=>'value', :another_field=>'value')
 
#
@car.attributes = {:title => 'Toyota', :year => 2005, :used=>false}
 
#other processing
..
 
#finally, save to DB
@car.save

Ref.
Discussions on StackOverflow:
http://stackoverflow.com/questions/2778522/rails-update-attribute-vs-update-attributes