เมื่อมีการบ้านให้คะแนนแล้ว ผมก็อยากจะให้ทำการบ้านกันจริงๆ (อย่างน้อยก็ควรจะได้สัมผัสและฝึกฝนด้วยตนเอง) เลยจะต้องหาทางตรวจว่าลอกการบ้านกันบ้างหรือเปล่า แต่การบ้านแรกคำถามจะค่อนข้างง่ายมาก ไม่สามารถพลิกแพลงหรือเขียนโปรแกรมแบบที่แตกต่างกันมากนัก (ส่วนใหญ่จะฝึกการเขียน expression ตามสูตรที่กำหนดให้) ก็เลยตรวจการลอกข้อสอบแบบง่ายๆ ก่อน (การบ้านครั้งต่อไปค่อยขยับขยายความซับซ้อนในการตรวจจับให้เพิ่มขึ้น) คือ ตรวจแค่ว่าส่งไฟล์เดียวกันมาหรือเปล่า ในที่นี้แปลว่าเอาไฟล์มาจากเพื่อนแล้วก็ upload ส่งมาให้เลยโดยไม่แตะต้องใดๆ ทั้งสิ้น

เมื่อจะตรวจแบบพื้นๆ ผมก็แค่ใช้ hash function มาสร้าง message digest จากไฟล์ที่นักศึกษาส่งมา ถ้าไฟล์ไหนมี message digest เหมือนกัน ก็แปลว่าลอกกันมาทั้งไฟล์ จะไปได้หักคะแนนถูก การหาค่า message digest ของไฟล์การบ้านทั้งหมด ก็ใช้คำสั่ง find ของ unix

$ cd assignment1
$ find . -name "*" -not -type d -exec shasum '{}' \; | sort > digest_list.txt

คำสั่ง find ใช้หาชื่อไฟล์ตามเงื่อนไขที่กำหนด ในที่นี้คือเอาทุกไฟล์ ยกเว้นไดเรคทอรี เมื่อได้ไฟล์แล้ว เราก็สามารถสั่งให้รันโปรแกรม shasum โดย ‘{}’ จะถูกแทนด้วยชื่อไฟล์ที่ค้นเจอแต่ละไฟล์ จากนั้นก็เอาไปเรียงลำดับเพื่อให้ไฟล์ที่มี digest เหมือนกันอยู่ติดกัน เก็บลงไฟล์​ digest_list.txt ที่เหลือก็แค่เขียนโปรแกรมจับกลุ่มว่าไฟล์ที่เหมือนกันมีใครบ้าง จัดเป็นกลุ่มก็เรียบร้อย

จากนั้นก็เลยลองเขียนโปรแกรมแบบมั่วๆ (เพราะยังงงกับ syntax อยู่) เพื่อแก้ปัญหา N-Queens แบบง่ายๆ (ใช้ backtracking search ด้วย recursive ดื้อๆ เอานี่แหละ) โดยใช้ Go:

package main
 
import "fmt"
 
var N int = 10
 
func nqueens(board []int, filled int) int {
	var attack bool = false;
	if filled == N-1 {
		for i:=0; i<N; i++ {
			fmt.Printf("%d\t", board[i])
		}
		fmt.Printf("\n");
		return 1
	}
	filled += 1;
	for i:=0; i<N; i++ {
		board[filled] = i;
		attack = false;
		for j:=0; j<filled; j++ {
			dy := board[j]-board[filled];
			dx := j - filled;
			if (board[j] == board[filled]) || 
			(dy/dx == 1 || dy/dx == -1) && (dy%dx == 0) {
				attack = true;
				break
			}
		}		
		if !attack {
			nqueens(board, filled)
		}	
	}
	return 0
}
 
func main() {
	var board []int = make([]int, N);
	nqueens(board, -1);
}

ด้วยความอยากรู้ ก็เลยลองเอาโปรแกรมนี้เอามาแปลงเป็นภาษา C แบบตรงๆ บรรทัดต่อบรรทัด

#include<stdio.h>
#include<stdlib.h>
 
const int N=10;
 
int nqueens(int *board, int filled) {
	int i,j,attack,dy,dx;
	if (filled == N-1) {
		for(i=0; i<N; i++)
			printf("%d\t", board[i]);
		printf("\n");
		return 1;
	}
	filled++;
	for(i=0; i<N; i++) {
		board[filled] = i;
		attack = 0;
		for(j=0; j<filled; j++) {
			dy = board[j]-board[filled];
			dx = j - filled;
			if ((board[j] == board[filled]) ||
			((dy/dx == 1 || dy/dx == -1) && (dy%dx == 0))){
				attack = 1;
				break;
			}
		}
		if (!attack)
			nqueens(board, filled);
	}
	return 0;
}
 
