roofimon

Erlang Complex Data Structures

ในเอิร์ลแลง(Erlang)โครงสร้างข้อมูลที่ซับซ้อนหมายถึงการนำโครงส้างข้อมูลแบบพื้นฐาน ไม่ว่าจะเป็นอะตอม ลิสท์ ทัปเปิล และอื่นๆมาประกอบรวมกันเพื่อจำลองข้อมูลที่ซับซ้อนบางอย่าง เช่นเราต้องการสร้าง
person ให้เป็นโครงสร้างที่ซับซ้อนที่ประกอบไปด้วย ชื่อ นามสกุล สัตว์เลี้ยง ความชื่นชอบ หรือ อื่นๆ จะได้ออกมาประมาณนี้
[{person,"Joe","Armstrong",
    [ {shoeSize,42},
        {pets,[{cat,zorro},{cat,daisy}]},
        {children,[{thomas,21},{claire,17}]}]},
 {person,"Mike","Williams",
    [ {shoeSize,41},
        {likes,[boats,wine]}]}
]

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

1> JoeAttributeList = [{shoeSize,42}, {pets,[{cat, zorro},{cat,daisy}]},
1> {children,[{thomas,21},{claire,17}]}].
        [{shoeSize,42},
            {pets,[{cat,zorro},{cat,daisy}]},
            {children,[{thomas,21},{claire,17}]}]
2> JoeTuple = {person,"Joe","Armstrong",JoeAttributeList}.
        {person,"Joe","Armstrong",
            [{shoeSize,42},
                {pets,[{cat,zorro},{cat,daisy}]},
                {children,[{thomas,21},{claire,17}]}]}
3> MikeAttributeList = [{shoeSize,41},{likes,[boats,wine]}].
        [{shoeSize,41},{likes,[boats,wine]}]
4> MikeTuple = {person,"Mike","Williams",MikeAttributeList}.
        {person,"Mike","Williams",
            [{shoeSize,41},{likes,[boats,wine]}]}
5> People = [JoeTuple,MikeTuple].
        [{person,"Joe","Armstrong",
            [{shoeSize,42},
                {pets,[{cat,zorro},{cat,daisy}]},
                {children,[{thomas,21},{claire,17}]}]},
         {person,"Mike","Williams",
            [{shoeSize,41},{likes,[boats,wine]}]}]

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

Erlang Pattern Matching
การเปรียบเทียบรูปแบบ(Pattern Matching)ในเอิร์ลแลงใช้สำหรับงานเช่น

edit @ 15 Dec 2009 11:02:03 by cyber-climber

edit @ 15 Dec 2009 11:05:36 by cyber-climber

edit @ 15 Dec 2009 11:06:08 by cyber-climber

Erlang Lists

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

[january, february, march]
[123, def, abc]
[a,[b,[c,d,e],f], g]
[]
[{person, 'Joe', 'Armstrong'}, {person, 'Robert', 'Virding'},
{person, 'Mike', 'Williams'}]
[72,101,108,108,111,32,87,111,114,108,100]
[$H,$e,$l,$l,$o,$ ,$W,$o,$r,$l,$d]
"Hello World"

ต่อไปเรามาดูคุณสมบัติของลิสท์เบื้องต้น [a,[b,[c,d,e],f], g] ลิสท์ตัวนี้จะมีขนาดความยาวเท่ากับ 3 โดยที่อิลิเมนท์ตัวแรกเป็นอะตอม a ตัวที่สองเป็นลิสท์ [b, [c,d,e],f] และตัวที่สามคืออะตอม g
ลิสท์ว่างเราสามารถถูกสร้างได้ด้วย [], นอกจากนี้เรายังสร้างลิสท์ของแทกทัปเปิลได้ [{person, 'Joe', 'Armstrong'}, {person, 'Robert',
'Virding'}, {person, 'Mike', 'Williams'}]

Erlang Characters and Strings
สำหรับเอิร์ลแลงแล้วมันเองเป็นภาษาที่ไม่มีข้อมูลประเภทสตริง ตัวอักษรในเอิร์ลแลงที่ถูกนำเสนอออกมานั้นเบื่องหลังมันคือตัวเลข และการนำค่าตัวเลขที่ใช้แทนตัวอักษรใดๆสามารถทำได้ด้วยการใส่เครื่องหมาย $ ไว้ที่หน้าตัวอีกษรนั้นๆเช่น
1> $A.
65
2> $A + 32.
97
3> $a.
97
ดังนั้นเราจะพบว่าในเอิร์ลแลงจะไม่มีการใช้ข้อมูลที่เป็นประเภทสตริง เพราะจริงๆแล้วสตริงคือลิสท์
ของ ASCII ที่ถูกแสดงผลภายใต้เครื่องหมาย '...' ดังนั้นถ้าเราเขียนสตริง "Hello World" นั่นหมายความว่า
เรากำลังสร้างลิสท์ที่มีค่า [72,101,108,108,111,32,87,111,114,108,100]
4> [65,66,67].
"ABC"
5> [67,$A+32,$A+51].
"Cat"
6> [72,101,108,108,111,32,87,111,114,108,100].
"Hello World"
7> [$H,$e,$l,$l,$o,$ ,$W,$o,$r,$l,$d].
"Hello World"

