ตอนนี้เปลี่ยนใจ ไปลง drupal แทนแล้วครับ ตามไปอ่านกันต่อได้ที่ http://www.iporsut.com ส่วน blog ที่นี่ก็ยังเปิดให้เข้ามาดูกันได้ปกติครับ

[ 58.593255 ] Kernel panic - not syncing: VFS: Unable to mount root fs on unknown-block(0,0)

ทำอะไรไม่ได้ก็เลยต้องหาแผ่น Live CD มาบูต ดีมีแผ่น Suriyan ที่ได้จากงาน miniDebCamp ติดกระเป๋า ก็เลยบูตเข้าไปที่ Suriyan ตัว Suriyan เองพัฒนาต่อมาจาก 9.10 Karmic ก็เลยใช้ grub2 เหมือนกัน

ตอนแรกก็ค้นหาวิธีในเนต หายังไงก็ไม่เจอ ก็เลยคิดว่าจะลองบูตเข้าไปที่ kernel ตัวเก่า ก็เลยหาวิธีแก้ให้มันแสดง menu ตอนบูต ปัญหาคือมันเป็น grub2 ซึ่งเปลี่ยนวิธี config ไปจากเดิมอย่างสิ้นเชิง ของเก่าเคยแก้แค่ไฟล์ menu.lst แค่ไฟล์เดียว ตอนนี้เข้าไปก็ไม่เจอไฟล์ menu.lst แล้ว

ค้นไปค้นมาไปเจอ document ของมันที่ https://wiki.ubuntu.com/Grub2 บอกวิธีแก้ให้มันแสดงเมนูโดยไปแก้ที่ไฟล์ /etc/default/grub ให้คอมเม้นที่

#GRUB_HIDDEN_TIMEOUT=3

GRUB_TIMEOUT=XXX

แต่ว่า เราใช้ Suriyan บูต ทำให้มันไม่มอง drive ที่เรา mount เป็น root (/) ต้องเปลี่ยนด้วยคำสั่ง chroot ก่อน

ด้านล่างของ document จะมีบอกวิธี chroot แต่ว่าก่อนจะ chroot จะทำการ –bind พวก /dev /proc และ /sys ก่อน ด้วยคำสั่ง ประมาณนี้

$ sudo mount --bind /dev /mnt/dev
$ sudo mount --bind /proc /mnt/proc
$ sudo mount --bind /sys /mnt/sys

$ sudo chroot /mnt

สุดท้ายวิธีแก้ kernel panic ก็คือ บูตไป kernel เก่า แล้วไป apt-get remove ตัว kernel ใหม่ เสร็จแล้ว apt-get install ใหม่อีกที หายเลยทีนี้

รีบเดินไป siam inter ก่อนเลย เพื่อ ปาฏิหาริย์แห่งผู้กล้า เล่ม 2 เลยซื้อ ปฐมบทผู้กล้า มาด้วยเพราะยังไม่ได้อ่าน เสร็จแล้วเดินๆไป บูตของ วินทร์ เลียววาริณ ได้มาอีก 2 เล่ม มังกรเซน กับ ปีกแดง แล้วก็ให้พี่เขาเซ็นให้เหมือนเดิม มาทีไร ได้ทุกที ย้ายไปต่อโซน C บูต ฟ้าเดียวกัน ช่วยกันซื้อคนละเล่มกับ @Bank_Xavi เอามาผลัดกันอ่าน เล่ม ข้อมูลใหม่ กับ พรมแดน แผนที่ ประวัติศาสตร์ ชาตินิยม แค่นี้หมดไปอย่างรวดเร็ว พันกว่าบาทแล้ว กลับบ้าน จัด ปาฏิหาริย์แห่งผู้กล้าก่อนเลย กำลังมัน

โดยใช้ Railo ซึ่งเป็น opensource coldfusion application server และ ใช้ javaloader ซึ่งเป็น library ที่ช่วยใช้ coldfusion โหลดคลาสจาวา โดยไม่ต้องเอา jar ไฟล์ไปไว้ใน coldfusion classpath และไม่จำเป็นต้อง restart server ใหม่