main() {
	int *board = (int *)malloc(sizeof(int)*N);
	nqueens(board, -1);
}

เสร็จแล้วก็ลองเขียน Python อีกโปรแกรมหนึ่ง

def nqueens(board, filled):
	global N
	if filled == N-1:
		for i in board:
			print "%d\t" % board[i],
		print
		return True
	filled+=1
	for i in xrange(0, N):
		board[filled] = i
		attack = False
		for j in xrange(0, filled):
			dy = board[j]-board[filled]
			dx = j - filled
			if board[j] == board[filled] or ((dy/dx == 1 or dy/dx == -1) and dy%dx==0):
				attack = True
				break
		if not attack:
			nqueens(board, filled)
	return 0
N=10
board = [0]*N
nqueens(board, -1)

ทดลองรัน (ด้วย N=10) แล้วจับเวลาง่ายๆ ด้วย time ก็จะได้ผลเป็น

ประสิทธิภาพแบบคร่าวๆ ก็ถือว่าใช้ได้ทีเดียว ไม่ได้แย่กว่า C นัก แต่ไม่รู้ว่าผมชินกับภาษา C มากเกินไปหรือเปล่า ทำให้ผมรู้สึกแปลกๆ งงๆ กับ syntax ของ Go มันดูไม่ค่อยสวยงามยังไงไม่รู้ บอกไม่ถูก เหมือนแค่เอา C มาตัดบางส่วนออก เพราะกลัวจะพิมพ์เยอะเกินไป มันเลยดูขัดๆ อีกอย่าง Go ก็ไม่ได้เขียนสั้นๆ ง่ายๆ ได้เหมือน Python ผมว่าโครงสร้าง syntax ของ C กับ Python สวยงามกว่าเยอะ แต่ผมก็ยังไม่ลอง concurrent programming ที่เป็นจุดขายของ Go เหมือนกัน เอาไว้หนีงานมาลองใหม่คราวหน้าละกัน

若い時にプログラムを書こう、必ず人生の豊かさにつながる
– 山下徹　NTTデータ社長

แปลเป็นไทยได้ความว่า

เขียนโปรแกรมกันไปเถอะในช่วงที่อายุยังน้อย, สิ่งเหล่านี้จะเชื่อมโยงกับความรุ่มรวยในชีวิตอย่างแน่นอน
– โทรุ ยะมะชิตะ ประธานบริษัทเอ็นทีทีดาต้า

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

จริงอยู่ว่าเด็กส่วนใหญ่จะพอเขียนโปรแกรมได้ อาจจะใช้วิธีตัดแปะเอาบ้าง หาทางเอาตัวรอดกันไปได้ แต่ส่วนใหญ่มักจะรู้สึกว่าการเขียนโปรแกรมเป็นเรื่องยาก เป็นเรื่องน่าเบื่อ เป็นงานคนชั้นล่าง (เหมือนผู้ใช้แรงงานในสังคมไอที) โดยเฉพาะค่านิยมอันหลังนี้ เป็นสิ่งที่ผมไม่เห็นด้วยที่สุด เพราะผมเชื่อว่าเราไม่สามารถเป็น system analyst เป็น project manager ที่ดี หรือเป็นตำแหน่งต่างๆ ที่บางบริษัทบอกว่าเป็นเหมือนยอดปิระมิดได้ โดยไม่มีพื้นฐาน ทักษะการเขียนโปรแกรม หรือไม่รู้ว่าถ้าออกแบบไปอย่างนี้แล้วคนที่เอาไป implement เขาจะทำยังไง

ผมตั้งใจว่าต่อไปนี้ผมพยายามลบค่านิยมนี้ออกจากเด็กๆ ที่เข้ามาเรียนในภาค แม้ว่ามันจะเป็นเรื่องยาก เพราะแนวความคิดว่างานบริหารจัดการเป็นงานสบายเป็นเรื่องที่ฝังรากลึกไปแล้ว รวมถึงการเสนอทางเลือกที่ดูเหมือนดีกว่า ว่าการเรียนวิธีการบริหารจัดการโดยตรงก็สามารถเข้าใจวิธีการ และเทคนิคต่างๆ ได้ สามารถเริ่มงานโดยเป็นผู้บริหารได้เลย ไม่จำเป็นต้องทำงานต๊อกต๋อยเหมือนพวกที่เรียนเขียนโปรแกรม เขาทำแค่ออกแบบ เสนอแนวความคิด ที่เหลือก็ปล่อยให้ใครก็ไม่รู้ทำก็หมดเรื่อง

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

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