Erlang Atoms and Strings
หลายคนอาจเริ่มสงสัยว่าแล้วอะตอมกับสตริงต่างกันอย่างไร อย่างแรกเลยคือข้อมูลทั้งสองอย่างถูกโพรเซสต่างกัน
สำหรับอะตอมสิ่งที่เราสามารถทำได้กับมันคือการเปรียบเทียบ ในทางกลับกันสำหรับสตริงแล้วเราสามารถทำงานกับมันได้หลาย
รูปแบบมาก เช่นสตริง "Hello World" นั้นสามารถแยกมันออกเป็นส่วน เช่น ["Hello", "World"]

อีกข้อแตกต่างระหว่างสตริงกับอะตอมคือเรื่องประสิทธิภาพการทำงาน เนื่องจากสตริงจะใช้พื้นที่ในการเก็บมากกว่าอะตอมทำให้ทุกๆการทำงานที่เกิดขึ้นกับสตริงจะกินเวลานานกว่าอะตอม ยกตัวอย่างเช่นถ้าเราต้องการเปรียบเทียบสตริงสองตัว(ลิสท์สองตัว)เราต้องเปรียบเทียบตัวอักษรครั้งละตัวไปจนหมด ในขณะที่ถ้าเราต้องการเปรียบเทียบอะตอมแล้วระบบจะทำการเปรียบเทียบอะตอมด้วยตัวบ่งชี้ภายใน(internal identifier) ด้วยคำสั่งเพียงคำสั่งเดียว

Erlang Building and Processing Lists
เราได้รู้จากหัวข้อก่อนหน้านี้แล้วว่าสิ่งที่ทำให้ลิสท์กับทัปเปิลแตกต่างกันก็คือการโพรเซสนั้นเองโดยที่ทัปเปิลนั้นเราสามารถทำได้เพียงดึงเอาอิลิเมนท์จากตำแหน่งที่เราต้องการออกมาเท่านั้น  ในขณะที่ลิสท์นั้นเราจะแบ่งข้อมูลในลิสท์ออกเป็นสองชุดคือหัวกับหาง โดยที่หัวคืออิลิเมนท์ตัวแรกในลิสท์และส่วนที่เหลือจะหลายเป็นหาง โดยที่เราสามารถแตกอิลิเมนท์ออกไปได้เรื่อยๆจนกว่าลิสท์นั้นจะว่าง ดังนั้นถ้าเรามีลิสท์ [1,2,3] เราจะได้หัวที่มีค่าเป็น 1 และหางเป็น [2,3] เมื่อเราเรียนรู้เกี่ยวกับเอิร์ลแลงเราจำเป็นต้องรู้การประกาศลิสท์แบบรีเคอร์สีฟเพราะถ้าเราไม่เข้าใจตั้งแต่แรกมันจะทำให้เรา งง เป็นอย่างมากดังนั้นให้ดูการประกาศลิสท์ทั้งหมดด้านล่าง ว่าผลที่ได้ออกมามีค่าเท่ากันหมด

[one, two, three, four]
[one, two, three, four|[]]
[one, two|[three, four]]
[one, two|[three|[four|[]]]]
[one|[two|[three|[four|[]]]]]

