http://wiki.debian.org/skype に書いてあるとおり。
sudo dpkg --add-architecture i386
sudo apt-get update
wget -O skype-install.deb http://www.skype.com/go/getskype-linux-deb
sudo dpkg -i skype-install.deb
ひっかかったら
sudo apt-get -f install
Skype のバージョン 4.0.0.7 になってた。この前まで 2.x.x? beta だったのに。画面の共有もできるようになったようだ。
満足して実装したい衝動が消えちゃう。。。
https://github.com/quek/info.read-eval-print.active-record
(establish-connection)
(defrecord prefecture ()
()
(:has-many :facilities))
(defrecord facility ()
()
(:belongs-to :prefecture)
(:has-many :experiences :as :experiencable))
(defrecord experience ()
()
(:belongs-to :experiencable :polymorphic t))
(let ((facilities (with-ar (facility)
(where "name like ?" "%水族館")
(where :publish 1)
(order :name)
(get-list))))
(values
(mapcar #'name-of facilities)
(name-of (prefecture-of (car facilities)))))
(facilities-of (with-ar (prefecture)
(where "id = 1")
(get-first)))
(experiences-of (with-ar (facility)
(get-first)))
(experiencable-of (with-ar (experience)
(get-first)))
(with-ar (facility)
(joins :prefecture)
(where :prefectures.name "鳥取県")
(get-list))
ときどき Active Record を Common Lisp で実装したくなる。それでひっかかるものの一つがメソッドチェーン。
Ralis の Active Record Query Interface や jQuery や S2JDBC とか、メソッドチェーン多いよね。でも、Common Lisp だとメソッドチェーンはやりにくい。
リーダマクロという手はあるが、 Common Lisp らしくスペシャル変数と with 系マクロでいきたいと思う。
こんな感じになる。
(with-ar (facility)
(where "name like ?" "%水族館")
(when only-published-p
(where :publish 1))
(order :name)
(get-list))
with-ar でかこんで、後は普通に関数呼び出し。メソッドチェーンは条件分岐があるとめんどうだけで、普通の関数呼び出しだから when や if の条件分岐とかも間に入れられる。
次のような defvar と defmacro だけで簡単にできちゃう。
(defvar *association* nil "association")
(defmacro with-ar ((table) &body body)
`(let ((*association* (ensure-association ,table)))
,@body))
好きな言語がスペシャル変数とマクロのある言語でよかった。
Opera の調子がずっとよくなかった。 Facebook, Twitter がまともに動かない。エクステンションはことごとく「XML の解析に失敗しました」といエラーになる。
いいかげん他のブラウザを使うべきもかしれないと、本気で考えていた。他のブラウザにするぐらいなら ~/.opera を捨ててみるか、と rm -rf ~/.opera してみた。
全てが解決した。バージョン 8 くらいから使い続けていた ~/.opera だったので、最近の Opera ではいろいろと不都合があったのでしょう。
ダニエル・ピンクの「モチベーション 3.0」を読んだ。よかった。「自律」について私が感じていることを、見事に説明してくれた。
しかし、一つだけわからないことが。何でこの本借りたんだろう? 私があまり読まなさそうなタイプの本なのに。
サーバ側
(defparameter *port* 1958)
(defgeneric server-start (server))
(defgeneric server-stop (server))
(defclass* server ()
((host usocket:*wildcard-host*)
(port *port*)
(listen-thread nil)))
(defmethod server-start ((server server))
(setf (listen-thread-of server)
(sb-thread:make-thread
(lambda ()
(usocket:with-socket-listener (socket (host-of server) (port-of server) :reuse-address t)
(loop (usocket:with-connected-socket (connected-socket
(usocket:socket-accept socket))
(let ((stream (usocket:socket-stream connected-socket)))
(print (eval (read stream)) stream)
(force-output stream))))))
:name "nunumo:server")))
(defmethod server-stop ((server server))
(sb-thread:terminate-thread (listen-thread-of server))
(setf (listen-thread-of server) nil))
クライアント側
(defgeneric client-open (client))
(defgeneric client-close (client))
(defgeneric client-read (client))
(defgeneric client-write (client object))
(defgeneric client-flush (client))
(defclass* client ()
((host "localhost")
(port *port*)
(socket nil)
(stream nil)))
(defmethod client-open ((client client))
(setf (socket-of client)
(usocket:socket-connect (host-of client) (port-of client))
(stream-of client)
(usocket:socket-stream (socket-of client)))
client)
(defmethod client-close ((client client))
(force-output (stream-of client))
(usocket:socket-close (socket-of client))
client)
(defmethod client-read ((client client))
(read (stream-of client)))
(defmethod client-write ((client client) object)
(print object (stream-of client)))
(defmethod client-flush ((client client))
(force-output (stream-of client))
client)
はい。RPC システム完成!
(let ((server (make-instance 'server))
(client (make-instance 'client)))
(server-start server)
(unwind-protect
(progn
(client-open client)
(client-write client '(format nil "(+ 1 2) => ~a" (+ 1 2)))
(client-flush client)
(client-read client))
(server-stop server)))
;;=> "(+ 1 2) => 3"
sb-concurrency:queue を使ってみる。
(defstruct (thread-pool (:constructor %make-thread-pool))
(queue)
(name)
(stop)
(sleep-time)
(threads))
(defun make-thread-pool (number-of-thread &key
name
(sleep-time 0.1))
(let ((stop (cons nil nil))
(queue (sb-concurrency:make-queue)))
(%make-thread-pool
:name name
:queue queue
:stop stop
:sleep-time sleep-time
:threads (collect 'bag
(sb-thread:make-thread
(lambda ()
(loop until (car stop)
do (multiple-value-bind (job ok)
(sb-concurrency:dequeue queue)
(if ok
(funcall job)
(sleep sleep-time)))))
:name (format nil "~a worker thread ~d" name
(scan-range :from 1 :upto number-of-thread)))))))
(defun stop-thread-pool (thread-pool)
(setf (car (thread-pool-stop thread-pool)) t))
(defun join-thread-pool (thread-pool)
(stop-thread-pool thread-pool)
(collect-ignore (sb-thread:join-thread (scan (thread-pool-threads thread-pool)))))
(defun add-job (thread-pool job)
(sb-concurrency:enqueue job (thread-pool-queue thread-pool)))
(defun wait-thread-pool (thread-pool)
(loop until (sb-concurrency:queue-empty-p (thread-pool-queue thread-pool))
do (sleep (thread-pool-sleep-time thread-pool))))
(defmacro with-thread-pool ((var number-of-thread
&key
(name "nunumo::thread-pool")
(sleep-time 0.1) )
&body body)
`(let ((,var (make-thread-pool ,number-of-thread
:name ,name
:sleep-time ,sleep-time)))
(unwind-protect
(progn ,@body)
(stop-thread-pool ,var))))
#|
(labels ((fib (n)
(if (<= n 2)
1
(+ (fib (1- n))
(fib (- n 2))))))
(let ((q (sb-concurrency:make-queue)))
(with-thread-pool (pool 4)
(dotimes (i 10)
(add-job pool (let ((n (+ 31 i)))
(lambda ()
(sb-concurrency:enqueue (cons n (fib n)) q)))))
(wait-thread-pool pool)
(join-thread-pool pool))
(sb-concurrency:list-queue-contents q)))
;;=> ((31 . 1346269) (32 . 2178309) (33 . 3524578) (34 . 5702887) (35 . 9227465) (36 . 14930352) (37 . 24157817) (38 . 39088169) (39 . 63245986) (40 . 102334155))
|#