อ้างอิง: http://slashdot.jp/developers/09/06/05/066228.shtml

เรื่องของเรื่องก็คือผมต้องการส่งอีเมลไปยังคนหลายๆ คน โดยมีเนื้อหาที่แตกต่างกันเล็กน้อย ผมเลยเริ่มจากเปิด OpenOffice.org Spreadsheet ขึ้นมาเขียนข้อมูลต่างๆ ที่ต้องการแปะลงไปในจดหมาย แล้วเก็บเป็นไฟล์ CSV (Comma-Separated Value) ที่เป็นสำหรับเก็บข้อมูลแบบง่ายที่สุด แต่ละบรรทัดแทนข้อมูลแต่ละเรคอร์ด และใช้เครื่องหมาย “,” คั่นระหว่างข้อมูลแต่ละฟิลด์ จากนั้นก็เขียนสคริปต์ Python เพื่ออ่านข้อมูลจากไฟล์ CSV ที่ทำไว้ เอาไปแปะในเทมเพลตที่เตรียมไว้ โดย Python จะมีคลาสสำหรับอ่านเขียนไฟล์ CSV เป็นคลาสมาตรฐานอยู่แล้ว ก็เลยสามารถทำงานได้สะดวกมาก

วิธีใช้คลาส csv เพื่ออ่านข้อมูล จะทำอย่างนี้

import csv
data = csv.reader(open('myfile.csv'), delimiter=',', quotechar='"')
for row in data:
	print row[0]

csv.reader เป็นคลาสสำหรับจัดการอ่านข้อมูลแบบ CSV รับอาร์กิวเมนต์เป็นไฟล์ เครื่องหมายที่ใช้คั่นระหว่างฟิลด์ และเครื่องหมายที่ใช้เป็น quote ครอบข้อมูลแต่ละฟิลด์ เมื่อสร้างออพเจคต์ของ csv.reader ขึ้นมาแล้ว ก็สามารถวนรอบเพื่ออ่านไฟล์ขึ้นมาทีละเรคอร์ดได้เลย โดยข้อมูลที่อ่านขึ้นมาจะเก็บไว้ในรูปอาเรย์ อย่างกรณีนี้ row[0] ก็คือข้อมูลในฟิลด์แรกสุด

หลังจากนี้เราก็ต้องเตรียมเทมเพลต ซึ่งก็คือกำหนดตัวแปรสตริงเท่านั้นเอง เช่น

template = """
Dear {r[0]},
 
I would like to send you the following information:
 
{r[1]}
 
Best Regards,
Cholwich
"""

จะเห็นว่าสตริงนี้มีสัญลักษณ์พิเศษ ระบุข้อมูลที่เราต้องการจะเอาไปแทรก {r[0]} หมายถึงสมาชิกตัวแรกของตัวแปร r ที่ส่งมาเป็นพารามิเตอร์ อันนี้เป็นฟีเจอร์ String Formatting ของ Python อยู่แล้ว เมื่อกำหนดเทมเพลตเสร็จ สั่งให้ Python แทรกข้อมูลโดย

output = template.format(r=row)

จะได้ผลลัพธ์ที่ผสานข้อมูลเข้าไปแล้ว เป็นสตริงเก็บไว้ที่ตัวแปรชื่อ output จากนั้นผมก็สามารถเอาไปส่งเมล์ หรือเอาไปเขียนลงไฟล์เก็บไว้ได้ พอเอาทั้งหมดมารวมกันก็จะได้

import csv
 
template = """
Dear {r[0]},
 
I would like to send you the following information:
 
{r[1]}
 
Best Regards,
Cholwich.
"""
data = csv.reader(open('myfile.csv'), delimiter=',', quotechar='"')
 
for row in data:
	output = template.format(r=row)
	f = open(row[2], 'w')
	f.write(output)
	f.close()

สุดท้ายก็จะได้สคริปต์ง่ายๆ สำหรับทำ mail merge ที่ได้ output เป็นไฟล์แยกกัน โดยระบุชื่อไฟล์ไว้ที่ row[2]