ข้อควรระวังคือเราต้องมีอิลิเมนท์ที่ฝั่งซ้ายมือของเครื่องหมาย cons และลิสท์ทางขวามือที่อยู่ในวงเล็บปีกแข็งเดียวกัน ด้วยการใช้
ข้อกำหนดนี้เราสามารถสร้างลิสท์ที่อยู่ในลักษณะที่ถูกต้องได้(ไม่ใช่ข้อกำหนดแต่ควรทำ)อย่างไรก็ตามลิสท์ในเอิร์ลแลงก็ไม่จำเป็นจะต้องเป็นจะต้องเป็นไปตามข้อกำหนดข้างต้นที่ อิลิเมนท์ด้านขวามือจะต้องเป็นลิสท์ก็ได้ยกตัวอย่างเช่นให้ลองพิมพ์  [[1, 2]|3] ลงไปในเชลแล้วดูผลที่ได้ก็คือลิสท์ที่เป็นแบบไม่ถูกลักษณะนั่นเอง ลิสท์ในลักษณะนี้เหมาะสำหรับงานประเภทเร่งรีบและรีบเร่งซึ่งเราจะกล่าวถึงเรื่องนี้ในภายหลัง  แต่อย่างไรก็ตามเราควรหลีกเลี่ยงการใช้ลิสท์ในลักษณะที่ผิดเนื่องจากถ้าเราใช้งานมันเยอะเข้า เราอาจจะแยกไม่ออกว่า เราตั้งใจจะใช้มันหรือมันเกิดจากความผิดพลาดของโปรแกรม เช่น ถ้าเราพิมพ์ [2|3] แทนที่ [2|[3]], โปรแกรมของเราสามารถถูกคอมไพล์ได้อย่างไม่มีปัญหาแต่อย่างไรก็ตามโปรแกรมส่วนนี้จะเกิดปัญหาในกรณีที่เราพยายามจะทำงานกับส่วนหางของลิสท์โดยที่เราคิดว่ามันเป็นลิสท์อย่างที่มันควรจะเป็นโดยที่แท้จริงแล้วมันเป็นอะตอม

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

ลิสท์เองก็เตรียมโอเปอร์เรชั่นหลายๆอย่างมาให้เราใช้งานได้เลยดังตัวอย่าง โดยที่โอเปอร์เรชั่นเหล่านี้ไม่ใช้ BIFs ดังนั้นการเรียกใช้งานจำเป็นต้องใช้เครื่องหมาย : คั่น
1> lists:max([1,2,3]).
3
2> lists:reverse([1,2,3]).
[3,2,1]
3> lists:sort([2,1,3]).
[1,2,3]
4> lists:split(2,[3,4,10,7,9]).
{[3,4],[10,7,9]}
5> lists:sum([3,4,10,7,9]).
33
6> lists:zip([1,2,3],[5,6,7]).
[{1,5},{2,6},{3,7}]
7> lists:delete(2,[1,2,3,2,4,2]).
[1,3,2,4,2]
8> lists:last([1,2,3]).
3
9> lists:member(5,[1,24]).
false
10> lists:member(24,[1,24]).
true
11> lists:nth(2,[3,4,10,7,9]).
4
12> lists:length([1,2,3]).
** exception error: undefined function lists:length/1
13> length([1,2,3]).
3
แต่อย่างที่บอกว่าโอเปอร์เรชั่นเหล่านี้ไม่ใช่ BIFs ยกเว้น length
เครื่องหมาย ++ และ--, มีไว้สำหรับรวมลิสท์และแตกลิสท์ออกดังตัวอย่าง
1> [monday, tuesday, Wednesday].
[monday,tuesday,wednesday]
2>
2> [1|[2|[3|[]]]].
[1,2,3]
3> [a, mixed, "list", {with, 4}, 'data types'].
[a,mixed,"list",{with,4},'data types']
4> [1,2,3] ++ [4,5,6].
[1,2,3,4,5,6]
5> [1,2,2,3,4,4] -- [2,4].
[1,2,3,4]
6> "A long string I have split "
6> "across several lines.".
"A long string I have split across several lines."
เครื่องหมาย ++ มีไว้เพื่อรวมลิสท์สองตัวเข้าด้วยกันเป็นลิสท์ตัวใหม่เช่น [1,2]++[3,4] จะได้ [1,2,3,4]
ส่วนเครื่องหมาย -- มีไว่สำหรับแยกอิลิเมนท์ที่เรากำหนดไว้ที่ด้านขวามือ ออกมาจากลิสท์ทางซ้ายมือ
ดังนั้น [1,1] -- [1] จะได้[1], ส่วน[1,2,3,4] -- [1,4] จะได้[2,3]. แต่ถ้าเราใช้ [1,2] -- [1,1,3], ผลจะออกมาเป็น [2]. ถ้าอิลิเมนท์ทางขวามือไม่มีในด้านซ้ายมันจะถูกมองข้ามไป
ทั้ง ++ และ-- จะทำงานแบบอิงด้านขวาเป็นหลัก(right-associative),

7> [1,2,3]--[1,3]--[1,2].
[1,2]
8> ([1,2,3]--[1,3])--[1,2].
[]

สุดท้ายถ้าเราพิมพ์ "Hello " "Concurrent " "World" เราจะได้ "HelloConcurrentWorld".
อย่างไรก็ตามเราสามารถเพิ่มอิลิเมนท์เข้าไปในลิสท์ได้สองวิธีคือ
• ใช้ cons ตรงๆ [1|[2,3,4]].
• หรือใช้ ++ แทน [1] ++ [2,3,4].
การทำงานทั้งสองแบบให้ผลเหมือนกันแต่ ++ จะทำงานได้ช้ากว่าดังนั้นในกรณีที่เราต้องการเพิ่มอิลิเมนท์เข้าไปที่
หัวของลิสท์ใช้ cons จะทำได้เร็วกว่า

 

