coderek (derek)

route 多个 url 到同一个 action

coderek — Wed, 21 Mar 2018 10:25:45 +0800

我有一个 vue app，它有自己的 router。我想把 vue routes 都 map 到同一个 rails 控制器的 action 上，不知道在 rails 里怎么写（除了一个一个的 map)。如果用 nginx proxy 就很容易，但我没有那个权限。

关于 Rails 官方文档

coderek — Tue, 20 Mar 2018 21:42:38 +0800

感觉官方的文档 http://api.rubyonrails.org/ 真的很乱。比如我想找 controller render function 有哪些 parameters，找了半天都还是不知道。难道 rails 就没有像 Java Doc 或者 django 一样格式的文档吗？

貌似这个论坛里没多少人用 Angular

coderek — Tue, 02 May 2017 10:52:39 +0800

好像大家用的都是 Vuejs，比较支持国产的。

有用 Angular 的回个贴，大家把这个节点搞起来。

Hacksummit - free talks NOW. DHH is talking

coderek — Tue, 02 Dec 2014 00:48:53 +0800

Live now! 狂点啊！！

https://hacksummit.org/

Geek Reader 我做的一个 Feed Reader

coderek — Wed, 05 Feb 2014 22:05:08 +0800

跟大家分享一下 Geek Reader。这是我的个人阅读器，也是我练手的一个项目。用到了 BackboneJS + Rails。我还没有什么生产项目的经验，所以程序写的还很业余。但基本的阅读器的功能都齐全了，支持移动端。

我的设想是它可以支持以下功能：