ตัวอย่างโค้ด

                <cfscript>
                        // กำหนด path ของ jar ไฟล์ที่จะโหลด
                        paths = arrayNew(1);
                        paths[1] = expandPath("/jassperreports-lib/commons-digester-1.7.jar");
                        paths[2] = expandPath("/jassperreports-lib/jasperreports-3.7.1.jar");
                        paths[3] = expandPath("/jassperreports-lib/groovy-all.jar");
      
                        //create the loader
                        loader = createObject("component", "javaloader.JavaLoader").init(paths);


                        // getConnection ที่จำเป็นต้องใช้ผ่าน coldfusion datasource
                        datasourceService = createObject("java","coldfusion.server.ServiceFactory").getDataSourceService();
                        connection = datasourceService.getDatasource("qualinet").getConnection();

                        // hashMap ไว้เก็บค่า Property ต่างๆ ที่จะส่งไป fill ให้ jasper report
                        hashMap = createObject("java","java.util.HashMap").init();
                        hashMap.put("QUOTATION_ID",toString(url.qid));
                        // โหลดคลาส แต่ยังไม่ได้ทำการสร้าง instance
                        JasperFillManager = loader.create("net.sf.jasperreports.engine.JasperFillManager");
                        JasperExportManager = loader.create("net.sf.jasperreports.engine.JasperExportManager");
                        // โหลดแล้วสร้าง instance เลย
                        jrEmptyDataSource = loader.create("net.sf.jasperreports.engine.JREmptyDataSource").init();
                        
                        // ทำการ fill report โดยส่ง path ของ file jasper , hashMap และ connection 
                        jasperPrint = JasperFillManager.fillReport("/home/iporsut/railo/webapps/ROOT/example-0.6/quotation.jasper",hashMap,connection);

                        // export report ไปเป็นไฟล์ pdf
                        JasperExportManager.exportReportToPdfFile(jasperPrint,"/home/iporsut/railo/webapps/ROOT/quotation.pdf");
                </cfscript>

import net.sf.jasperreports.engine.*;
import net.sf.jasperreports.engine.design.JasperDesign;
import net.sf.jasperreports.engine.xml.JRXmlLoader;
import net.sf.jasperreports.engine.export.*;
import java.util.*;
import java.sql.*;
public class TestJasper {
	public static void main(String[] args) {
		JasperReport jasperReport;
		JasperPrint jasperPrint;
		JasperDesign jasperDesign;
		Connection conn = null;
		
		Map parameters = new HashMap();
		try {
			Class.forName("com.mysql.jdbc.Driver");
			conn = DriverManager.getConnection("jdbc:mysql://localhost/database?useUnicode=true&characterEncoding=UTF-8&user=root&password=password");
                        // โหลดไฟล์ jrxml
			jasperDesign = JRXmlLoader.load("/home/iporsut/Sourcecode/report3.jrxml");
                        // คอมไพล์ report จะได้ไฟล์ report3.jasper
			jasperReport = JasperCompileManager.compileReport(jasperDesign);
                        // ส่ง parameters กับ connection ของ database ให้ jasper ทำการ fill report
			jasperPrint = JasperFillManager.fillReport(jasperReport,parameters,conn);
                        // export report ออกไปเป็นไฟล์ demo.pdf
			JasperExportManager.exportReportToPdfFile(jasperPrint,"/home/iporsut/demo.pdf");
		}catch (JRException e) {
			e.printStackTrace();
		}
		catch (ClassNotFoundException ex) {System.err.println(ex.getMessage());}
	    	catch (SQLException ex) {System.err.println(ex.getMessage());}
	    	
		finally
		{
			if (conn != null)
			{
				try {conn.close();} 
				catch (Exception ignored) {}
			}
		}
	}
}

ข้อนี้ให้ encode ลิสต์โดยแปลงให้กลายเป็น ลิสต์ของลิสต์ที่มีค่าแรกคือความยาวของตัวที่ซ้ำอีกตัวก็คือค่าที่ซ้ำ แต่ถ้าอันไหนยาวแค่ 1 ก็ไม่ต้องให้มีตัวเลขบอกจำนวน เช่น B กับ D

ข้อนี้ สำหรับ Haskell วันนี้ จะสร้าง data type ขึ้นมาใหม่ เพื่อเก็บข้อมูลที่เข้ารหัส เพราะ ว่า Haskell มันเก็บ ลิสต์ที่มี type ต่างกันปนกันไม่ได้

Haskell

import Data.List
data LengthEncode a =  L a |  LS Int a
                        deriving (Show)

encode::(Eq a)=>[a]-> [LengthEncode a]
encode [] = []
encode xs = map subEncode (zip (map length (group xs)) (map head (group xs)))
                where
                        subEncode x = if ((fst x) == 1)
                                        then
                                                (L (snd x))
                                        else
                                                (LS (fst x) (snd x))