edit @ 9 Dec 2009 16:54:57 by cyber-climber

edit @ 15 Dec 2009 11:07:04 by cyber-climber

The Erlang Shell
ต่อไปเราจะเริ่มเปิดเชลของเอิร์ลแลงขึ้นมาเพื่อลองให้งาน โดยในยูนิกส์ให้พิมพ์คำสั่ง "erl" ลงไปมื่อเราสามารถเปิดเชลขึ้นมาแล้ว เราจะเห็นเป็น ( เลขบรรทัด> ) จากนั้นให้ลองพิมพ์ตัวเลขอะไรลงปสักอย่างเพื่อดูผลที่ได้ออกมา (อย่าลืมใส่ . เพื่อแสดงการจบคำสั่ง)
1> −234.
-234
2> 2#1010.
10
3> $A.
65

ในกรณีที่เราไม่ได้ใส่เครื่องหมาย . เข้าไปข้างหลังคำสั่งเอิร์ลแลงจะไม่รู้ว่ามันคือคำสั่งนั่นแปลว่ามันจะเก็บสิ่งที่เราพิมพ์เข้าไปเรื่อยๆจนกว่าเราจะพิมพ์ . เข้าไปนั่นเอง
4> 5-
4>
4> 4.
1
เครื่องหมาย 1>, 2> นั้นคือคอมมานด์พรอมป์ที่แสดงให้เห็นว่าเอิร์ลแลงเชลนั้นพร้อมรับคำสั่งที่เราจะป้อนเข้าไป จากพรอมป์เมื่อเราใส่ตัวเลขและจบด้วยเครื่องหมาย . และกดเอ็นเทอร์ เอิร์ลแลงะรับตำสั่งและทำการแปรออกมาเป็นเลขฐานสิบ แต่ถ้าเกิดข้อผิดพราดเราจะได้เมสเสจออกมาดังนี้
4> 5-.
* 1: syntax error before: '.'
5> q().
ในกรณีที่เราต้องการออกจากโปรแกรมก็สามารถทำได้ด้วยการพิมพ์ q().

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

#define OP_READ 1
#define OP_WRITE 2
#define OP_SEEK 3
...
#define RET_SUCCESS 223
...
ซึ่งเมื่อเรานำมันมาใช้งานในโปรแกรมหลักผลที่ได้ออกมาจะมีลักษณะนี้
int ret;
ret = file_operation(OP_READ, buff);
if( ret == RET_SUCCESS ) { ... }

ซึ่งโปรแกรมที่เขียนด้วยเอิร์ลแลงนั้นจะออกมาเป็น

Ret = file_operation(op_read, Buff),
if
Ret == ret_success ->
...

การประกาศอะตอมนั้นจะใช้ตัวอักษรตัวเล็กและตามมาด้วยชุดของตัวอักษรตามที่เราต้องการหรือจะเป็น _ หรือt @) เช่น red,ecember, cat, meters, yards, joe@somehost, และa_long_name.นอกจากนี้อะตอมยังสามรถถูกครอบด้วยเครื่องหมาย ' ได้อีกด้วยเนื่องจากในบางกรณีเราต้องการประกาศใช้งานอะตอมที่ขึ้นต้นด้วยตัวหนังสือตัวใหญ่รืออะตอมที่มีตัวอักษรพิเศษเช่น: ’Monday’, ’Tuesday’, ’+’, ’*’,
’an atom with spaces’. ดังนั้นเราจะเห็นว่าค่าของอะตอมใดๆก็คือตัวอะตอมนั่นเอง ดังนั้นเมื่อเราพิมพ์อะตอมลงไปในเชลสิ่งที่เราได้กลับมาคือค่าของอะตอมนั่นเอง
1> hello.
hello
เรื่องนี้ถือเป็นเรื่องค่อนข้างแปลกสำหรับคนที่เคยเขียนภาษาอื่นมาเมื่อเราพูดถึงเรื่องของค่าของอะตอมหรือค่าของอินทิเจอร์ แต่เนื่องจากเอิร์ลแลงเป็นภาษาเชิงฟังก์ชั่นนอล ทำให้ทุกๆคำสั่งหรือการแสดงออก(expression)จำเป็นต้องมีค่า เสมอ