อ้างอิง:

1. PEP 3103: Advanced String Formatting
2. Python csv — CSV File Reading and Writing

เพื่อเผื่อแผ่ให้ทุกคนถูกเรียกกันอย่างทั่วถึง เลยปรับการสุ่มนิดหน่อย โดยเก็บจำนวนครั้งที่นักศึกษาแต่ละคนถูกเรียกไว้ ถ้าโดนเรียกแล้วหนึ่งครั้ง ก็จะกำหนดโอกาสที่จะถูกสุ่มขึ้นมาอีกให้เป็น 1/2 ของเพื่อนที่ยังไม่เคยโดนเรียก ถ้าโดนสองครั้งก็จะลดไปอีกให้เหลือ 1/4 ของเพื่อนๆ คือให้เป็น 1/(2^n) เมื่อ n เป็นจำนวนครั้งที่ถูกเรียก เสร็จแล้วก็มานึกอีกว่าบางคนอาจจะโดนเรียกแล้วไม่อยู่ อย่ากระนั้นเลยจะต้องเก็บข้อมูลไว้หน่อยว่าคนนี้โดดเรียน เลยทำปุ่มให้กดได้ด้วยว่าโดดไปแล้วกี่ครั้ง (ไม่รู้เก็บไว้ทำไมเหมือนกัน)

สุดท้ายได้โปรแกรมออกมาหน้าตาแบบนี้

ถ้าใครสนใจลองโหลดไปเล่นได้ที่นี่ วิธีใช้ก็คือเตรียม text file ใส่ชื่อนักศึกษาบรรทัดละคน เขียน ID ก่อน แล้วค่อยตามด้วยชื่อ คั่นด้วย TAB อาจจะใส่จำนวนครั้งที่เรียกนักศึกษาไปแล้วด้วยก็ได้ คั่นด้วย TAB เหมือนกัน

ส่วนโค้ด ถ้าใครอยากได้ก็ขอมาล่ะกันครับ มันค่อนข้างเละเทะ ไม่อยากเผย อายครับ ถ้ามีเวลาบ้าอีก ก็อาจจะเพิ่มฟีเจอร์อื่นๆ ไปด้วย

def min(first, *rest) 
  min=first
  rest.each {|x| min=x if x<min}
  return min
end

method นี้จะหาค่าต่ำที่สุดของอาร์กิวเมนต์ทั้งหมดที่รับมา เช่น

>> min(4,2,1,5)
=> 1

โดย first เป็นพารามิเตอร์หลัก หมายความว่าจะต้องรับข้อมูลมาอย่างน้อยหนึ่งตัว ส่วน rest เป็นพารามิเตอร์สำหรับค่าอื่นๆ ที่เหลือ ในที่นี้เมื่ออ้างถึง rest จะเป็นอะเรย์เก็บค่าต่างๆ ที่ได้รับมา ดังนั้นจึงสามารถใช้ rest.each ในการอ้างถึงสมาชิกแต่ละตัว แล้วเปรียบเทียบหาค่าต่ำที่สุดได้

ลองดูฟีเจอร์นี้ของ Ruby แล้ว ก็รู้สึกว่าไม่ต่างจากรูปแบบลิสต์ [head|tail] ของ Prolog คือลิสต์ถูกแบ่งเป็นสองส่วน ได้แก่ ส่วนหัว กับส่วนที่เหลือ (ตรงนี้จะต่างจากภาษา C ที่ใช้วิธีกำหนดทั้งหมดไว้ในอะเรย์ แล้วระบุจำนวนอาร์กิวเมนต์มาให้) เลยอยากจะลองเขียน method reverse สำหรับสลับลำดับข้อมูลในลิสต์เรียงกลับจากลำดับเดิม โดยใช้วิธี recursive แบบ Prolog ดู

reverse([],[]).
reverse([H|T], R) :- reverse(T,TR), append(T,[H],R).

def reverse(first, *rest) 
  if rest.empty?
    return [first] 
  else 
    return reverse(*rest) << first
  end
end

ลองเทียบกันดูในแง่ความหมาย จะเห็นว่่าเหมือนกันเป๊ะๆ แถมยังใช้เครื่องหมายคล้ายๆ กันอีก จุดที่แตกต่างที่สุดก็เห็นจะอยู่ที่ลักษณะของ reverse ใน Ruby เป็นฟังก์ชันมีการส่งค่ากลับ ส่วน reverse ของ Prolog เป็น predicate แสดงความสัมพันธ์ระหว่าง list สองอัน