สร้าง data type ชื่อ LengthEncode a โดยมี constructor 2 แบบคือ L a สำหรับกรณีความยาวแค่ 1 และ LS Int a สำหรับกรณีที่เหลือ

ตรงส่วนของฟังก์ชัน encode เราจะใช้ map เข้ามาช่วย ตรง (zip (map length (group xs)) (map head (group xs))) เราจับ xs ที่เข้ามาไป เรียกใช้ group เพื่อให้ได้ list แบบโจทย์ข้อ P09 แล้ว มาใช้ map length จะได้ลิสต์ของจำนวนซ้ำ ส่วน map head จะเอาแค่ตัวแรกตัวเดียว เสร็จแล้วจับมา zip รวมกันจะได้ list ของ tuple ที่ตัวหน้าเป็นจำนวน ตัวหลังเป็นอิลิเมนต์ที่ถูกเข้ารหัส แล้วสุดท้ายใช้ map subEncode โดยที่ subEncode จะแปลงจาก tuple ไปเป็นข้อมูลแบบ LengthEncode a จะใช้ L หรือ LS ก็แยกตามความยาว

Erlang

-module(pack).
-export([encode/1]).
pack ([]) ->    [];
pack (L)  ->    [H|_] = L,
                A = lists:takewhile(fun(X)-> X == H end,L),
                B = lists:dropwhile(fun(X)-> X == H end,L),
                [A | pack(B)].
encode([]) -> [];
encode(L)  -> ELEMCOUNT = lists:map(fun(X)->[H|_] = X,H end,pack(L)),
              COUNT = lists:map(fun erlang:length/1 ,pack(L)),
              ZIP = lists:zip(COUNT,ELEMCOUNT),
              lists:map(fun(X)->{C,E} = X, (if C == 1 -> E; C > 1 -> [C,E] end) end,ZIP).

Lisp

(defun my-filter (L A R)
        (if L
                (if (equal (first L) A)
                        (my-filter (rest L) A (cons (first L) R))
                        (cons R L)
                )
                (cons R L)
        )
)
(defun pack (L)
        (if L
                (cons (first (my-filter L (first L) nil)) (pack (rest (my-filter L (first L) nil))))
                nil
        )
)