Tuples
ทัปเปิลคือกลุ่มของข้อมูลของเอิร์ลแลง(ต่างชนิดกัน)ที่ถูกเก็บไว้ในรูปแบบของคอลลเล็คชั่นของไอเท็ม ทัปเปิลใช้เครื่องหมายวงเล็บปีกกาเป็นตัวกำหนด, {...}, และแต่ละอิลิเมนท์ของมันจะถูกแบ่งโดยเครื่องหมายลูกน้ำ(commas).
{123, bcd} {123, def, abc} {abc, {def, 123}, ghi} {}
{person, 'Joe', 'Armstrong'} {person, 'Mike', 'Williams'}
ทัปเปิล {123,bcd} ประกอบด้วยสองอิลิเมนท์คือ อิลิเมนท์ที่เป็นอินทิเจอร์ 123 และอิลิเมนท์ที่เป็นอะตอม bcd อีกตัวอย่างของทัปเปอร์
{abc, {def, 123}, ghi} มีสามอิลิเมนท์คือทัปเปิล {def, 123} อีกสองอิลิเมนท์เป็นอะตอมคือ abc และ ghi ส่วน {} แปลว่าทัปเปิลว่างที่ไม่มีสมาชิก ส่วนทัปเปิลที่มีเพียงอิลิเมนท์เดียวเราก็สามารถสร้างได้เช่น {123} แต่ออกจะดูแปลกที่เราจะสร้างของแบบนี้ไว้เพราะเราสามารถเก็บมันไว้บน อันทัปเปิล(untupple) ได้สำหรับทัปเปิลที่มีสมาชิกตัวแรกเป็นอะตอม เราจะเรียกสมาชิกตัวนั้นว่าแทก(TAG) โดยการใช้แทกนี้เป็นข้อตกลงพิเศษทของเอิร์ลแลงที่เราควรรู้ไว้เพราะมันถูกใช้เยอะมาก โดยมากจะใช้เพื่อบอกประเภทของข้อมูลที่เก็บในทัปเปิลเช่น
{person, 'Joe', 'Armstrong'}, อะตอม person จะบอกว่าทัปเปิลนี้ใช้เก็บข้อมูลบุคคลดังนั้นอิลิเมนท์ที่สองของทัปเปิลนี้ควรจะเป็นชื่อ ส่วนอิลิเมนท์  สองก็เป็นนามสกุล สำหรับการใช้แทกนั้นมีเพื่อใช้เพื่อระบุความแต่กต่างของทัปเปิลที่ถูกใช้สำหรับจุดประสงค์ที่ต่างกันในบริเวณต่างๆของโค้ดเรายกตัวอย่างเช่นเราสามารถหาต้นตอของปัญหาที่เกิดขึ้นได้เมื่อมีการส่งทัปเปิลผิดตัวเข้าไปหรือออกมาจากฟังก์ชั่นที่เราเรียกไป
ซึ่งการใช้แทกถือเป็นข้อปฏิบัติที่ดีในการเขียนโปรแกรมด้วยเอิร์ลแลงนอกจากนี้ทัปเปิลยังมีฟังก์ชั่นแบบบิวด์อินมาให้ใช้งานอีกด้วยเช่น

1> tuple_size({abc, {def, 123}, ghi}).
3
2> element(2,{abc, {def, 123}, ghi}).
{def,123}
3> setelement(2,{abc, {def, 123}, ghi},def).
{abc,def,ghi}
4> {1,2}<{1,3}.
true
5> {2,3}<{2,3}.
false
6> {1,2}=={2,3}.
false
คำสั่งที่สองในตัวอย่างที่เราต้องการหาอิลิเมนท์ที่สองแสดงให้เห็นว่าลำดับในทัปเปิลเริ่มด้วยเลข 1 ไม่ใช่ 0
คำสั่งที่สามเป็นการเปลี่ยนค่าอิลิเมนท์ที่สองในทัปเปิล โดยที่ผลที่ได้จะเป็นทัปเปิลใหม่ที่มีค่าตามที่เราต้องการ
โดยที่ทัปเปิลเดิมนั้นค่าก็ยังไม่มีการเปลี่ยนแปลง

edit @ 3 Dec 2009 15:01:02 by cyber-climber

ไม่ได้เขียน blog ที่นี่นานมากอยากเขียนเรื่องเอิร์ลแลงเก็บไว้อ่านเองไม่รู้จะไปเขียนที่ไหนก็เลยนึกถึงที่นี่ก่อน แต่!!!ไม่ได้เข้ามานาน แน่นอนลืมรหัสผ่านพยายามมั่วอยู่หนึ่งคืนก็ทนไม่ได้ ต้องกดสูตรลับ ผมก็ได้รหัสใหม่มาภายในสิบนาที

 ทำไมต้องเอิร์ลแลง(Erlang)ภาษาอื่นก็มีตั้งมากมายล้านแปดที่จะให้ไปอ่านเล่นไม่ว่าจะเป็น สกาล่า(Scala), รูบี้(Ruby), ไพธอน(Python) และอื่นๆอีกมากมายแต่สำหรับผมแล้วมีเหตุผลอยู่สองข้อ

 

