รายละเอียดใน RPG

มาดุรายละเอียดกันครับ
เขียนในสไตล์  เล่าเรื่องไปเรื่อยๆ  ถ้าจะให้ครบคงต้องไปอ่านใน หนังสือน๊ะครับ

ทบทวน Version

RPG II -> RPG III -> RPG/400 (with SQL) -> RPG ILE

RPG II    เขียน Code ให้สั้นที่สุด (เหมือน  การเจาะรูใน Punch Card จะเร็ว)
               แต่ละตำแหน่งที่เจาะรูในกระดาษ มีความหมาย  (มีมาก/เข้าใจยาก)
RPG III   เริ่มเป็น  Code ที่อ่านรู้เรื่องมากขึ้น (แต่จำกัดที่  ขนาดของ PunchCard)
RPG/400 (with SQL)  เพิ่มความสามารถต่างๆให้สะดวกขึ้น รวมทั้งเขียนติดต่อกับ SQL ได้
RPG ILE  ปรับที่ระดับ  โครงสร้างพื้นฐาน  ลดข้อจำกัดต่างๆ
...             มีข่าว ภาษาใหม่ ออกมา ทำงานแบบลูกครึ่ง  (จำชื่อไม่ได้แล้ว  เงียบไปแล้ว)

Hist

ผู้เขียนโชคดีที่  เมื่อเข้าทำงานบริษัทได้กำหนด  ให้หยุด/ลด การใช้ RPG II มาใช้ RPG III
(ช่วงนั้น การแปลง code เป็นงานใหญ่มาก)

ขอบคุณรุ่นพี่ทุกคนที่  กล้าหาญและเสียสละ  วางเส้นทางที่สะดวกในอนาคตไว้ ครับ
ช่วงเวลานั้นจะมีรุ่นพี่ 1 คน  ประกาศชัดเจน และมี 3-4 คน ที่เชี่ยวชาญสนับสนุน "เต็มตัว"
(ไม่ใช่เห็นด้วยแต่ไม่ทำอ่ะ) ทีมงานครอบคลุมทั้งหน่วยงาน


ตั้งแต่เริ่มใช้ RPG III เป็นต้นมาแนวทางการเขียนโปรแกรม "เข้าใจง่าย" ขึ้นมาก
นับเป็นจุดเปลี่ยนที่สำคัญ
(รุ่นพี่ได้แนะนำให้ ผู้เขียนอ่าน RPG II ด้วยเพราะมีบางโปรแกรม ที่ตกค้างยังและบางเทคนิคยังจำเป็น)

ในยุคถัดมา  บางกลุ่มได้พยายามปรับแนวทาง  ตาม ver  แต่ไม่สำเร็จ (ได้แค่ระดับบุคคล,หน่วยย่อย)
กลับเพิ่มปัญหาใหม่ คือ คนกลุ่มหนึ่งจะไม่ยอมเปลี่ยน  และอาจจะเกเรไม่ดู code ที่ตนเองอ่านไม่เข้าใจ

ตย.การเปลี่ยนไปใช้  RPG/400 with SQL  
ข้อดี คือ SQL เป็น Tool ที่ดีในการเข้าถึง Database (IBM แนะนำว่า SQL ทำงานเร็วกว่าแบบปัจจุบัน)
ข้อเสีย คือ ภาพรวม   (กับโครงสร้าง) ทำให้เขียนโปรแกรม "ยาวขึ้น" ,การตรวจสอบ "ยุ่งยาก"
(เหมาะกับ คนที่จะเริ่มปรับ มาใช้  ภาษารุ่นใหม่)
ต้องสร้างพื้นฐานให้ทุกคนใช้ SQL ให้คล่องก่อน (เพิ่ม ขั้นตอน)

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

(จาก Hist + ทดลอง พบว่า การบังคับ ใช้เวลาสั้นและสำเร็จ แต่ถ้า  อาสาสมัคร  ใช้เวลานาน,ล้มเหลว)