(defun encode (L) (map 'list (lambda (X) (if (eql (length X) 1) (first X) (cons (length X) (cons (first X) nil)))) (pack L)))

history | awk ‘{CMD[$2]++;count++;}END { for (a in CMD)print CMD[a] ” ” CMD[a]/count*100 “% ” a;}’ | grep -v “./” | column -c3 -s ” ” -t | sort -nr | nl |  head -n10
1    126  25.2%  vim
2    92   18.4%  cd
3    86   17.2%  ls
4    68   13.6%  erl
5    26   5.2%   clisp
6    25   5%     ghci
7    24   4.8%   sudo
8    12   2.4%   exit
9    6    1.2%   kill
10    5    1%     ssh

เออ ช่วงนี้มี erl, clisp, ghci เยอะแฮะ ตอนแรกเดาว่า cd เยอะสุด แต่ก็ยังแพ้ VIM เหอะๆ ไม่มี emacs เลย

P09 (**) Pack consecutive duplicates of list elements into sublists.

If a list contains repeated elements they should be placed in separate sublists.

Example:
* (pack ‘(a a a a b c c a a d e e e e))
((A A A A) (B) (C C) (A A) (D) (E E E E))

ข้อนี้ จะจับอลิเม้นที่เหมือนกัน ที่อยู่ติดๆกันให้เป็นลิสต์ใหม่โดยผลลัพธ์สุดท้ายก็คือลิสต์ของลิสต์ที่จับตัวที่ซ้ำๆมาอยู่ด้วยกันแล้วนั่นเอง

ข้อนี้ถ้าใช้ takeWhile กับ dropWhile มาช่วยดึงเอาelementที่ซ้ำๆที่ติดกันออกมาจะง่ายหน่อย แต่จะยังไม่ใช้จะเขียนฟังก์ชันขึ้นมาช่วยเองอีกตัวใช้แยกลิสต์ที่เป็น input ออกเป็น 2 ส่วนคือ ส่วนที่ซ้ำ กับ element ที่เหลือที่หักส่วนที่ซ้ำออก ส่วนฟังก์ชัน pack หลักๆนั้นก็แค่ทำการเรียกฟังก์ชันที่ใช้แยกelementที่ซ้ำก็จะได้listของelementแล้วก็เอาลิสต์นั้นมาต่อๆกับผลลัพธ์ที่ได้จากการเรียกซ้ำส่วนที่เหลือของลิสต์

Haskell

pack::(Eq a)=>[a]->[[a]]
pack [] = []
pack xs = (fst (myFilter xs (head xs) [])):(pack (snd (myFilter xs (head xs) [])))
                where
                        myFilter [] a rs = (rs,[])
                        myFilter (x:xs) a rs | x == a = myFilter xs a (a:rs)
                                                        | otherwise =  (rs,(x:xs))

Erlang

-module(pack).
-export([pack/1]).
myfilter ([],_,R) -> [R];
myfilter ([L|T],A,R) when L == A -> myfilter (T,A,[L|R]);
myfilter (L,_,R) -> [R|L].
pack ([]) ->    [];
pack (L)  ->    [H|_] = L,
                                   [A|B] = myfilter(L,H,[]),
                                   [A | pack(B)].

Lisp

(defun my-filter (L A R)
        (if L
                (if (equal (first L) A)
                        (my-filter (rest L) A (cons (first L) R))
                        (cons R L)
                )
                (cons R L)
        )
)
(defun pack (L)
        (if L
                (cons (first (my-filter L (first L) nil)) (pack (rest (my-filter L (first L) nil))))
                nil
        )
)

การเขียนฟังก์ชันให้รอรับ message นั้นใช้คีย์เวิร์ด receive …. end. ตัวอย่างเช่น

-module(chat).
-export([alert/0]).

alert () ->
        receive
                Any ->
                        io:format("Alert : ~w~n",[Any])
        end.

ตรงระหว่าง receive กับ end นั้นจะเป็น pattern ของ message และ action เมื่อเจอ message pattern นั้นส่งมาหา process ที่กำลังทำงานฟังก์ชันนี้อยู่

ทีนี้ วิธีการส่ง message ไปหา process จะใช้รูปแบบนี้

Eshell V5.7.2  (abort with ^G)
1> c(chat).
{ok,chat}
2> PID = spawn(chat,alert,[]).
<0.42.0>
3> PID ! hello.
Alert Hello: hello
hello
4> halt().

โดยที่ทางซ้ายคือ PID (process id) ส่วนทางขวา จะเป็น message ที่ต้องการส่ง

receive end. จะรอรับ message แต่ครั้งเดียว เมื่อมี message ส่งมาแล้วก็จะหยุด แต่ถ้าเราต้องการให้ process รอรับ message อีกรอบ ก็ให้เรียกซ้ำฟังก์ชันอีกครั้งแบบนี้

-module(chat).
-export([alert/0]).

alert () ->
        receive
                Any ->
                        io:format("Alert : ~w~n",[Any])
        end,
        alert().

P08 (**) Eliminate consecutive duplicates of list elements.

If a list contains repeated elements they should be replaced with a single copy of the element. The order of the elements should not be changed.

Example:
* (compress ‘(a a a a b c c a a d e e e e))
(A B C A D E)

จากโจทย์คือเขียนฟังก์ชัน compress เปลี่ยนลิสต์ที่มีสมาชิกที่ซ้ำๆกัน และอยู่ติดกัน ให้เหลือเพียงแค่ตัวเดียว ข้อนี้ไม่ยาก เงื่อนไขมี 3 แบบ คือ เมื่อ ลิสต์มีสมาชิกแค่ตัวเดียวให้ ส่งค่านั้นเป็นผลลัพธ์ ถ้าเป็นกรณีอื่นให้เอาสมาชิกตัวที่หนึ่งกับสอง มาเทียบกัน ถ้าเท่ากัน เราจะเรียกซ้ำฟังก์ชัน แต่ตัดสมาชิกตัวแรกสุดออก ถ้าสมาชิกตัวที่หนึ่งกับสองไม่เท่ากัน เราจะเอาสมาชิกตัวที่หนึ่งมาต่อกับผลลัพธ์ที่ได้จากการเรียกซ้ำโดยตัดสมาชิกตัวแรกออก

Haskell

compress::(Eq a) =>[a]->[a]

compress [x] = [x]
compress (x:y:xs)
                | x == y = compress (y:xs)
                | otherwise = x:compress(y:xs)

Erlang

-module(compress).
-export([compress/1]).

compress ([L|[]]) -> [L|[]];
compress ([L|[M|T]]) when (L == M) -> compress ([M|T]);
compress ([L|T]) -> [L | compress (T)].

Lisp

(defun compress (L)
        (if (eql (second L) nil)
                L
                (if (eql (first L) (second L))
                        (compress (rest L))
                        (cons (first L) (compress (rest L)))
                )
        )
)