เป็นอันสิ้นสุดการทดลองของวันนี้แต่เพียงเท่านี้

พอดีช่วงนี้กำลังเขียน Ruby เพื่อจัดการข้อความภาษาไทย และพยายามออกแบบให้จัดการกับภาษาอื่นๆ ได้ด้วย ก็เลยต้องเก็บทุกอย่างไว้เป็น UTF-8 จะได้ไม่เสียเวลาแปลงข้อมูล เสร็จแล้วทีนี้จะต้องเข้าถึงตัวอักษรแต่ละตัวเพื่อคำนวณค่าอะไรบางอย่าง จะใช้ [] ก็ไม่ได้แล้ว เพราะจะได้ตัวอักษรไม่ตรงตัว สุดท้ายเลยต้องไปหา gem ที่ช่วยจัดการ UTF-8 มาลองใช้ด้วย เท่าที่ลองหาดูก็เจอ

• icu4r เป็น binding ที่ทำให้ Ruby ใช้ความสามารถของ ICU ได้ โดยสร้าง class ใหม่ชื่อ UString มาใช้โดยเฉพาะ ดูท่าทางจะใช้ได้ดี แต่ก็มีข้อเสียอยู่ที่ติดตั้งยาก ต้องลง ICU ไว้ในระบบก่อน สุดท้ายเลยเลิกไป
• utf8proc เป็น module อีกอันหนึ่ง ที่เพิ่มส่วนขยายให้คลาส String ซึ่งก็มีข้อจำกัดในฟังก์ชันการทำงาน แถมยังไม่ค่อยมีเอกสารเท่าไหร่
• character-encodings อันนี้ไปเจอทีหลังสุด ฟีเจอร์ต่างๆ ก็ดูดี ใช้งานไม่ยุ่งยาก (แต่อาจจะหาเอกสารยากเหมือนกัน) แต่คนเขียนพยายามบอกว่ามันคือส่วนหนึ่งที่อาจจะรวมเข้าไปใน Ruby 2.0 เลยเลือกใช้อันนี้

การใช้งานก็ไม่ยาก ลองดูตามตัวอย่างนี้ได้เลย

require 'rubygems'
require 'encoding/character/utf-8'
s = +"สวัสดีครับ"
a = Array.new
s.each_char {|c| a << c}

แค่นี้เราก็แยกตัวอักษรแต่ละตัวจาก s ไปไว้ในอะเรย์ a ได้เลย ตัวอักษรแต่ละตัวก็ยังเก็บในฐานะ String เหมือนเดิม ถ้ามองในแง่ความสะดวกแล้ว การทำแบบนี้ก็ง่ายดี แต่ดูแล้วมันต้องแปลงไปแปลงมาอยู่หลายรอบเหมือนกัน

I believe that computer programming is a practical skill, and I agree with Pólya that we “acquire any practical skill by imitation and practice.” Programmers who long to write beautiful code should therefore read beautiful programs and imitate the techniques they learn as they write their own programs.
- Jon Bentley, “The Most Beautiful Code I Never Wrote” in “Beautiful Code”

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

void qsort(void *base, size_t nmemb, size_t size, int(*compar)(const void *, const void *))

จาก function prototype จะเห็นว่าฟังก์ชันนี้ต้องการ argument 4 ตัว คือ

1. base เป็น pointer ที่ชี้ไปยังอะเรย์ที่ใช้เก็บข้อมูลทั้งหมด
2. nmemb ใช้ระบุจำนวนสมาชิกของอะเรย์ที่ต้องการเรียงลำดับ
3. size กำหนดขนาดของข้อมูลแต่ละชุด ซึ่งจำเป็นต้องใช้เวลาย้ายข้อมูลสลับตำแหน่งกัน
4. compar เป็น pointer ที่ชี้ไปยังฟังก์ชัน เพื่อเปรียบเทียบสมาชิกแต่ละตัวในอะเรย์ ฟังก์ชันนี้ควรจะให้ค่าน้อยกว่าศูนย์ เท่ากับศูนย์ และมากกว่าศูนย์ เช่นเดียวกับฟังก์ชัน strcmp