• ภาษานั้นต้องไม่ทำงานบนเจวีเอ็ม เพราะผมเบื่อมันมากกกกกก
• ภาษานั้นต้องไปเป็นการเขียนโปรแกรมแบบเชิงวัตถุ(Object Oriented) เพราะอยากเปลี่ยนวิธีคิดบ้าง 

 

ดังนั้นหวยเลยออกที่เอิร์ลแลง ก่อนอื่นเรามาทำความรู้จักกับภาษาก่อนว่ามันคืออะไร

1.1 เอิร์ลแลงในเปลือกนัท

เอิร์แลงเองเป็นทั้งแพลทฟอร์มและเป็นภาษาสำหรับการใช้งานทั่วไป โดยที่ตัวมันเองถูกออกแบบมาให้สามารถรองรับการทำงานหลายๆงานพร้อมกัน(Concurrent), กระจายการทำงาน(Distribution) และทนต่อความผิดพลาด(Fault Tolerance)ดังนั้นเราจะเห็นการนำเอาภาษานี้ไปใช้งานในโดเมนของระบบการสื่อสารเยอะมากเช่นบริษัทอิริกสัน(Ericsson)เป็นบริษัทที่ใช้งานภาษาเอิร์ลแลงสำหรับการสร้างระบบสื่อสารขนาดใหญ่ของตัวเองเยอะมาก

 

1.2 อะไรคือโอทีพี(OTP)

โอทีพีเป็นคำย่อของมาตรฐานเทเลคอมแบบเปิด(Open Telecom Platform)  ตัวมันเองเป็นไลบารี่ขนาดใหญ่ที่ช่วยให้เราสามาถทำได้ตั้งแต่การคอมไพล์ Abstract Syntax Notation One (ASN.1) ไปจนถึงการเตรียมเวบเซิร์ฟเวอร์ ดังนั้นทุกโปรเจคที่ใช้เอิร์ลแลงส่วนใหญ่จะใช้ เอิร์ลแลง/โอทีพี ไปโดยธรรมชาติแล้วนั่นเอง

1.3 แอพพลิเคชั่นประเภทไหนที่ควรจะใช้เอิร์ลแลง

 

• การประมวลผลแบบกระจาย, งานที่ต้องการความน่าเชื่อถือสูงมาก และการทำงานแบบซอฟท์เรียวไทม์
• ระบบทางโทรคมเช่นการควบคุมสวิช, การแปลงโปรโตคอล
• เซิร์ฟเวอร์สำหรับอินเทอร์เน็ทแอพพลิเคชั่น ยกตัวอย่างเช่น เอเจนท์สำหรับส่งเมล์ เซิร์ฟเวอร์ IMAP-4,HTTP เซิร์ฟเวอร์หรือ WAP สแต็ค.
• แอพพลิเคชั่นของระบบโทรคม เช่น การควบคุมระบบเน็ทเวิร์คสำหรับโทรศัพท์เคลื่อที่ 
• แอพพลิเคชั่นทั่วไปที่ต้องการความสามารถระดับซอฟท์เรียวไทม์

 

เอิร์ลแลงเป็นแพลทฟอร์มที่เหมาะสมมากกับงานเหล่านี้เพราะปัญหาเหล่านี้ถือเป็นอินพุทสำหรับการออกแบบตัวเอิร์ลแลงเองตั้งแต่แรกเริ่ม ทำให้มันมีความสามารถต่างๆที่พร้อมจะถูกใช้ในการแก้ปัญหาเหล่านี้ได้เช่น

 

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

 

เอิร์ลแลงมีตัวรันไทม์เอ็นไวรอนเมนท์ของเอิร์ลแลง(เหมือนกับเวอร์ชวลแมชีนของจาวา)  นั่นหมายความว่าโค้ดเอิร์ลแลงของเราสามารถถูกนำไปรันได้ทุกๆที่ที่มีตัวรันไทม์อยู่ 

 

1.4 ใครใช้งานเอิร์ลแลงอยู่บ้าง

คนที่ใช้งานเอิร์ลแลงมากที่สุดก็คืออิริกสัน โดยระบบที่ใหญ่ที่สุดของอิริคสันที่ใช้เอิร์ลแลงคือ AXD301 ATM Switch โดยปริมาณที่โค้ดของเอิร์ลแลงที่ใช้สำหรับโปรเจคนี้คือ 850 kloc และ 1Mloc ของ C/C++

บริษัทอื่นๆที่ใช้งานเอิร์ลแลง

 