ตย แนวทางที่ผู้เขียน กำหนดเปลี่ยน
- เตรียมพร้อม ที่จะเปลี่ยน เทคโนโลยี (อนาคต) ใน 3 ปี
        ต้องทำได้ "เร็วกว่า" และพร้อมจะเปลี่ยน ภาษา(ASP -> C#, PHP, ...) ,DB (DB2 -> Oracle,...) 
- หยุด/ลด การเขียน Report บน RPG   โดยใช้ภาษาใหม่  ที่ง่าย/เร็วกว่า
     - ก่อนสร้าง Report   ใช้ SQL ทดสอบ Data บน Excel  
             เลือก iSeries Navigator
     - นำ SQL ไป Bind กับ ตัวแสดงผล ...  
             เลือก VS2005 Express + มีรูปแบบการสร้างที่แน่นอน (ลอกไปได้)
             + เน้น  ลดการปรับที่จุกจิก (ใช้เฉพาะบุคคล)  
     - เลือกใช้ OWC ช่วยในการ  เปลี่ยนการแสดงผล (1 report แสดงได้หลายแบบ)

RPG-Syntax

RPG เริ่มจากการเขียนบน  บัตรตอก (Punch Card)  ส่งให้เครื่องอ่าน อ่านและแปล (Compile)
(ประวัติศาสตร์นี้แหล่ะที่ทำให้ รูปแบบปัจจุบัน ยังคงต้องทำอยู่)

    ภาพแสดง การ์ดอธิบายช่องต่างๆ  ที่โปรแกรมเมอร์ในอดีต ต้องมีใช้ติดตัว


ในยุคนั้น  พบอุปสรรคเรื่องข้อจำกัดต่างๆ  (1 แถวใน  บัตรตอกป้อน code ได้ 60-100 อักษรเท่านั้น)
จึงได้หาทางแก้ไข เหมาะที่สุดในเวลานั้น  ได้แก่

# แต่ละช่อง มีความหมาย 

     จากรูป จะเห็นความหมายแต่ละช่อง


    เพื่อให้  ง่าย(ขึ้นนิ๊ด) บัตรตอก แยกหมวด (Specification) แต่ละหมวด มี Format เป็นของตนเอง

•  F-Spec = บอกว่า ติดต่อ file อะไรบ้าง  File Description Specifications
• [ E-Spec = ใช้บอก เขียนส่วนขยาย เช่น Array   Extenstion-Specifications ]
• [ I-Spec =รูปแบบ input (Field/Record) เป็นอย่างไร   Input-Specifications ] 
•  C-Spec = ส่วนของ Coding หรือ การคำนวน  Calculation-Specifications 
•  O-Spec = รูปแบบ output (Field/Layout) เป็นอย่างไร  Output-Specifications

     ภาพใน F-Spec ยังมีแบ่งย่อยการใช้งานอีก

     ใน ver RPG II ต้องใช้หมวดต่างๆเกือบจะครบ (ยังมีอีก 2 ตัวคือ  L,C) ... วันนี้ถ้าใครยังต้องใช้อยู่ ขอแสดงความเสียใจด้วยครับ
     แต่ ver RPG III ขึ้นไปใช้น้อยลง  RPG ILE เพิ่ม D-Spec ใช้กำหนดตัวแปร (มีความหมายชัดเจนกว่า I-Spec)

# ขนาดที่จำกัดขนาด

     ทำให้  ชื่อ File (8 อักษร), คำสั่ง (5 อักษร),ตัวแปร  (8 อักษร)
     หัดตั้งชื่อ Var, Field แบบย่อให้ได้  เช่น  strCustomerCode   -> CUST, CSTC, CSCD
     เริ่มใช้ ตัวแปรร่วม, ใช้ชั่วคราว  เช่น intK  -> N#52   strText  -> X#10

ภาพแสดง การเขียนคำสั่งติดต่อ File ลงในช่องที่จำกัด

       ตย. การอ่าน code ทำงาน
       F-Spec : โปรแกรมนี้ ติดต่อ File 2 ตัว
                TestX  เรียกใช้แบบ อ่านอย่างเดียว (I = Input)  ชื่อ Field ดูได้ใน I-Spec  (F)
                           จำกัดการติดต่อที่ 5 อักษร
                TestA  เรียกใข้แบบ  Update/Delete (U = Update)  ชื่อ Field ดูได้ใน I-Spec  (F)
                           จำกัดการติดต่อที่ 10 อักษร
                (มักจะใช้   E เพื่อบอกว่า  นำ Field ที่กำหนดใน File มาใช้  ไม่ต้องไปประกาศใน I-Spec)
      I-Spec กำหนดตาม ที่ F-Spec ระบุ  File ชื่อ ... ตั้งชื่อ Field อะไร  ตำแหน่งที่เท่าไหร่ ?
      C-Spec กำหนดให้ อ่านแบบเขียน ควบคุมเอง  (มี Goto)
                   อ่าน File  TestX
                   If    End Of File (*In66 = 1)  Then จบการทำงาน
                   Else
                           อ่าน File  TestA
                           If   Found  (*In67 = 0)   Then
                                    Fld1 = Part
                                    Output (Update) ตามรูปแบบ MAST (ดู O-Spec)
                           กลับไปอ่าน TextX ใหม่

       สำหรับคนรุ่นใหม่  เป็นอย่างไรครับ  (ถ้าเปิดใจบ้าง  วิธีนี้ก็เขียนโปรแกรมสั้นดีครับ)


   - ข่าวดี
          ตั้งแต่ ver RPG/400 เริ่มให้ พื้นที่การเขียนที่กว้างมากขึ้น  เขียนร่วมกับ SQL ได้
   - ข่าวร้าย ถ้าคุณต้องมาดูแล Code ที่เขียนไว้นานกว่า 5 ปี คุณต้องรู้โครงสร้างแบบเก่า 555

# ผลกระทบ 

           แบบอ่านเข้าใจง่าย       If  x <  20   Then
           เขียนในรูป RPG          X    IFLT 20                         Less Than

     ภาพแสดง การเขียนคำสั่ง  ลงในช่องที่จำกัด

           แบบอ่านเข้าใจง่าย       If  (x <  20) and (y >= 10)  
           เขียนในรูป RPG          X    IFLT 20
                                             Y   ANDGE                          Greather and Equal

           ปัญหาเก่าๆ ที่ไม่พบใน ภาษายุคใหม่แล้ว  จะกลับมาพบเห็นหมด
           เช่น                            X    IFLT 20
                                             Y   ANDGE10                      
                                             Z   ORLT 5                        

           code ข้างต้น  คนเขียน คิดแบบไหน ? RPG จะมองแบบไหน ?
           (a)  If    (x < 20) and (y >= 10)  or (z < 5)
           (b)  If   [(x < 20) and (y >= 10)]  or (z < 5)
           (c)  If    (x < 20) and [(y >= 10  or z < 5)]      
           (d)  ...

Tip :  ถ้าไม่ยึดติดมาก  Code ที่ดูยุ่งยาก  ก็ยังอ่านรู้เรื่อง
         ดังนั้นควรเน้น  "ความเข้าใจ" จะยืดหยุ่นดีกว่าท่องจำ

ใน RPG : ผมจะมี Source Code อยู่ 1 member ที่รวมเทคนิค ที่ใช้ "บ่อยๆ" = ผมจะมาค้นที่นี่ที่เดียว
ส่วน ภาษาอื่น  ที่ไม่ค่อยได้ใช้ (เช่น กลับไปเขียน code C#,ASP)
     ผมก็เรียกใช้เครื่องมือพื้นฐาน โดยใช้เวลาค้น 3-5 วินาที (เร็วมาก)
     แต่ผมต้อง "เข้าใจ"  -> รู้  "คำ" ที่จะค้นก่อน ...  แล้วไปค้นในจุดที่เปิดได้เร็วที่สุด (Help > Index, Google > ASP xxx example)

Tip : ควรอ่าน  แบบเร็ว  เพื้อให้คุ้นว่า  อะไรทำได้,ไม่ได้
- อ่าน Syntax "ทั้งหมด" หมายถึงอะไร (ไม่ต้องสนใจ การใช้งาน) ใช้เวลาประมาณ 10-30 นาที
  เช่น  ไม่มี For ... Next แต่ใช้  Do ... End แทน
  # อ่านจาก RPG "User" Guide 

- อ่านคำสั่ง "ทั้งหมด" หมายถึงอะไร (ไม่ต้องสนใจ การใช้งาน) ใช้เวลาประมาณ  1-2 ชม.
  เช่น SORTA ใช้เรียงค่าใน Array
  ดู code เล็กน้อย (บางทีเข้าใจง่ายกว่า)
  จะมี  ติดบางคำ (ถ้าไม่รุ่นพี่ ก็ถามซะ) ถ้าไม่รู้จะถามใคร ก็ผ่านๆไปก่อน (บางตัวไม่ใช้งานเลย)
  # อ่านจาก RPG "Reference" Guide จะเรียงตามอักษร

# ตัวแปรที่ไม่แปลก  แต่ไม่คุ้นเคย

ตัวแปร Boolean (True/False = 1/0 = On/Off) จะใช้ตัวแปรชนิด Indicator (*IN) แทน
พื้นฐานมีให้ใช้ 99 ตัว (01-99) ... คนรุ่นเก่านึกถึง การใช้ Register ใน Assembly

RPG จะใช้ Indicator แทน IF ...  And   เพราะพื้นที่จำกัด มาเขียน IF หลายๆตัวคงไม่ได้
      โดยกันพื้นที่  ให้ใช้ 3 ตัวด้านซ้าย

Tip : เมื่อรู้ที่มา ก็เลือกใช้ให้เหมาะน๊ะครับ  เช่น
        ควรใช้ IF คลุมหลายบรรทัด จะทำงานเร็วว่า  ใส่ Indicator  ตัวเดียวกันทุกบรรทัด

ในขณะเดียวกัน เมื่อสั่งOperation เช่น อ่าน File, ค้นหาใน Array, เปรียบเทียบ Field ก็จะส่งคืนค่าผ่าน Indicator
       โดยจะกันพื้นที่ด้านขวา  ให้แสดงผลได้ 3 ตัว

# RPG Cycle

เป็นส่วนของ RPG II หลงเหลือให้เห็นอยู่    Cycle = ทำงานวนไปเรื่อยๆ (Loop)

ภาคบังคับ  เพื่อจบ Cycle ต้องกำหนด Indicator = LR  (Last Record)ให้ = On(1)
                              SETON             LR
          LR                RETRN

สั่ง *IN LR = 1 หรือ On   บอกให้ RPG Compiler รู้ว่า   อ่านรอบนี้เป็นรอบสุดท้าย
(วิ่งไปจนถึงบรรทัดสุดท้ายของ C-Spec)
กำหนด If  *In LR = '1'   Then   ทำคำสั่ง  RETRN = Return   เป็นการสั่งให้  สิ้นสุดทำงาน "ทันที"
(ไม่ต้องรอให้ไปถึง บรรทัดสุดท้ายของ C-Spec)

(ตอนต่อไป น่าจะเข้าเรื่อง DB ได้สักที)