ตัวอย่าง ผมต้องการเรียงลำดับสตริง ซึ่งในภาษาซีจะใช้ char * ดังนั้นผมจึงสร้างตัวแปรแบบ char ** เพื่อเป็นอะเรย์สำหรับเก็บ pointer ที่ชี้ไปยังสตริงแต่ละตัว ส่วน nmemb ก็คือจำนวนสมาชิกของอะเรย์ กับ size ก็คือ sizeof(char) หาได้ไม่ยาก ปัญหาหลักอยู่ที่ฟังก์ชันสำหรับเปรียบเทียบข้อมูล ซึ่งจะเห็นว่าเรามีฟังก์ชัน strcmp สำหรับเปรียบเทียบสตริงอยู่แล้ว เพียงแต่ prototype อาจจะไม่เหมือนกัน เลยต้องทำฟังก์ชันขึ้นมาห่อไว้หน่อย

int compare(const void *a, const void *b) {
    const char **pa = (const char **)(a);
    const char **pb = (const char **)(b);
    return strcmp((*pa), (*pb));
}

อ้อ เวลาฟังก์ชัน qsort เรียก compar มาทำงาน จะเรียกโดยส่ง pointer ที่ชี้ไปยังสมาชิก 2 ตัวในอะเรย์ไปให้ ฉะนั้นจึงต้องมา cast ให้เป็น char ** ก่อน แล้วถึงจะไปเรียกใช้ strcmp ได้ ส่วนการเรียกฟังก์ชัน qsort ก็แค่

qsort(a, n, sizeof(char *), compare);

สุดท้ายที่อยากฝากไว้ก็คือ “don’t reinvent the wheel” เราควรจะใช้สิ่งที่มีอยู่แล้วให้เป็นประโยชน์ให้มากที่สุด โดยเฉพาะอย่างยิ่งฟังก์ชันมาตรฐานต่างๆ เพราะฟังก์ชันเหล่านี้ได้รับการพัฒนามายาวนาน ผ่านร้อนผ่านหนาวมาเยอะ น่าจะทำงานได้ดีกว่าการเขียนฟังก์ชันขึ้นมาใช้งานเอง แต่ทั้งนี้ไม่ได้บอกว่าไม่ควรทำเองนะ เพียงแต่พยายามปรับใช้สิ่งต่างๆ ที่มีอยู่ให้ดี เพื่อจะได้มีเวลาไปทำให้สิ่งใหม่ๆ

อ้างอิง: man qsort

ทีนี้พอทำส่วนประกอบต่างๆ เสร็จ ก็อยากจะทำเท่ห์โดยให้ pdflatex ทำงานแบบพื้นหลัง แล้วค่อยใช้ Ajax มาคอยเช็คดูว่าสร้าง pdf เสร็จหรือยัง ก็จำเป็นต้องสร้าง process ใหม่ขึ้นมาเพื่อเรียก pdflatex มาทำงาน ลองค้นดูก็พบว่า php มีกลุ่มคำสั่ง pcntl (Process Control) สำหรับควบคุม process ต่างๆ ซึ่งในนั่นจะมีคำสั่ง pcntl_fork() เอาไว้สร้าง process ลูก และ pcntl_exec(…) สำหรับกำหนดให้เรียกโปรแกรมมาทำงาน

พอใช้ก็โดนเตือนว่าไม่รู้จักคำสั่งพวกนี้ ลองหาไปหามา ก็มีคนบอกว่าต้อง enable pcntl ก่อน ใน ubuntu ไม่ได้ทำมาให้ สุดท้ายก็เลยไปพยายามสร้าง .deb ขึ้นมาใหม่เพื่อการนี้ แต่ก็ยังใช้ไม่ได้ ลองค้นดูอีกเจอว่า คำสั่งพวกนี้จะใช้ได้เฉพาะเวลาใช้ php แบบ CGI เท่านั้น ไม่สามารถใช้ได้เวลาทำงานเป็น module หนึ่งของ Apache (คิดว่าคงเพราะทำงานเป็นส่วนหนึ่งของ process ของ Apache ถ้ายอมให้ทำได้ ก็อาจจะเกิดปัญหาต่างๆ ได้ ต่างจากแบบ CGI ที่ทำงานอยู่บน process ของ php เอง)

สุดท้ายก็เลยเปลี่ยนใจไม่ใช้แล้ว เพราะดูท่าทางจะยุ่งยาก แล้ว pdflatex มันก็ไม่ได้ทำงานนานเท่าไหร่ เนื่องจากไฟล์ค่อนข้างเล็ก