• Bluetail/Alteon/Nortel (distributed, fault tolerant email system, SSL accelerator) 
• Cellpoint (Location-based Mobile Services) 
• Corelatus (SS7 monitoring). 
• dqdp.net (in Latvian) (Web Services). 
• Facebook (Facebook chat backend) 
• Finnish Meteorological Institute (Data acquisition and real-time monitoring) 
• IDT corp. (Real-time least-cost routing expert systems) 
• Kreditor (Electronic payment systems) 
• Mobilearts (GSM and UMTS services) 
• Netkit Solutions (Network Equipment Monitoring and Operations Support Systems) 
• Process-one (Jabber Messaging) 
• Schlund + Partner (Messaging and Interactive Voice Response services) 
• Quviq (Software Test Tool) 
• RabbitMQ (AMQP Enterprise Messaging) 
• T-Mobile (previously one2one) (advanced call control services) 
• Telia (a telecomms operator) 
• Vail Systems (Interactive Voice Response systems) 
• Wavenet (SS7 and IVR applications) 

 

 

 

 

 

 

@chanwit ได้รับแรงบันดาลใจจากรายงานการเลือกตั้งประธานาธิปดี ประเทศเจ้าโลกครับ โดยมีคนเก่งเขียนแอพพลิเคชั่นดึงเอาข้อความต่างๆ ที่มีคนพูดถึงผู้สมัคร

@chanwit เลยเขียนแอพพลิเคชั่นมาอีกหนึ่งตัวที่ดึงเอาข้อความใน twiiter ทีทีคนพูดถึงผู้สมัคร 5 คนขึ้นมให้เราอ่านประกอบไปด้วย ประภัสร์ อภิรักษ์ ลีน่า ชูวิทย์ และ เกรียงศักดิ์ ใครสนใจติดตามข่าวสารแบบรวดเร็วทันใจสามารถเข้าไปลองเล่นได้ที่

เลือกตั้งผู้ว่ากรุงเทพ 51<< click ที่นี่ครับ

 

edit @ 30 Sep 2008 22:42:24 by cyber-climber

อยากใช้ครับเพราะช่วงหลังเรื่องนี้แรงมาก เหตุผลเพราะอันดับแรกเน็ทมันแรงขึ้นทำให้เราสามารถใส่คอนเทนท์ที่พิศดารได้มากขึ้น รวมทั้งขนาดใหญ่มากขึ้น

ทำให้ผู้ผลิตเจ้าใหญ่ๆเร่งปล่อยของออกมากันใหญ่ทั้ง Adobe, SUN, MS ของฟรีก็มีหลายเจ้า

Adobe-Flex3 ต้นตำหรับตัวพ่อเรื่อง RIA เป็นเจ้าแรกที่ปล่อยเครื่องมือในการทำงานออกมาเจ้าแรก โดยออกมาตั้งแต่ปี 2004 สำหรับ Flex 1.0 ซึ่งตอนนั้นฮือฮามากเนื่องจาก เราสามารถสร้างแอพพลิเคชั่นให้หลุดพ้นจากขอบเขตเดิมๆที่เราติดอยู่ได้ แต่เงื่อนไขคือราคาแพงมากๆ ปัจจุบันมาถึงเวอร์ชั่นสามแล้ว มหัศจรรย์มากครับ แถมทั้งไม่เสียเงินด้วยถ้าต้องการเขียนเองโดยไม่ต้องพึ่งพาเครื่องมือ และที่บอกมหัศจรรย์คือมันสามารถเขียนรวมกับภาษาได้หลากหลายมากๆ ที่สนุกที่สุดคือเขียนกับ Rails ได้เนียนมากแถมมีหนังสืออกมาสองเล่มคือ Flexible Rails และ Enterprise Flexible Rails ดังนั้นไม่ต้องกลัว (ผมชอบแนวนี้มาก) ใครยังไม่เคยดูก็แวะไปดูได้ว่ามันตื๊ดขนาดไหนที่ Flex Showcase

SUN-JavaFx ออกมาให้ตื่นเต้นเล่นก่อน แล้วก็เงียบเป็นเป่าสาก แต่คาดว่ากำลังซุ่มทำอะไรแนวๆอยู่เพราะจาก JavaOne ครั้งที่ผ่านมาเห็นเอา ของเล่นมาโชว์คือสามารถทำให้ designer กับ developer ทำงานได้ใกล้กันมากขึ้นเพราะสามารถเอางานที่ designer ทำใน Photoshop ทำการ export ออกมาเขียนต่อได้เลยไม่ต้องเสียเวลาตัดให้เนิ่นนาน แต่ก็ยังเงียบเหมือนเดิม