阅读样式编辑
对 Hacker News 特殊处理
有非常好的阅读体验包括移动端
自由创建 Feed (这个比较有挑战）

希望大家可以提点建议，或者有什么好的 idea。最终的目的是想做成一个 Geeks 都爱用的 Reader。

源码地址：https://github.com/coderek/geek-reader

Understand OOP (inheritance)

coderek — Tue, 26 Nov 2013 16:44:49 +0800

前一篇 http://ruby-china.org/topics/15758

OOP language is used to model all kinds of objects in universe. With different levels of abstraction, there are certain hierachical relationships among the objects. Inheritance is used to describe such relationships. Inheritance is a key concept of OOP. All the OOP langauges have some kind of built in inheritance.

For example, all Ruby objects inherits Object class; Object class inherits Kernel module and BasicObject class.

why care about it?

Code can be reused.
Common attributes and methods of objects can be collected to form a parent class.
Class behaviors can be overriden and extended according to specific needs.
This can be useful when using third parting libraries.

Inheritance always create new subtypes or supertypes. A dynamic type system is need to manage all. This will be covered by my next post.

how does it work?

All classical OOP languages have built in keywords for inheritance. In Ruby, this is super easy. But let's look at Javascript instead. As it's prototype-based and inheritance can be a bit tricky:

// constructor for animal
var Animal = function (name) {
  this.name = name;
};
Animal.prototype.walk = function () {
  console.log(this.name+" is walking.");
}

// constructor for dog -> animal
var Dog = function (name, age) {
  // call parent constructor
  this.constructor.prototype.constructor.apply(this, arguments);
  this.age = age;
};
// copy a parent's prototype and assign to sub class
Dog.prototype = Object.create(Animal.prototype);

Dog.prototype.bark = function () {
  console.log("bark bark, I am "+this.age+" years old.");
};

var animal = new Animal("animal");
var dog = new Dog("dog", 19);

console.log(animal instanceof Dog);    // false
console.log(animal instanceof Animal); // true
console.log(dog instanceof Dog);    // true
console.log(dog instanceof Animal); // true

A major constraint of most implementations of inheritance is that they can inherit from only one parent. Obviously, this does not resemble the real life scenarios, where a Dog can be both Animal and Pet, for example.

This is the major criticism of inheritance. The followings will demonstrate how languages circumvent the restrictions of single inheritance while still achieve the same benefits.

mixins

Mixins can be viewed as groups of shared functions between objects. One common example is Utility functions. Class can include the functions in the class definitions hence inherit their functionalities. One distinction of mixins in dynamic languages is that the included functions can automatically inherit the scope of the host object and gain access to object's variables and methods.

open class

Open class is a feature of dynamic langauges. The class definition can be changed after it's been defined. This can be used to extend the class without inheriting it.

Here is how Ruby use mixin and open class:

# mixin
module Intelligient
  def do_math
    "#{@name}: calculating 1+1"
  end
end

# mixin
module Emotional
  def cry
    "#{@name}: cries..."
  end
end

class Animal
  # inherit both
  include Intelligient
  include Emotional

  attr_reader :name
  def initialize name
    @name = name
  end
end

dog = Animal.new ("dog")
puts dog.do_math
puts dog.cry
puts "#{dog.name} can bark? #{dog.respond_to? :bark}" # false

# open class
class Animal
  def bark
    "#{@name}: bark bark"
  end
end

# after modify the class, the `dog` object can bark now. 
puts "#{dog.name} can bark? #{dog.respond_to? :bark}" # true

# check types
puts dog.is_a? Intelligient # true
puts dog.is_a? Emotional    # true
puts dog.is_a? Animal       # true

A few things can be observed here. Ruby uses module to create mixins. Thus mixins cannot be instantiated. After including mixins dog object has the characteristics of 3 types now, namely Intelligent, Emotional and Animal. This is multiple inheritance created using mixins. Open calss can be used to add new object behavior, even though the objects have already been initialized. However, the side effect is the potential unwanted overriding of existing methods. Open class is also called monkey patch when it's not used carefully.

Now Javascript:

// require underscorejs

var log = function (msg) {
  console.log(msg);
};
// mixin 1
var Intelligient = {
  do_math: function () {
    return this.name + " calculating 1+1";
  },
};
// mixin 2
var Emotional = {
  cry: function () {
    return this.name + " cries..."
  }
};

var Animal = function (name) {
  this.name = name;
};

var dog = new Animal("dog");
// mixins
// also can extend Animal.prototype so mixins will apply to all animals 
_.extend(dog, Intelligient, Emotional);

log(dog.do_math());
log(dog.cry());
log(dog.name + " can bark? " + (dog.bark == undefined));

// open class
Animal.prototype.bark = function () {
  return this.name + " bark bark";
};

log(dog.name + " can bark? " + (dog.bark == undefined));

log(dog instanceof Animal);       // true
log(dog instanceof Intelligient); // error
log(dog instanceof Emotional);    // error

Here, I used underscoreJS's extend method to inherit from mixins.It's almost the same as Ruby except the type of the object. Since I create mixins as plain object, it does not have a constructor type. But I can easily use duck typing to decide the type of the object. This is not a big deal in dynamic language.

Let's look at Java.

Java doesn't have the concept of mixins and open class. Once the class is defined, there is no way to modify it.

I have to create a sub class which inherits the parent class and modify from inside the sub class. Java also has the qualifier final, protected and private to control the accessibility of the internals of parent class. So when inheriting, sub class only gets what are needed and will not have access nor be able to override any private or final data or methods in parent. This makes Java safer than most dynamic languages.

Java uses composition over inheritance. Composition can be seen as a variant of mixin. It's a way of adding new behavior by creating delegate object inside the main object.

For example:

Here I want to create a controller which comprises printing functions and scanning functions.

class Test {

  abstract class Printer {
    TaskCallback callback;
    public void setCallback(TaskCallback _callback) {callback = _callback;}
    abstract public void print(); // define the behavior
  }

  abstract class Scanner {
    TaskCallback callback;
    public void setCallback(TaskCallback _callback) {callback = _callback;}
    abstract public void scan(); // define the behavior
  }

  interface TaskCallback {
    public void done(Printer p);
    public void done(Scanner p);
  }

  // one implementation of printer
  class ThreeDPrinter extends Printer {
    public void print () {
      System.out.println("print a 3D iron man!");
      callback.done(this);
    }
  }

  // one implementation of scanner
  class ThreeDScanner extends Scanner {
    public void scan() {
      System.out.println("scan a 3D iron man!");
      callback.done(this);
    }
  }

  // main class 
  class Controller implements TaskCallback {
    private Printer printer; // printer delegate
    private Scanner scanner; // scanner delegate

    public Controller(Printer _printer, Scanner _scanner) {
      printer = _printer;
      scanner = _scanner;
      printer.setCallback(this);
      scanner.setCallback(this);
    }

    public void doTask() {
      printer.print();
      scanner.scan();
    }

    public void done(Scanner s) {
      System.out.println("Received: scanner done!");
    }

    public void done(Printer p) {
      System.out.println("Received: printer done!");
    }
  }

  public void test () {
    Printer p = new ThreeDPrinter();
    Scanner s = new ThreeDScanner();
    Controller c = new Controller(p, s);
    c.doTask();
  }

  public static void main(String[] args) {
    Test t = new Test();
    t.test();
  }
}

delegations

iOS developers promote the idea of delegates to handle UI events or specific tasks with separate classes.

It's not so obvious for newbie Android/Java developers like myself at first, so what I did was to create an activity that implements quite a number of event listeners and do all handlings inside the activity, so it ends up with a whole chunk of un-reusable code.

interfaces

Though a Java class can have only one parent, it can implement many interfaces. By implementing multiple interfaces, a class can exhibit behaviors of multiple types. This is a way of multiple inheritance and it can be very useful together with polymorphism.

Summary

In Java, a class has to inherit a class to modify it's behavior. So inheritance is still a very important way of extending functions in such languages. In order to gain the flexibility, I have to carefully structure my program into components so that each component's functions can be shared.

Is inheritance necessary for dynamic language? The answer is probably yes. Though I can use mixins to model inheritance, mixins don't maintain states, i.e. they don't have instance variables. And inheriting a class makes the code look much cleaner. I haven't written enough Ruby or Javascript to fully appreciate its power yet. Maybe it also makes the code look more logical? I am not sure, just my guesses.

Understand OOP (encapsulation)

coderek — Sun, 24 Nov 2013 23:57:01 +0800

我是新手，觉得基础很重要，所以想写这个跟 OOP 有关的一个系列，欢迎大家拍砖！

In OOP, objects consist of data and methods. Data can be used to describe the states of the object while methods can be used to change the states of the objects.

Encapsulation is also called data hiding. It's the abstraction an object introduces to hide away data from outside, so that the user of the object cannot access the internals of the object directly other than using its exposed methods.

why care about it?

There are several benefits to encapsulate the data:

Hide away the data that is non-important to the users of the object but important to the workings of the object.
1. avoid messing up the internal states of the objects
2. let developers know only the necessities
Allow the object creator to define a consistent interface to access the members of an object, so whenever the internal mechanism or naming changes it won't affect the use of the objects.

Simply put, it allows to write elegant and secure code.

how does it work?

In Ruby it works like this

# encapsulation

class Animal
  def initialize name
    @name = name 
  end

  def name 
    @name
  end
end

animal = Animal.new "dog"
puts animal.name # "dog"

@ sign marks the instance variable. In Ruby, all instance variables are inaccessible directly from the instantiated object. There must be an method defined to read and write the instance variable. But for the sub class there is no such restrictions. Ruby also offers convenient methods attr_reader, attr_writer and attr_accessor to generate methods for you. Hence, the above example can be shortened:

# encapsulation (shortened)
class Animal
  attr_reader :name
  def initialize name
    @name = name
  end
end
animal = Animal.new "dog"
puts animal.name # "dog"

In Java, it is slightly different. The members of an object can be decorated using qualifiers. E.g. public, private, protected. public qualifier allows the member to be accessed directly. But this is generally considered as unsafe and thus discouraged. The JavaBean conventions enforce the use of private members and a set of setter and getter are to be defined for them.

class Animal {
  private String name;

  public String getName() {return name;}

  public void setName(String _name) {name = _name;}

  public static void main(String[] args) {
    Animal a = new Animal();
    a.setName("dog");
    System.out.println(a.getName()); // "dog"
  }  
}

In Javascript, the notion of encapsulation is somewhat arbitrary.

Functions in Javascript create a scope or closure. Variables are only accessible within the closure. However, every function invocation creates a function object which can have methods attached to it. Those function can be used as a way to access privately scoped variables. For example:

Animal = function (_name) {
  var name = _name; // private variable
  this.getName = function () {return name;};
  this.setName = function (_name) {name = _name;};
}
a = new Animal("dog");
a.getName(); // "dog"

Good thing is the name variable is entirely hidden away.

The problems of this method are:

it will be like Java, which creates a lot of getter and setter, this is troublesome and not scalable
when the function is used as an object constructor, the accessors defined inside constructor will be copied to all the objects memory space. This is a waste of memory

A probably better way is:

// inspired by BackboneJS
Animal = function () {
  this.attributes = {};
}
Animal.prototype.get = function (name) {
  return this.attributes[name];
}
Animal.prototype.set = function (name, val) {
  this.attributes[name] = val;
}
dog = new Animal;
dog.set("name", "dog");
dog.get("name"); // "dog"

It creates generic get and set methods, thus save a lot of keystrokes as well as memories.

However, one can still access and change dog.attributes.

In ECMAScript 5, a concept of property is defined. An object can define properties that can be configured. The configrable attributes include:

value -> value of property
writable -> whether the property can be modified
enumerable -> whether the property can be see in for..in loop
configurable -> whether the property can be deleted or attributes can be changed

By setting writable and configurable to false, the property can be prevented from modifications.

// inspired by JS Definitive Guide 6th Edition
var p = {};
Object.defineProperty(p, "x", {
  value: 1.0, 
  writable: false, 
  enumerable: false, 
  configurable: false
});
p.x // 1.0
p.x = 2
p.x // 1.0

One thing about the object property, though the property value cannot be changed, it doesn't hide the data entirely. The property value can still be poked. And given the lengthy property definition, the previous prototypal methods may be a better option.

Summary

Encapsulation is just one of many programming paradigms. It's not unique to OOP language. In C, this has be been used extensively. Here I have covered 3 typical main stream OOP languages. Though the implementation of encapsulation is different but the fundamental idea is same for all. After understanding this, I can make better decisions when I design objects.

怎样部署 octopress 在 rails server

coderek — Thu, 15 Aug 2013 11:18:12 +0800

现在我的做法是将 octopress _deploy 下的所有文件丢在 rails public 文件夹下。

然后这是我的 routes.rb

MySite::Application.routes.draw do
  scope "/feeds_reader" do
    ...
  end

  match ":action" => ":action/index.html"
end

我的 rails 有跑一个 feed reader app 在 /feeds_reader 我想让其他的 routes 都 route 到 octopress 的静态文件里. octopress 很多 post link 是以 / 结尾，比如说 http://derekzeng.me/blog/2013/08/11/understanding-backbone-2/

其实这是指向 index.html 文件，rails 貌似默认不能直接转到 index.html 所以 routes.rb 里面最后要转一下。

现在问题是，这个 setup 只在 devlopment environment 里面其作用。用了 assets precompilation 之后在 production 里面就不 work 了。

哪位大虾可以帮忙小弟诊断一下吗？