MS-Silverlight2 ดีครับมหัศจรรย์มากๆเพราะออก expression studio มาด้วยเลยทำให้ Adobe ร้อนๆหนาวๆแต่ติดตรงเรื่องราคามหาโหด ตอดมาแบบเย็นๆ แต่รวมกันถึงสะดุ้งไปดูงานได้ที่ Showcase ครับสำหรับคนที่เป็นสาวกคงชอบมากเพราะมันก็ทำให้เรา ทำอะไรแปลกๆได้อีกเหมือนกันและถ้าดูจากผลที่ได้อาจจะลืมเรื่องราคาไปได้เหมือนกันครับ และที่สำคัญ Microsoft เตรียมคลังข้อมูลมหาศาลไว้ให้เรียบร้อยแล้ระดับไม่เสียดายตังแม้แต่แดงเดียวที่จ่ายไป

ส่วนที่เหลือก็จะเป็น product ที่ดังเมืองนอกอย่าง backbase แต่ไม่ดังเมืองไทยอันนี้ก็ครบชุดแต่แพงนรกแตก ส่วนอีกตัวคือ OpenLazlo ที่ยืนกรานว่าตัวเองเป็น Flex Alternative ดูจาก demo น่าสนใจครับแต่เอกสารน้อยจนน่ากลัว

สรุปผมน่าจะไปทาง Flex (+Rails) ครับเพราะดูแล้วจะกลางๆและมีอนาคตที่สุดสำหรับผม

เกริ่น

CPU คุณมีกี่ Core ครับ? ใครตอบต่ำกว่าสองคอร์ถือว่าตกเทรนด์ครับเพราะเดี๋ยวนี้เราต้องมีหลายๆคอร์และจากการ ทำนายแล้วในอีกสองปีเราจะมี CPU ที่มี 32 คอร์ออกมาให้เล่น

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

กฎของมัวร์ กล่าวไว้ว่า "คอมพิวเตอร์จะมีความเร็วเพิ่มขึ้นเป็นสองเท่า ทุก ๆ 18 เดือน โดยที่มีราคาคงเดิม" แต่ผู้เชี่ยวชาญในด้านนี้แตกต่างกันค่อนข้างมากครับ เพราะเป็นเรื่องของการทำนายอนาคต ผู้เชี่ยวชาญหลายท่านและ Dr. Moore เองก็คิดว่า กฎนี้น่าจะไปเจอทางตันที่ประมาณปี 2020

เพราะอย่าลืมว่าเราจะทำ ทรานซิสเตอร์ให้มันเล็กลงไปได้มากขนาดไหนกันละ? ดังนั้นหนึ่งในทางออกคือเพิ่มคอร์เข้าไป แทนที่จะเพิ่มความเร็วให้คอร์เดียว ก็ใส่คอร์ไปเยอะๆแต่ความเร็วของแต่ละคอร์ลดลงอันนี้เอามาจาก (http://softwareblogs.intel.com/2007/03/14/the-multi-core-dilemma-by-patrick-leonard/)

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

ทางเลือกแรก

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

ทั้งสองภาษานี้เป็นภาษาแห่งอนาคตครับ Scala เองเป็นภาษาที่ถูกเรียกว่าเป็นผู้สืบทอดแห่ง JVM หลายคนฟันธงว่ามันจะมาแทน Java และตัวมันเองถูกสร้างมาด้วยการเอาแนวคิดเรื่อง Object Oriented Programming มาผสมเข้ากับ Functional Programming ได้อย่างสวยงาม

ในทางกลับกัน Erlang เกิดขึ้นมาโดยบริษัท Ericsson โดยมันถูกออกแบบมาให้รับมือกับงานประเภท distributed, fault-tolerant, soft-real-time, non-stop applications แต่แตกต่างตรงที่มันเป็น Functional Programming

ทางเลือกที่สอง

ภาษาเก่าสิ่งที่เราต้องทำคือลุ้นว่าจะมีคน port ภาษาที่เราใช้อยู่ให้มันสามารถทำงานได้ดีบนโลกหลายคอร์ได้หรือไม่ เรามาดูกันทีละภาษา

Ruby เท่าที่เห้นว่าจะเป็นไปได้มากที่สุดคือ Rubinius ที่ประกาศว่าจะสร้าง VM สำหรับ Ruby ที่สามารถทำ  rich, high-performance environment for running Ruby code ที่เหลือดูจะยังไม่เป็นเรื่องเท่าไหร่

Python มี thread อยู่แล้วแต่ thread ใน python เป็น user thread ดังนั้นจะไม่สามารถแตก thread ข้ามคอร์ได้

Java มีอยู่แล้วสบายด้วย

C# ไม่ขอเอ่ยเพราะไม่รู้เรื่อง

จบเท่านี้ครับ

 

 

 

edit @ 24 Jun 2008 15:45:54 by cyber-climber