หลักการภาษาชุดคำสั่ง
Home  Contents KMArticlesMembersSponsorsAbout us

ปรับปรุง : 2556-11-05 (ปรับ template)
ขอบซ้ายขอบบน
บทนำ
CPSC 317 หรือ CPSC 214
หลักการภาษาชุดคำสั่ง
(Principles of Programming Languages)

- ทฤษฎีของการออกแบบ และสร้างภาษา แนวคิดเกี่ยวกับภาษาฟอร์มัล รูปแบบ และคุณลักษณะทางไวยากรณ์เบื้องต้น ชนิด และโครงสร้างของข้อมูล โครงสร้างของการควบคุม และการเคลื่อนที่ของข้อมูล การพิจารณาเวลาในการประมวลผล อัลกอริทึมแบบขนาน การออพติไมซ์ การออกแบบ และสร้างลักษณะต่าง ๆ ของภาษา ลักษณะเฉพาะของภาษาแบบโครงสร้างบล๊อก แบบมอดูลาร์ แบบเชิงวัตถุ ประเภทของภาษาชุดคำสั่ง แบบกำหนดกระบวนการ และแบบไม่กำหนดกระบวนการ การวิเคราะห์ประโยคคำสั่งของภาษาคอมพิวเตอร์ ฝึกปฏิบัติการเขียน และทดสอบโปรแกรมด้วยภาษาปาสคาล ภาษาซี หรือภาษาระดับสูงอื่น ๆ
- ภาษาคอมพิวเตอร์ (Computer Language) คือ ภาษาที่ใช้ หรือเกี่ยวข้องกับคอมพิวเตอร์ ซึ่งมักใช้ร่วมกับภาษาโปรแกรม แต่ภาษาคอมพิวเตอร์นั้นมีความหมายที่กว้างกว่า โดยไม่จำเป็นที่จะต้องเป็นภาษาโปรแกรม ซึ่งเป็นที่รู้กันว่าภาษาอย่างHTML หรือ SQL ไม่ใช่ภาษาโปรแกรม แต่ถือว่าเป็นภาษาคอมพิวเตอร์.
- ภาษาโปรแกรม (Program Language) คือ วิธีการมาตรฐานในการสื่อสารสำหรับแสดงคำสั่งไปยังคอมพิวเตอร์ ภาษาโปรแกรมกำหนดไวยากรณ์และการตีความหมายจากโปรแกรมคอมพิวเตอร์ที่เขียนขึ้น ภาษาโปรแกรมทำให้โปรแกรมเมอร์สามารถระบุอย่างชัดเจนถึงข้อมูลที่คอมพิวเตอร์จะทำงาน และวิธีการที่คอมพิวเตอร์จะประมวลผลข้อมูลเหล่านั้น
    จุดประสงค์รายวิชา
  1. เข้าใจทฤษฏีของการออกแบบ และสร้างภาษา
  2. เข้าใจแนวคิดเกี่ยวกับฟอร์มัล รูปแบบ และลักษณะทางไวยากรณ์เบื้องต้น
  3. เข้าใจชนิด และโครงสร้างของข้อมูล
  4. เข้าใจโครงสร้างของการควบคุม และการเคลื่อนที่ของข้อมูล
  5. เข้าใจหลักการในการพิจารณาเวลาในการประมวลผล อัลกอริทึมแบบขนาน และการออพติไมซ์
  6. เข้าใจการออกแบบ และสร้างลักษณะต่าง ๆ ของภาษา
  7. เข้าใจลักษณะเฉพาะของภาษาแบบโครงสร้างบล๊อก แบบมอดูลาร์ แบบเชิงวัตถุ
  8. เข้าใจประเภทของภาษาชุดคำสั่ง แบบกำหนดกระบวนการ และไม่กำหนดกระบวนการ
  9. เข้าใจการวิเคราะห์ประโยคคำสั่งของภาษาคอมพิวเตอร์
เอกสาร Power Point
- Introduction33
- Languages18
- Flowchart12
- Transition & Parse Tree7
- Infix to Postfix9
- Language Evaluation Criteria6
- GW-Basic Language14
- COBOL Language12
- Visual Basic Language12
ขอบซ้ายขอบบน
แผนการสอน
    แผนการสอน (Course Syllabus หรือ Course Outline)
    (ใหม่ ตามคำอธิบายรายวิชา และคณะกรรมการฯ)
  1. วิวัฒนาการ และประวัติของแต่ละภาษา
    กระบวนการแปลภาษา (Compilation Process) มี 5 ขั้นตอน
    1. เลกซิคัล อนาไลเซอร์ (Lexical Analyzer)
    2. ซินแทกซ์ อนาไลเซอร์ (Syntax Analyzer)
    3. ซีแมนติก อนาไลเซอร์ (Semantic Analyzer)
    4. โค้ด ออฟติไมเซอร์ (Code Optimizer)
    5. โค้ด เจนเนอเรเตอร์ (Code Generator)
    # http://www.personal.kent.edu
    # http://en.wikibooks.org
  2. ทฤษฎีของการออกแบบ สร้างภาษา และ การแสดงแบบซอฟต์แวร์
    1. การพิมพ์โปรแกรมต้นฉบับ (Source Listing)
    2. ผังงาน Flowchart #
    3. ผังงาน Structured Flowchart
    4. ผังงาน Nassi-Shneiderman
    5. ผังงาน HIPO
    6. ผังงาน Jackson
    7. ผังงาน Warnier-Orr (#)
    8. ผังโครงสร้าง (Structure Chart) ?
    9. คำสั่งลำลอง (Pseudo Code)
    10. ตารางการตัดสินใจ (Decision Table) ?
  3. การออกแบบ และสร้างลักษณะต่าง ๆ ของภาษา
    1. แนวคิดเกี่ยวกับภาษาฟอร์มัล ?
    2. รูปแบบ และคุณลักษณะทางไวยากรณ์เบื้องต้น
    3. ชนิด และโครงสร้างของข้อมูล
    4. โครงสร้างของการควบคุม และการเคลื่อนที่ของข้อมูล
    5. การพิจารณาเวลาในการประมวลผล
    6. อัลกอริทึมแบบบขนาน การออพติไมซ์
  4. ประเภทของภาษาชุดคำสั่ง
    1. แบบกำหนดกระบวนการ
    2. แบบไม่กำหนดกระบวนการ
  5. โครงสร้างภาษาแบบต่าง ๆ
    1. แบบโครงสร้างบล๊อก
    2. แบบมอดูลาร์
    3. แบบเชิงวัตถุ
  6. การวิเคราะห์ประโยคคำสั่ง และเกณฑ์การประเมินภาษา
  7. สอบกลางภาค
  8. แนวคิดภาษาโปรแกรมเชิงวัตถุ
    1. Encapsulation
    2. Inheritance
    3. Polymorphism (Overloading, Overriding)
  9. การนำ class กลับมาใช้ใหม่ (Object reuse)
    1. นำ class กลับมาใช้ใหม่ (แบบลอกใหม่หมด)
    2. เขียนใหม่จากข้อมูลที่มีอยู่ (ไม่มี source code ให้)
    3. นำโปรแกรมมาประกอบกัน (Composition)
    4. นำกลับมาใช้แบบสืบสกุล (Inheritance)
  10. การสืบทอด (Inheritance) และคอนสตัคเตอร์(Constructor)
  11. การพ้องรูป (Polymorphism)
    1. โอเวอร์โหลดดิ้ง (Overloading)
    2. โอเวอร์ไรดิ้ง(Overriding)
  12. การจัดการความผิดปกติโดย exception
  13. การเขียนโปรแกรมแบบ Event - driven (การทำงานตามเหตุการณ์)
    1. AWT (Abstract Windows Toolkit)
    2. แอปเพล็ต (Applet)
    3. สวิงค์(Swing)
  14. สอบปลายภาค
ตัวอย่างภาษาคอมพิวเตอร์
Compiler Resources
1. BATCH
2. DEBUG
3. QBASIC ? 1963
- Language Listing
- BAS 1.9 (Interpreter *)
4. GWBASIC ? 1963
- Games Source
- Free Basic Compiler ?
- YaBasic Compiler
5. PASCAL ? 1970
6. C++ ? 1970
- Notepad2 Source
- Djgpp Compiler
7. CLIPPER ? 1985
8. COBOL ? 1959
9. PERL ? 1987
- Active Perl of activeState.com
10. PHP ? 1994
11. ASP ?
12. JSP ?
13. JAVA ? 1990
14. JAVA Script ?
15. ACCESS Nov1992
16. VB ?
17. VB.NET ?
18. ASSEMBLY ?
- MS MASM 8.0
- MS MASM 6.15
- อิว ไอยรากาญจนกุล CD
19. HTML ?
20. MySQL ?
21. SQL Server ?
22. LOGO ?
CYGWIN (Unix Simulator) : # : #
คือ ชุดโปรแกรมสร้างสภาพแวดล้อมลินุกซ์บนวินโดวส์ ประกอบด้วย cygwin1.dll เพื่อจำลองสภาพแวดล้อมให้เหมือนลีนุกซ์ และรวมเครื่องมือที่จำเป็นให้เหมือนบนลีนุกซ์ โปรแกรมนี้จำเป็นต่อการ compile โปรแกรมมากมาย ที่ถูกพัฒนาให้ compile บน linux ทำให้นักพัฒนาสร้างโปรแกรมที่ถูกแปลบน linux นำมาแปลบน windows แบบจำลองขึ้นมาได้ เครื่องมือที่มีมาให้ เช่น ash coreutils cvs diffutils findutils gawk grep libiconv make patchutils perl sed unzip zip หลังสั่งประมวลผล setup.exe ก็เลือก download โปรแกรมต่าง ๆ แต่ที่สำคัญต้องเลือกลง gcc, nasm, binutils, libtool, zip, unzip, make, flex, bison, cvs, cmake, autoconf, automake, ed เพิ่ม มิเช่นนั้นจะไม่มีมาให้นะครับ หลัง download จะสร้างห้อง c:\cygwin อัตโนมัติ แล้วประมวลผล setup.exe อีกรอบ เพื่อติดตั้งจาก Local Directory หลังติดตั้งจะเข้า Linux โดยจำลองห้อง c:\cygwin เป็น root directory สำหรับคำสั่งที่ใช้งานได้อยู่ในห้อง bin
เมื่อเปรียบเทียบ Cygwin กับ Mingw พบว่า Mingw เน้นบริการ GCC แต่ Cygwin จำลองสภาพแวดล้องของ Linux ที่สมบูรณ์
ตัวอย่างการติดตั้ง เช่น #make หรือ #install.sh
- Download : setup.exe (cygwin.com 297 KB)
- Download : .iso (uwinnipeg.ca 700MB)
ขอบซ้ายขอบบน
กระบวนการแปลภาษา
กระบวนการแปลภาษา (Compilation Process)
1.Lexical Analyzer
2.Syntax Analyzer
3.Semantic Analyzer
4.Code Optimizer
5.Object Code Generation
แนะนำเว็บไซต์ตัวแปลภาษา
- Slide เรื่อง language implementation
- Compilers and Compiler Generators
- Languages and Compiler Design
มีหลายบท ตัวอย่างนี้เป็นบทที่ 6
- Programming language structure 1
มีหนังสือ และ parsing ที่ละเอียดมาก
- Programming language PPT ละเอียดดีมาก
ขอบซ้ายขอบบน
ขั้นตอนในตัวแปลภาษา (Step in compiler)
  1. เลกซิคัล อนาไลเซอร์ (Lexical Analyzer)
    ขั้นตอนแรก ทำหน้าที่ อ่าน Source Code แล้วแยกอักขระออกตามลักษณะ และหน้าที่ เช่น คำสั่ง ตัวแปร ค่าคงที่ เป็นต้น รวมถึงการขจัด ส่วนหมายเหตุ(Comment) ช่องว่างขาว(White space) เช่น blank, tab และ new line เป็นต้น ผลของขั้นตอนนี้จะแยกทุกสิ่งที่ควรแยกออกจากกัน เพื่อนำไปตรวจสอบในขั้นตอนต่อไป
    เป็นขั้นตอนแรกของคอมไพเลอร์ หน้าที่หลักคืออ่านอักษรทีละตัวจาก source code แล้วส่งผลลัพธ์ที่เป็น โทเคน ให้กับขั้นตอนซินแทกซ์อนาไลเซอร์ และเก็บค่าซึ่งจำเป็นต้องใช้ในขึ้นตอนอื่น ๆ ไว้ในตารางสัญลักษณ์ ซึ่งขั้นตอนซินแทกซ์อนาไลเซอร์ และเลกซิคัล อนาไลเซอร์ ต้องมีความสัมพันธ์กันอย่างใกล้ชิด


    Transition diagram แสดงลำดับของแต่ละประโยค แต่ละคำ แต่ละสัญลักษณ์ หรือตารางการตรวจสอบคำ (Token)
    A transition diagram is similar to a flowchart for (a part of) the lexer. We draw one for each possible token. It shows the decisions that must be made based on the input seen. The two main components are circles representing states (think of them as decision points of the lexer) and arrows representing edges (think of them as the decisions made).
    เช่น การแยก begin end if then และ else [http://cs.nyu.edu]
    (ตัวอย่างนี้จากหนังสือ การเขียนคอมไพเลอร์ สำหรับ IBM PC โดย อิว ไอยรากาญจนกุล สนพ.ซีเอ็ด)




    แบบฝึกหัด เรื่อง Transition diagram
    แสดง begin end
    แสดง if then และ else
    แสดง while loop locate และ lookup
    แสดง ตัวเลข = และ +
  2. ซินแทกซ์ อนาไลเซอร์ (Syntax Analyzer)
    ขั้นตอนที่สอง ทำหน้าที่ ตรวจสอบความสัมพันธ์ การจัดเรียง และความถูกต้องของแต่ละคำ แต่ละประโยค ซึ่งมีวิธีตรวจสอบหลายวิธี
    เช่น ตรวจสอบ parse tree ว่ามีไวยากรณ์ถูกต้องตามที่กำหนดไว้หรือไม่
    ? ? A parse tree is a tree that represents the syntactic structure of a string according to some formal grammar. A program that produces such trees is called a parser. Parse trees may be generated for sentences in natural languages (see natural language processing), as well as during processing of computer languages, such as programming languages.

    ตัวอย่างใช้ parse tree แสดง if E1 then ( if E2 then S1 else S2 ) หรือ if E1 then ( if E2 then S1) else S2


    แบบฝึกหัด เรื่อง parse tree
    ให้ใช้ parse tree แยก ( i + 2) * (3 - 1)
    ให้ใช้ parse tree แยก i + 2 * (3 - 1)
    ให้ใช้ parse tree แยก i + 2 * 3 - 1
  3. ซีแมนติก อนาไลเซอร์ (Semantic Analyzer) #
    ขั้นตอนที่สาม ทำหน้าที่ ตรวจสอบความหมายของภาษา และสร้างรหัสของชุดคำสั่งที่ผ่านการตรวจสอบการประกาศ ประเภทข้อมูล และความถูกต้องของโครงสร้างแล้ว ให้อยู่ในรูปแบบ หรือขั้นตอนที่ใกล้เคียงกับภาษาเครื่อง ซึ่งเป็นภาษากลางที่ง่ายต่อการปรับปรุง หรือนำไปแปลงเป็นภาษาเครื่องต่อไป ขั้นตอนนี้อาจนำไปรวมกับ Code Generator แล้วสร้างภาษาเครื่องก็ได้
    ตัวอย่าง
    double calculate(int a, double b); // function prototype
    int x = 0; // global variables available throughout the program
    double y; 
    int main() {
    int m[3]; // local variables available only in main
    char *n;
    }
    
  4. โค้ด ออฟติไมเซอร์ (Code Optimizer)
    ขั้นตอนที่สี่ ทำหน้าที่ ปรับปรุง code ที่ได้ให้มีประสิทธิภาพในการทำงาน ใน compiler บางตัวอย่างไม่มีขั้นตอนนี้ หรือมีขั้นตอนนี้ ที่ละเอียดกว่านี้ก็ได้

    - ถ้าใน method ว่างเปล่าแฟ้ม .class ที่ได้จาก 1.7.0_03 จะมีขนาด 247 Bytes
    - ถ้าใน method มีคำสั่ง if (true) แล้วพิมพ์ตัวเลข 1 หลัก แฟ้มที่ได้จะมีขนาด 372 Bytes
    - ถ้าใน method มีคำสั่ง if (false) แล้วพิมพ์ตัวเลข 1 หลัก แฟ้มที่ได้จะมีขนาด 247 Bytes
    - ถ้าใน method มีคำสั่งพิมพ์ตัวเลข 1 หลัก ก็ยังมีขนาด 372 Bytes
    - ถ้าใน method มีคำสั่งกำหนดค่าให้ y แบบ int มีขนาด 253 Bytes
  5. โค้ด เจนเนอเรเตอร์ (Code Generator)
    ขั้นตอนที่ห้า ทำหน้าที่ เปลี่ยนรหัสที่ได้ให้เป็นภาษาแอสเซมบลี หรือภาษาเครื่อง ซึ่ง code ที่ได้มีลักษณะขึ้นอยู่กับเครื่อง ที่ให้บริการหน่วยความจำ และ register ที่แตกต่างกันไป
    blank command
    define y equal 5
    + http://en.wikipedia.org/wiki/Java_class_file อธิบาย Magic Number : CAFE BABE for first 4 Bytes
    อีก 4 bytes ต่อมาก็เป็น version : 00 00 00 33 ซึ่ง 33 หมายถึง J2SE 7 = 51 (0x33 hex)
    Java ใช้ ASCII Code : 0B ปิดท้ายแฟ้ม .CLASS (0B = VT - vertical tabulation = เลื่อนไปยังแท็บหยุดในแนวตั้ง)
ขอบซ้ายขอบบน
D1. Source Listing
การพิมพ์โปรแกรมต้นฉบับ (Source Listing) คือ การแสดงรหัสต้นฉบับอย่างเป็นระเบียบ เพื่อใช้อ้างอิง และตรวจสอบได้ง่าย มักมีเลขบรรทัด เลขหน้า รวมถึงการจัดย่อหน้าให้เป็นระเบียบ สำหรับภาษา COBOL จะสร้างแฟ้ม .lst ให้กับนักพัฒนานำไปใช้งานได้ ในระหว่างการแปลภาษา ถือเป็นเอกสารแบบหนึ่งที่มีความสำคัญ ตัวอย่างผลการแปลรหัสต้นฉบับด้วยภาษา COBOL ดังภาพด้านล่างนี้จะได้แฟ้ม x.lst และ x.obj ซึ่งแฟ้ม .obj จะต้องนำไปทำการ link ก่อนจะได้แฟ้ม .exe ที่นำไปประมวลผลได้
งานมอบหมาย ให้นักศึกษาใช้ภาษา COBOL เขียนโปรแกรมอย่างง่าย 1 โปรแกรม แล้วส่งแฟ้ม .lst ให้ส่งผู้สอนผ่าน social network
ขอบซ้ายขอบบน
D2. Flowchart
ผังงาน (Flowchart) คือ รูปภาพ (Image) หรือสัญลักษณ์(Symbol) ที่ใช้เขียนแทนขั้นตอน คำอธิบาย ข้อความ หรือคำพูด ที่ใช้ในอัลกอริทึม (Algorithm) เพราะการนำเสนอขั้นตอนของงานให้เข้าใจตรงกัน ระหว่างผู้เกี่ยวข้อง ด้วยคำพูด หรือข้อความ ทำได้ยากกว่าเมื่อใช้รูปภาพ หรือสัญลักษณ์
     โดยปกติการเขียนผังงานจะไม่มีกฎเกณฑ์มากนัก ทำให้มีการนำผังงานไปใช้ในการอธิบายการไหลของงานอย่างแพร่หลาย ต่อมานักคอมพิวเตอร์ที่นำผังงานไปใช้แล้วต้องแปลงเป็นภาษาคอมพิวเตอร์ก็พบว่าทำได้ยากหรือทำไม่ได้ จึงมีแนวคิดว่าควรเปลี่ยนผังงานให้อยู่ในรูปของ Structured Flowchart ที่สามารถนำไปแปลงเป็นภาษาโปรแกรมได้ทันที


งานมอบหมาย เขียนผังงานมา 3 ผังงาน ที่ไม่เป็นไปตามกฎของ structured flowchart และผลการแปลงเป็น structured flowchart
ขอบซ้ายขอบบน
D3. Structure Flowchart
ผังงานโครงสร้าง (Structure Flowchart) คือ การเขียนผังงานที่มีกฎเกณฑ์ว่ากระบวนการต่าง ๆ จะต้องอยู่ใน 3 รูปแบบ คือ การทำงานแบบตามลำดับ (Sequence) การเลือกกระทำตามเงื่อนไข (Decision or Selection) และ การทำซ้ำ (Repeation or Loop)
ผังงานแสดงการรับค่าอาเรย์ 5 สมาชิกจากแป้นพิมพ์แบบตัวเลข รับจนหมดแล้วจึงทำซ้ำ เพื่อหาค่าสูงสุด เมื่อได้ค่าสูงสุด จึงพิมพ์ค่านั้นทางจอภาพ
COBOL source code : col 8 and 12 
       working-storage section.
       01 ar occurs 5 times     pic 999.
       01 max                   pic 999 value 0.
       01 i                     pic 999 value 0.
       procedure division.
           display " " with blank screen.
           perform loop1 varying i from 1 by 1 until i > 5.
           perform loop2 varying i from 1 by 1 until i > 5.
           display "Max : " max.
           stop run.
       loop1.
           display i  " : " with no advancing.
           accept ar(i).
       loop2.
           if ar(i) > max
              move ar(i) to max.
ขอบซ้ายขอบบน
D4. Nassi - Shneideman
แนสซี่ & ชไนเดอร์แมน (Nassi - Shneideman)
NSD = Nassi-Shneiderman diagram คือ การนำเสนอการออกแบบด้วยภาพกราฟฟิกสำหรับการโปรแกรมโครงสร้าง ถูกพัฒนาในปี 1972 (2515) โดย Isaac Nassi และ Ben Shneiderman แผนภาพเหล่านี้มีอีกชื่อคือ structograms เพื่อใช้แสดงโครงสร้างของโปรแกรม ซึ่งแผนภาพข้างล่างนี้จะนำเสนอการประมวลผล เพื่อปรับปรุงข้อมูลที่สัมพันธ์กันระหว่าง Master file และ Transaction file ที่เทียบได้กับการประมวลผลบนเทปแม่เหล็ก (ไม่ใช่ Harddisk ที่ใช้ SQL command เหมือนในปัจจุบัน)


งานมอบหมาย อธิบายแผนภาพทั้ง 3 นี้มาพอเข้าใจ
- http://www.cs.umd.edu/hcil/members/bshneiderman/nsd/ : แนะนำเครื่องมือช่วยวาดแผนภาพ
- http://en.wikipedia.org/wiki/Nassi-Shneiderman_diagram : มีภาพย่อยของแต่ละ function
- http://yourdon.com/strucanalysis/wiki/index.php?title=Chapter_15 : มีตัวอย่าง chart แบบต่าง ๆ และ master + transaction
ขอบซ้ายขอบบน
D5. HIPO
ผังงานไฮโป (HIPO = Hierarchy plus Input-Process-Output)
- http://www.yourdon.com/strucanalysis/chapters/ch15.html (Additional Modeling Tools)
- http://www.yourdon.com/imgs/strucanalysis/ch15/SA.15.9.gif (IPO diagram)
- http://www.shk-dplc.com/cfo/articles/litigate.htm


HIPO ถูกพัฒนาโดยบริษัท IBM เมื่อ 2517 เพื่อเป็นเครื่องมือที่ช่วยในการออกแบบ และแสดงแบบซอฟต์แวร์ โดยใช้ผังงานแบบเดิม แต่เพิ่มผังงานสำหรับอธิบายส่วนนำข้อมูลเข้า ส่วนประมวลผล และส่วนส่งออก ซึ่ง HIPO ประกอบด้วยผังงาน 3 ประเภท คือ 1) ผังงานลำดับความสำคัญของกิจกรรม (Hierarchy Diagram หรือ Visual Table of Contents) 2) ผังภาพรวม IPO (Overview IPO Diagram) และ 3) ผังภาพรายละเอียด IPO (Detailed IPO Diagram)

HIPO stands for Hierarchy plus Input, Process, Output. The first part, the hierarchy, is a visual table of contents that displays the modules in a hierarchy much like the appearance of an organization chart. The second part is a diagram that lists all input, all processes, and all output, and is often called an “IPO” chart.
ลูกศรสีดำ หมายถึง การควบคุม
ลูกศรสีขาว หมายถึง การเคลื่อนที่ของข้อมูล
ขอบซ้ายขอบบน
D6. Jackson Diagram
แจ็คสันไดอะแกรม (Jackson Diagram)

Jackson Structured Programming (JSP) is a method for structured programming based on correspondences between data stream structure and program structure. The method is closely related in concept to creating a parser for a regular expression that describes the data stream structure, but tries to build a program structure that matches more than one data stream and provides guidance and techniques to compensate the limited lookahead and the clashes between the structures of the different data streams. JSP was originally developed in the 1970s by IT consultant Michael A. Jackson and documented in his 1975 book Principles of Program Design. Jackson's aim was to improve the general standard of COBOL programming, but the method is still useful when coding with modern programming languages such as C and Perl.
- http://en.wikipedia.org/wiki/Jackson_Structured_Programming : มีอธิบายแต่ละ function
- http://www.answers.com/topic/jackson-structured-programming : มีอธิบายแต่ละ function
- http://cisx2.uma.maine.edu/NickTemp/JSP&JSDLec/jsd.html
ขอบซ้ายขอบบน
D7. Warnier-Orr diagram
ผังงานแบบวาร์นิแอร์-ออร์ (Warnier-Orr diagram)
+ http://widgetech.com/howto/warndiag.shtml
+ http://varatek.com/warnierorr.html (tool for diagram drawing)
Warnier-Orr diagrams are a kind of hierarchical flowchart that allows us to describe the organization of data and procedures. There are four basic constructs used on Warnier/Orr diagrams: hierarchy, sequence, repetition, and alternation. There are also two slightly more advanced concepts that are occasionally needed: concurrency and recursion. Each of these six diagramming constructs are illustrated in the sections that follow
1. Hierarchy is the most fundamental of all of the Warnier/Orr constructs. It is simply a nested group of sets and subsets shown as a set of nested brackets.
2. Sequence is the simplest structure to show on a Warnier/Orr diagram. Within one level of hierarchy, the features listed are shown in the order in which they occur.
3. Repetition is the representation of a classic "loop" in programming terms. It occurs whenever the same set of data occurs over and over again (for a data structure) or whenever the same group of actions is to occur over and over again (for a processing structure).
4. Alternation or selection, is the traditional "decision" process whereby a determination is made to execute one process or another.
5. Concurrency is one of the two advanced constructs used in the methodology. It is used whenever sequence is unimportant.
6. Recursion is the least used of the constructs. It is used to indicate that a set contains an earlier or a less ordered version of itself


Warnier-Orr diagrams are very similar to flowcharts, but they are more like psedoucode than blocks and shapes. They are a graphical representations of solutions or algorithms. They are a key step between the understanding of the steps needed to accomplish a task and the different steps that the program will take to finish the task. The more complex the problem, the more a Warnier-Orr diagram or other similar tool is essential in the design process of the program. This is because the more complex a program, the harder it is to follow the logical relationships of all of the steps with in the program. Warnier-Orr diagrams allow the programmer to work on and record one part of the problem, before moving to next problem, without being mired in the complexity of the whole program. They also allow the programmer to work out the logic of the program without being bogged down with the syntax of a specific language. The ability to understand the logical structure of a program without being confused in the details is indispesable.
ขอบซ้ายขอบบน
D8. Structure Chart
แผนผังโครงสร้าง (Structure Chart) หมายถึง เครื่องมือที่อธิบายถึงการแบ่งการทำงานของระบบออกเป็นส่วนย่อย หรือโมดูล โดยแสดงโมดูลเป็นลำดับขั้นตามการเรียกใช้ข้อมูล พร้อมทั้งแสดงถึงความสัมพันธ์ระหว่างโมดูล
+ http://www.rff.com/samples.htm (ตัวอย่างแผนภาพแบบต่าง ๆ)

Structure charts show how variables pass between modules in a computer program.
ขอบซ้ายขอบบน
D9. Pseudo code
คำสั่งลำลอง (Pseudo Code) คือ รหัสลำลอง หรือรหัสเทียม ที่ใช้เป็นตัวแทนของอัลกอริทึม โดยมีถ้อยคำหรือประโยคคำสั่งที่เขียนอยู่ในรูปแบบของภาษาอังกฤษที่ไม่ขึ้นกับภาษาคอมพิวเตอร์ภาษาใดภาษาหนึ่ง
หลักการเขียนซูโดโค้ด
1. ถ้อยคำที่ใช้เขียน ใช้ภาษาอังกฤษที่เข้าใจง่าย
2. ในหนึ่งบรรทัด ให้มีเพียงหนึ่งประโยคคำสั่ง
3. ใช้ย่อหน้าให้เป็นประโยชน์ ในการแสดงการควบคุมอย่างเป็นสัดส่วน
4. แต่ละประโยคคำสั่งให้เขียนจากบนลงล่าง และมีทางออกทางเดียว
5. กลุ่มของประโยคคำสั่งอาจรวมเป็นหมวดหมู่แล้วเรียกใช้เป็นโมดูล
+ http://www.thaiall.com/datastructure/pseudocode.htm
ขอบซ้ายขอบบน
D10. Decision Table
Decision tables เป็นเครื่องมือช่วยในการตัดสินใจที่แม่นยำ มีขนาดเล็กช่วยจัดการกับเงื่อนไขหรือตรรกะที่ซับซ้อน ตารางนี้คล้ายกับการใช้คำสั่ง if-then-else หรือ switch-case ที่รวมเงื่อนไขกับการปฏิบัติการเข้าด้วยกัน แต่ไม่เหมือนกับโปรแกรมโครงสร้างแบบดั่งเดิม เพราะสามารถจัดการกับเงื่อนไขได้อย่างอิสระแล้วกำหนดการปฏิบัติการได้อย่างหลากหลาย
Printer troubleshooter
Y= Yes , N = No , X = Execution
Rules
Conditions Printer does not print Y Y Y Y N N N N
A red light is flashing Y Y N N Y Y N N
Printer is unrecognized Y N Y N Y N Y N
Actions Check the power cable     X          
Check the printer-computer cable X   X          
Ensure printer software is installed X   X   X   X  
Check/replace ink X X     X X    
Check for paper jam   X   X        
ขอบซ้ายขอบบน
DFD (Data Flow Diagram)
In the late 1970s data-flow diagrams (DFDs) were introduced and popularized for structured analysis and design (Gane and Sarson 1979). DFDs show the flow of data from external entities into the system, showed how the data moved from one process to another, as well as its logical storage. There are only four symbols:
1. Squares representing external entities, which are sources or destinations of data.
2. Rounded rectangles representing processes, which take data as input, do something to it, and output it.
3. Arrows representing the data flows, which can either be electronic data or physical items.
4. Open-ended rectangles representing data stores, including electronic stores such as databases or XML files and physical stores such as or filing cabinets or stacks of paper.
- http://www.thaiall.com/dfd
- http://www.thaiall.com/casereg
ขอบซ้ายขอบบน
ER (Entity Relation)
The Entity-Relationship (ER) model was originally proposed by Peter in 1976 [Chen76] as a way to unify the network and relational database views. Simply stated the ER model is a conceptual data model that views the real world as entities and relationships. A basic component of the model is the Entity-Relationship diagram which is used to visually represents data objects.
- http://www.thaiall.com/learn/sader.htm
ขอบซ้ายขอบบน
UML
UML (Unify Model Language) คือ เครื่องมือสำหรับแสดงแบบซอฟท์แวร์ ที่ใช้หลักการออกแบบเชิงวัตถุ (OOP = Object oriented programming) รูปแบบของภาษา UML จะมีสัญลักษณ์ (Symbol) เครื่องหมาย (Notation) และกฎเกณฑ์ (Rule) ที่มีความหมายต่อการเขียนโปรแกรม (Coding) ดังนั้นการใช้ UML จะต้องทราบความหมายของ Symbol หรือ Notation เช่น Generalization, Association, Dependency, Realization, Class หรือ Package
- http://www.thaiall.com/uml
ขอบซ้ายขอบบน
หลักการต่าง ๆ (Other Principle)
เหตุผลของการเรียนหลักการภาษาชุดคำสั่ง
Reasons for Studing Concepts of Programming Languages (#robert 2)
1. เพิ่มการเร่งความคิด (Increased capacity to express ideas)
2. สามารถเลือกภาษาที่เหมาะสม (Improved Background for Choosing Appropriate Languages)
3. สามารถเรียนรู้ภาษาใหม่ (Increased Ability To Learn New Language)
4. เข้าใจความสำคัญการนำไปใช้ (Better Understanding Of The Significance Of Implementation)
5. สามารถออกแบบภาษาใหม่ (Increased Ability To Design New Languages)
6. สามารถคำนวณขั้นสูง (Overall Advancement Of Computing)

Programming Language
+ http://en.wikipedia.org/wiki/Programming_language
+ http://en.wikipedia.org/wiki/Formal_language
A programming language is an artificial language that can be used to control the behavior of a machine, particularly a computer. Programming languages, like human languages, are defined through the use of syntactic and semantic rules, to determine structure and meaning respectively.
Programming languages are used to facilitate communication about the task of organizing and manipulating information, and to express algorithms precisely. Some authors restrict the term "programming language" to those languages that can express all possible algorithms;[1] sometimes the term "computer language" is used for more limited artificial languages.

เกณฑ์การประเมินภาษา
Language Evaluation Criteria (#robert 8 #)
1. ความสามารถอ่าน (Readability) : the ease with which programs can be read and understood
1.1 ภาพรวมดูเข้าใจง่าย (Overall Simplicity)
1.2 รวมกลุ่มอย่างมีความหมาย (Orthogonality)
1.3 ควบคุมบรรทัดคำสั่ง (Control Statements)
1.4 ชนิดข้อมูล และโครงสร้าง (Data Types and Structures)
1.5 ถ้อยคำในประโยค (Syntax Considerations)
2. ความสามารถเขียน (Writability) : the ease with which a language can be used to create programs
2.1 รวมกลุ่ม ได้ง่าย (Simplicity and Orthogonality)
2.2 สนับสนุนการเขียนแบบคัดย่อ (Support for Abstaction)
2.3 ย่อคำสั่ง (Expressivity)
3. ความน่าเชื่อถือ (Reliability) : conformance (การทำให้สอดคล้องกัน) to specifications
3.1 ตรวจสอบชนิด (Type Checking)
3.2 การจัดการกับข้อผิดพลาด (Exception Handing)
3.3 การใช้นามแฝง (Aliasing)
3.4 ความสามารถอ่าน และเขียน (Readability and Writability)
4. ต้นทุน (Cost) : the ultimate total cost
4.1 การฝึกอบรม (Training)
4.2 การเขียน (Writing)
4.3 การแปลภาษา (Compiling)
4.4 การประมวลผล (Executing)
4.5 การติดตั้ง (Implementation)
4.6 ความเสี่ยง (Poor Reliability)
4.7 การบำรุงรักษา (Maintaining)
+ slide ที่เรื่องเกณฑ์ฯ http://www.csee.umbc.edu/331/fall00/notes/finin1.pdf
การตรวจสอบ และการทดสอบ
Verification & Validation
คือ กระบวนการตรวจสอบและยืนยันความถูกต้องของระบบงาน เป็นกระบวนการที่ช่วยให้ผู้พัฒนาระบบมีความแน่ใจว่าระบบที่ตนพัฒนานั้น ตรงตามข้อกำหนดตกลงไว้กับผู้ใช้หรือผู้จัดการระบบและตรงกับความต้องการของผู้ใช้ระบบนั้นอยู่เสมอ

Validation เป็นการตรวจสอบว่าระบบที่พัฒนาขึ้นมานั้นมีความถูกต้องหรือไม่
Verification เป็นการตรวจสอบว่าการพัฒนาสร้างระบบทำอย่างถูกต้องหรือไม่

กระบวนการทดสอบ แบ่งเป็น 2 ส่วน
1. การทดสอบโปรแกรม (Software Testing)
2. การทดสอบระบบ (System Testing)

กลยุทธ์การทดสอบโปรแกรม
1. Black Box Testing
เป็นการทดสอบโดยไม่คำนึงถึงคำสั่งภายในโปรแกรม เป็นการทดสอบ Function ต่างๆ ของโปรแกรมตาม Requirements ที่มี เป็นการทดสอบโดยดูค่า Output จาก Input ที่ให้กับโปรแกรมต้องมีความสอดคล้องกัน

การกำหนดข้อมูลในการทดสอบ ได้แก่
- ค่าตัวแทนของกลุ่ม
- ค่าสูงสุด
- ค่าต่ำสุด
- ค่าเกินพิกัด (เช่น อายุ 1000)
- ค่าที่ผิดวิสัย (เช่น ใช้อักษรแทนตัวเลข)
2. White Box Testing
เป็นการทดสอบเพื่อดูโครงสร้างของโปรแกรม หรือทางเดินในโปรแกรม ต้องสร้างชุดทดสอบเฉพาะสำหรับทดสอบในเงื่อนไขต่างๆ โดยชุดทดสอบจะต้องประกอบด้วยชุดที่สามารถประมวลผลอย่างปรกติและไม่ปรกติ

เทคนิคอื่นในการทดสอบโปรแกรม
1. Manual Testing - เป็นการทดสอบโดยไม่ใช้เครื่องคอมพิวเตอร์
1.1 Inspection - เป็นการทดสอบแบบตรวจไวยากรณ์
1.2 Desk Checking - เป็นการทดสอบตามลำดับคำสั่งในโปรแกรม
2. Automated Testing - เป็นการทดสอบด้วยเครื่องคอมพิวเตอร์
2.1 Syntax Checking - เป็นการทดสอบด้วยการตรวจสอบไวยากรณ์ที่เขียนขึ้น
2.2 Unit Testing/Module Testing - เป็นการทดสอบโปรแกรมทีละ Module เพื่อหาข้อผิดพลาดที่เกิดขึ้นภายใน Module
2.3 Integration Testing - เป็นการทดสอบโปรแกรมโดยการเพิ่มจำนวน Module แบ่งออกเป็น 2 ลักษณะ
2.3.1 Top-Down Approach - จาก Module บนลงล่าง
2.3.2 Bottom-Up Approach - จาก Module ล่างขึ้นบน
2.4 Stub Testing คือ กลุ่มคำสั่งสั้นๆ ที่เขียนขึ้นมาเป็น Module ตัวแทนในการทดสอบโปรแกรม
2.5 System Testing เป็นการทดสอบโปรแกรมทุกโปรแกรมร่วมกันว่าได้ผลลัพธ์ที่ถูกต้องหรือไม่

กระบวนการทดสอบระบบ
1. Unit Testing - การทดสอบส่วนย่อยของโปรแกรม
2. Module Testing - การทดสอบการทำงานร่วมกันของส่วนย่อยในระดับล่าง
3. Subsystem Testing - การทดสอบปัญหาของการไม่สอดประสานกันของหน่วยย่อยต่างๆ
4. System Testing - การตรวจสอบว่าระบบทั้งหมดทำงานได้ตรงตามข้อกำหนด หรือ ความต้องการของผู้ใช้อย่างแท้จริงหรือไม่
5. Acceptance Testing - การทดสอบขั้นสุดท้ายก่อนที่ระบบจะถูกยอมรับได้ว่าสามารถทำงานได้จริง
เป็นการทดสอบร่วมกันระหว่างผู้ใช้ระบบและผู้ออกแบบพัฒนาระบบ แบ่งได้เป็น 2 ประเภทคือ
5.1 Alpha Testing - การทดสอบความสมบูรณ์ของระบบโดยผู้ใช้ และใช้ข้อมูลสมมุติในการทดสอบ
มีการทดสอบ 4 ประการ
5.1.1 Recovery Testing - การทดสอบการกู้ระบบ
5.1.2 Security Testing - การทดสอบความปลอดภัยของระบบ
5.1.3 Stress Testing - การทดสอบประสิทธิภาพการทำงานของระบบภายใต้ความกดดัน
5.1.4 Performance Testing - การทดสอบประสิทธิภาพการทำงานของระบบภายใต้สภาพแวดล้อมของคอมพิวเตอร์
5.2 Beta Testing - การทดสอบความสมบูรณ์ของระบบโดยผู้ใช้ และใช้ข้อมูลจริงในการทดสอบ และภายใต้สถานการณ์ที่เกิดขึ้นจริง

เกณฑ์การยอมรับงาน
1. Time to Learn - ระยะเวลาที่ผู้ใช้ต้องเรียนรู้การใช้ส่วนต่างๆ
2. Task Performance - ความเร็วของการดำเนินงานแต่ละส่วน
3. Error Rate - อัตราความผิดพลาดที่เกิดขึ้น
4. Subjective User Satisfaction - ระดับความพึงพอใจของผู้ใช้โดยส่วนรวม
5. Human Retention - ความสามารถจดจำคำสั่งและการใช้งานได้

มีหลายครั้งที่ programmer
มองไม่เห็นความผิดพลาด คิดว่าถูกแล้ว
สืบเนื่องจากความเคยชินของการรับรู้
เช่น while(yes) { }
หรือ while(True) { }
แต่ compiler สมัยนี้บอกได้ว่า
2 ประโยคข้างต้นผิดกฎเกณฑ์ .. แปลว่าไม่ผ่าน

class x{
public static void main(String a[]) {
while(0==0) { } // pass & ctrl-break
}
}

สรุปว่า เชื่อการรับรู้ แต่เมื่อต้องถูกตรวจสอบ ก็จะไม่ผ่านเกณฑ์ จะให้เหตุผลว่ารับรู้มา น่าจะถูก .. ไม่ได้
วิธีการประเมินผลการทำงานของระบบ
1. การใช้แบบสอบถาม
2. การบันทึกเทปการทำงานของผู้ใช้
3. การสร้างส่วนพิเศษในระบบ ให้บันทึกข้อมูลกับการทำงานของผู้ใช้
4. การสร้างระบบให้ผู้ใช้สามารถบันทึกความคิดเห็นขณะใช้งานระบบ

การวางแผนการทดสอบระบบ
1. กำหนดข้อตกลงเบื้องต้นและรายละเอียดของระบบ
2. เตรียมแผนงานการทดสอบเพื่อการยอมรับระบบ
3. นำข้อมูลการออกแบบมาใช้ในการวางแผน
การทดสอบความสัมพันธ์ของระบบรวม
4. กำหนดแผนการทดสอบความสัมพันธ์ของระบบย่อย

การทดสอบระบบ ทำได้ 2 ประการ
- การทดสอบเชิงสถิติ (Statistical Testing)
เพื่อประเมินได้ผลเป็นตัวเลขจากการใช้งานระบบ
- การทดสอบข้อบกพร่อง (Defect Testing) 
เพื่อตรวจสอบว่าระบบมีข้อผิดพลาดที่จุดใดบ้าง

กลยุทธ์ในการทดสอบประสิทธิภาพของระบบ
1. Peak Load Testing
การทดสอบการทำงานสูงสุด เป็นการทดสอบประสิทธิภาพ
ในการประมวลผลของระบบ เมื่อมีการทำรายการมากที่สุด 
ณ เวลาใดเวลาหนึ่ง
2. Performance Testing
การทดสอบประสิทธิ์ภาพของเวลา เป็นการทดสอบ
เพื่อพิจารณาถึงช่วงเวลาที่ใช้ในการประมวลผลรายการ 
ว่าใช้ระยะเวลานานเพียงใดในการทำรายการ
3. Recovery Testing
การทดสอบการกู้ระบบ เป็นการทดสอบความสามารถ
ในการกู้ระบบกรณีที่ระบบล้ม
4. Storage Testing
การทดสอบการเก็บข้อมูล เป็นการทดสอบความสามารถ
ของระบบในการเก็บข้อมูล ว่าสามารถเก็บข้อมูลได้สูงสุด
เป็นจำนวนเท่าใด
5. Procedure Testing
การทดสอบกระบวนการ เป็นการทดสอบ
การจัดทำเอกสารคู่มือการดำเนินของระบบ 
และคู่มือการใช้งานสำหรับผู้ใช้ 
ว่าสามารถสร้างความเข้าใจให้กับผู้ใช้ได้มากน้อยเพียงใด
6. User Testing
การทดสอบผู้ใช้ เป็นการทดสอบการใช้งานจริงของระบบ 
เพื่อต้องการทราบว่าผู้ใช้จะทำอย่างไรเมื่อพบปัญหาที่เกิดขึ้น
ที่มา SCC : Suthida Chaichomchuen
+ http://www.na-vigator.com/software-development/software-testing/121-verification-a-validation
+ http://www.coleyconsulting.co.uk/v-model-verification-and-validation.htm

อัลกอริทึมแบบขนาน (Parallel Algorithm)
ในด้านวิทยาการคอมพิวเตอร์, อัลกอริทึมแบบขนาน (parallel algorithm หรือ concurrent algorithm) ตรงข้ามกับ อัลกอริทึมแบบต่อเนื่องยุคเก่า (serial algorithm หรือ sequential algorithm),
ยุคใหม่จะนำงานหนึ่งไปประมวผลแบบแยกเป็นชิ้นเล็ก (piece) ให้ทำงานบนหลายอุปกรณ์ที่ต่างกัน,
แล้วนำกลับมารวมกันอีกครั้ง เพื่อให้ได้ผลลัพธ์สุดท้ายที่ถูกต้อง
http://en.wikipedia.org/wiki/Parallel_algorithm

     Some algorithms are easy to divide up into pieces like this. For example, splitting up the job of checking all of the numbers from one to a hundred thousand to see which are primes could be done by assigning a subset of the numbers to each available processor, and then putting the list of positive results back together.
     Most of the available algorithms to compute Pi, on the other hand, can not be easily split up into parallel portions. They require the results from a preceding step to effectively carry on with the next step. Such problems are called inherently serial problems. Iterative numerical methods, such as Newton's method or the three body problem, are also algorithms which are inherently serial. Some problems are very difficult to parallelize, although they are recursive. One such example is the depth-first search of graph.
     Parallel algorithms are valuable because it is faster to perform large computing tasks via a parallel algorithm than it is via a serial (non-parallel) algorithm, because of the way modern processors work. It is far more difficult to construct a computer with a single fast processor than one with many slow processors with the same throughput. There are also certain theoretical limits to the potential speed of serial processors. On the other hand, every parallel algorithm has a serial part and so parallel algorithms have a saturation point (see Amdahl's law). After that point adding more processors does not yield any more throughput but only increases the overhead and cost.
     The cost or complexity of serial algorithms is estimated in terms of the space (memory) and time (processor cycles) that they take. Parallel algorithms need to optimize one more resource, the communication between different processors. There are two ways parallel processors communicate, shared memory or message passing.
     Shared memory processing needs additional locking for the data, imposes the overhead of additional processor and bus cycles, and also serializes some portion of the algorithm.
     Message passing processing uses channels and message boxes but this communication adds transfer overhead on the bus, additional memory need for queues and message boxes and latency in the messages. Designs of parallel processors use special buses like crossbar so that the communication overhead will be small but it is the parallel algorithm that decides the volume of the traffic.
     Another problem with parallel algorithms is ensuring that they are suitably load balanced. For example, checking all numbers from one to a hundred thousand for primality is easy to split amongst processors, however some processors will get more work to do than the others, which will sit idle until the loaded processors complete.
     A subtype of parallel algorithms, distributed algorithms are algorithms designed to work in cluster computing and distributed computing environments, where additional concerns beyond the scope of "classical" parallel algorithms need to be addressed.
Parallel Computer
! http://www-unix.mcs.anl.gov/dbpp/text/node7.html
     A parallel computer is a set of processors that are able to work cooperatively to solve a computational problem. This definition is broad enough to include parallel supercomputers that have hundreds or thousands of processors, networks of workstations, multiple-processor workstations, and embedded systems. Parallel computers are interesting because they offer the potential to concentrate computational resources---whether processors, memory, or I/O bandwidth---on important computational problems

หลักการออกแบบจากบนลงล่าง และล่างขึ้นบน (#ครรชิตวิชิต 23)
Top-down Design : วิธีการย่อยปัญหาโปรแกรม โดยเน้นที่โครงสร้างควบคุมของโปรแกรมหรือการควบคุมการทำงานตามคำสั่งต่าง ๆ ในโปรแกรม เมื่อได้โครงสร้างควบคุมแล้ว จึงพิจารณารายละเอียดแต่ละคำสั่ง สำหรับการพิจารณามอดูลในแต่ละระดับ ไม่จำเป็นต้องสนใจรายละเอียดในระดับย่อยลงไป แต่สนใจเฉพาะข้อมูล และการควบคุมการทำงานของมอดูลระดับนั้นเท่านั้น
Bottom-up Design : วิธีการวิเคราะห์หาปัญหาโดยใช้ประสบการณ์ หาว่าส่วนใดคือปัญหาที่ซับซ้อน เมื่อได้เป้าหมาย ก็ทุ่มเทความสนใจ กำหนดรายละเอียด และโครงสร้างของโปรแกรมจนทำให้งานในส่วนนั้นเสร็จ และจึงเริ่มพิจารณาส่วนอื่นต่อไป วิธีนี้เริ่มต้น และออกแบบ จากส่วนที่สำคัญที่สุด

กำเนิด และกฏของ OOP (Object Oriented Programming) (#ธวัชชัย 11)
อาลัน เคร์(Alan Kay) เป็นผู้บุกเบิกแนวความคิดการเขียนโปรแกรมเชิงวัตถุคนหนึ่ง และมีส่วนพัฒนา Small talk ได้เสนอกฎ 5 ข้อของ OOP ไว้ดังนี้
1. ทุกสิ่งเป็นวัตถุ (Everything is an object)
2. โปรแกรมคือกลุ่มของวัตถุที่ส่งข่าวสารบอกกันและกันให้ทำงาน (A program is a bunch(พวง) of objects telling each other what to do by sending messages)
3. แต่ละวัตถุต้องมีหน่วยความจำ และประกอบด้วยวัตถุอื่น (Each object has its own memory made up of other objects)
4. วัตถุต้องจัดอยู่ในประเภทใดประเภทหนึ่ง (Every object has a type)
5. วัตถุประเภทเดียวกันย่อมได้รับข่าวสารเหมือนกัน (All objects of a particular type can receive the same messages)

แนวคิดภาษาโปรแกรมเชิงวัตถุ (Concepts in Object-Oriented Programming Languages) (#บุญเลิศ 14 + #frank 20)
  1. กำเนิด และกฏของ OOP (Object Oriented Programming)
  2. Overloading :: ใน polymorphism หมายถึงการมีชื่อ method เดียวกัน อาศัย parameter เป็นตัวจำแนกความแตกต่างภายในการทำงานของ method
  3. Overriding :: ใน polymorphism หมายถึงทั้งลูก และแม่มีชื่อ method เดียวกัน
  4. Object :: วัตถุคือทุกอย่างรวมกัน มักประกอบด้วยรายละเอียดและกิจกรรม เป็นกลุ่มก้อนเดียวกัน
  5. Class :: Class เสมือนแม่พิมพ์ที่พิมพ์วัตถุออกใช้ แต่ไม่สามารถใช้ประโยชน์จาก class ได้โดยตรง และ class จะถูกสร้างขึ้นโดยนิยามคุณสมบัติ(Properties) และพฤติกรรม(Method) เมื่อ class ถูกเรียกใช้ class จะสร้างวัตถุขึ้นมาทำงานแทน class ที่ถูกเรียกใช้
  6. Method :: พฤติกรรมที่กำหนดภายในแต่ละ class เพราะกระทำการใด ๆ
  7. Identifiers :: ชื่อที่ผู้ใช้ตั้งขึ้นให้กับ variable method หรือ class สามารถขึ้นต้นด้วย _ $ A a ก และไม่จำกัดความยาว
  8. Program :: กลุ่มของวัตถุที่ส่งข้อความ ข่าวสาร ถึงกันและกัน เพื่อบอกให้วัตถุทำงาน วัตถุจึงไม่ทำงาน ดังนั้น java จึงออกแบบให้ทุกอย่างอยู่ใน class หรือวัตถุ
  9. Primitive Data Types :: แบบของข้อมูลพื้นฐานมี 8 แบบ
  10. Constructor :: default method ของ class ที่มีชื่อเดียวกับ class และไม่มีส่วนขยาย
  11. การปกป้อง (Encapsulation)
    : การปกป้องข้อมูล (Object combine data and operations) หรือรวมกิจกรรม และรายละเอียดไว้ในที่ ๆ ได้รับการปกป้องเดียวกัน
    : เช่นประกาศตัวแปร ตัวเดียว แต่เรียกใช้ตัวแปร และรายละเอียดทั้งหมดได้ หากไม่ใช้ความสามารถนี้ จะต้องประกาศแบบ global แทน
  12. การสืบทอด (Inheritance)
    : สามารถสืบสกุลได้ (Class can inherit properties from other classes) สามารถใช้คุณสมบัติที่บรรพบุรุษสร้างขึ้นได้
    : เช่น สร้างสกุลคือ person มีตัวแปรเก็บข้อมูล 7 ตัวแปร ต่อมาสร้างสกุลใหม่ newperson เพื่อสืบสกุลเดิม ทำให้สามารถสร้างตัวแปรทับ หรือเพิ่มใหม่ได้
  13. การพ้องรูป (Polymorphism) มาจากภาษากรีก หมายถึง many shapes
    : หัวข้อที่เกี่ยวข้อง คือ Overloading และ Overriding
    : เลือกปฏิบัติแตกต่างด้วยความสามารถเดิมของสกุลเดิมด้วยสกุลใหม่ (Object can determine appropriate operation at execution time)
    : เช่น สกุล point มีกิจกรรม show, clear เมื่อสร้างสกุล circle ก็สามารถใช้กิจกรรม show, clear ของ point ได้อีก
    : โปรแกรมเดียวกันทำงานได้แตกต่างกันในสกุลเดียวกัน
      ตัวอย่างภาษาปาสคาล (Pascal Language)
      procedure outmsg;
      procedure outmsg(num: Integer);
      procedure outmsg(msg: String);

สรุปการเขียนโปรแกรมเชิงวัตถุ (#บุญเลิศ 234)
  1. ความมุ่งหมาย เพื่อประหยัดเวลาในการพัฒนาระบบ ที่สามารถนำโปรแกรมที่เคยพัฒนามาใช้ได้ใหม่
  2. ลักษณะของโปรแกรมแบบ OOP
    - การปกป้อง (Encapsulation)
    - การสืบทอด (Inheritance)
    - การพ้องรูป (Polymorphism)
    - การเรียกเกินกำลัง (Overloading) [ตัวแปรภาษาเก่า ๆ ไม่มีความสามารถนี้]
  3. ออปเจ็กต์จะประกอบด้วยรายละเอียด(Properties) และกิจกรรม(Method)

ชนิดของข้อมูล (Data Types) 8 แบบ
+ http://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
Every variable must have a data type. A variable's data type determines the values that the variable can contain and the operations that can be performed on it. For example, in the MaxVariablesDemo program, the declaration int largestInteger declares that largestInteger has an integer data type (int). Integers can contain only integral values (both positive and negative). You can perform arithmetic operations, such as addition, on integer variables.
The Java programming language has two categories of data types: primitive and reference. A variable of primitive type contains a single value of the appropriate size and format for its type: a number, a character, or a boolean value. For example, an integer value is 32 bits of data in a format known as two's complement, the value of a char is 16 bits of data formatted as a Unicode character, and so on.
The following table lists, by keyword, all of the primitive data types supported by Java, their sizes and formats, and a brief description of each. The MaxVariablesDemo program declares one variable of each primitive type.
Primitive Data Types
Keyword Description Size/Format
Integer numbers ::
    1. byte - Byte-length integer 8-bit two's complement
    2. short - Short integer 16-bit two's complement
    3. int - Integer 32-bit two's complement
    4. long - Long integer 64-bit two's complement
real numbers ::
    5. float - Single-precision floating point 32-bit IEEE 754
    6. double - Double-precision floating point 64-bit IEEE 754
other types ::
    7. char - A single character 16-bit Unicode character
    8. boolean - A boolean value (true or false) true or false
หมายเหตุ
ในภาษาอื่นจะมีรูปแบบและขนาด primitive data type ที่ขึ้นกับ platform ที่โปรแกรมนั้นประมวลผลอยู่ ส่วนภาษาจาวาจะใช้ pointer หรือ reference type กับ array, class หรือ interface ตามตำแหน่งที่จัดเก็บในหน่วยความจำ และไม่ได้กำหนดตำแหน่งในหน่วยความจำที่ชัดเจนเหมือนภาษาอื่น แต่ใช้การอ้างอิงผ่านชื่อตัวแปรแทน

การทำให้ดี (Optimization)
OPL(Optimization programming language) (http://mitpress.mit.edu/promotions/books/VANPPS99)
Linear programming, integer programming, and combinatorial optimization problems are ubiquitous (ซึ่งมีอยู่ทุกหนทุกแห่ง) in areas such as planning, scheduling, sequencing, resource allocation, design, and configuration, yet they are still challenging to formulate and express. OPL (Optimization Programming Language) is a new modeling language for combinatorial optimization that simplifies the formulation and solution of optimization problems. Perhaps the most significant dimension of OPL is the support for constraint (ข้อจำกัด) programming, including sophisticated (ซึ่งมีประสบการณ์มาก) search specifications, logical and higher order constraints, and support for scheduling and resource allocation applications.
What is Optimization? (http://www-fp.mcs.anl.gov/otc/Guide/OptWeb/opt.html)
Optimization problems are made up of three basic ingredients:
1. An objective function which we want to minimize or maximize. For instance, in a manufacturing process, we might want to maximize the profit or minimize the cost. In fitting experimental data to a user-defined model, we might minimize the total deviation (ความคลาดเคลื่อน) of observed data from predictions based on the model. In designing an automobile panel, we might want to maximize the strength(แข็งแรง).
2. A set of unknowns or variables which affect the value of the objective function. In the manufacturing problem, the variables might include the amounts of different resources used or the time spent on each activity. In fitting-the-data problem, the unknowns are the parameters that define the model. In the panel (แผงควบคุม) design problem, the variables used define the shape and dimensions of the panel.
3. A set of constraints (ข้อจำกัด) that allow the unknowns to take on certain values but exclude (แยกออกไป) others. For the manufacturing problem, it does not make sense to spend a negative amount of time on any activity, so we constrain all the "time" variables to be non-negative. In the panel design problem, we would probably want to limit the weight of the product and to constrain its shape.
Simple tricks for VB optimization
http://www.shamrock-software.eu/vb.htm
Use the dollar symbol for string functions
One might expect that Mid$( ) and Mid( ) are the same and the dollar symbol representing the string type is more or less implicit for string manipulating functions. But without the $, VB will return a variant value and has to reconvert it to a string later. Adding the $ is an optimization. It will explicitly enforce a string value to be returned. Running a loop 10 million times on a test PC shows significant timing differences:
e$ = mid("ABC", 2) 5.0 s
e$ = mid$("ABC", 2) 1.9 s

So a dollar symbol should be added behind all functions returning a string to avoid the unnecessary type conversion: Chr ChrB CurDir Dir Format Hex Input InputB LCase Left LeftB Mid MidB Oct Right RightB RTrim Space Str String Trim UCase
Code Optimization ด้วย GW-Basic

5 START = TIMER
10 DIM X
20 FOR I = 1 TO 1000000!
30 X = X + I
40 NEXT
50 PRINT X
60 PRINT(TIMER - START)

run
 4.999414E+11 
 1.589844
Ok

โครงสร้างข้อมูล
แสดงถึงความสัมพันธ์ระหว่างข้อมูล ความสัมพันธ์หลักใหญ่ ๆ 4 แบบ
http://sot.swu.ac.th/CP341/lesson01/ms1t2.htm
โครงสร้างข้อมูลแบบเซต (set) เป็นโครงสร้างที่ข้อมูลแต่ละตัวไม่มีความสัมพันธ์กันเลย
โครงสร้างแบบเชิงเส้น (linear) เป็นโครงสร้างที่ข้อมูลมีความสัมพันธ์แบบหนึ่งต่อหนึ่ง (one-to-one relationship) นั่นคือเราสามารถระบุถึงข้อมูลตัวถัดไปของข้อมูลได้
โครงสร้างแบบต้นไม้หรือแบบลำดับขั้น (tree or hierarchical) เป็นโครงสร้างที่ข้อมูลมีความสัมพันธ์กันแบบหนึ่งต่อหลาย (one-to-many relationship) นั่นคือ ข้อมูลตัวหนึ่งสามารถมีความสัมพันธ์กับข้อมูลในลำดับรองลงไปได้หลายตัว
โครงสร้างแบบกราฟหรือเครือข่าย (graph or network) เป็นโครงสร้างที่ข้อมูลมีความสัมพันธ์กันแบบหลายต่อหลาย (many-to-many relationship) นั่นคือ ข้อมูลตัวหนึ่ง ๆ อาจจะมีความสัมพันธ์กับข้อมูลตัวอื่น ๆ กี่ตัวก็ได้

ภาษาคอมพิวเตอร์ (Computer Language)
+ http://www.snw.ac.th/courseware/www.nectec.or.th/courseware/computer/comp-using/0064.html
การสั่งงานคอมพิวเตอร์ ต้องอาศัยภาษาที่มีรูปแบบไวยากรณ์ที่ชัดเจน รัดกุม เพื่อให้คอมพิวเตอร์แปลความหมาย ได้ถูกต้อง ไม่เกิดผลผิดพลาด ภาษาสำหรับใช้เขียน คำสั่งให้คอมพิวเตอร์ทำงาน มีวิวัฒนาการมาหลายรุ่น มีคุณสมบัติ และลักษณะแตกต่างกันออกไป ดังนี้
ภาษารุ่นที่ 1
ภาษาเครื่อง (Machine Language) ที่ใช้อักขระเพียง 0 และ 1
ภาษาสัญลักษณ์ (Symbol Language)
ภาษาแอสเซมบลี (Assembly Language) ที่ใช้รหัสช่วยจำ (Mnemonic Code) แทนรหัสคำสั่งที่เป็นอักขระ 0 กับ 1
การเขียนคำสั่งภาษาเครื่อง และภาษาสัญลักษณ์ จำเป็นต้องทราบขั้นตอน การทำงานภายในของตัวประมวลผลอย่างละเอียด ต้องทราบจำนวนรีจิสเตอร์ (Register) และหน้าที่ของรีจิสเตอร์ ต้องทราบถึงการอ้างถึงข้อมูลในหน่วยความจำมีวิธี และทำได้อย่างไร ภาษารุ่นนี้จึงใช้งานได้ยาก และมีความซับซ้อนในการสั่งงาน
ตัวอย่างภาษา Assembly
B80103 mov ax,00301
B90100 mov cx,00001
BA8000 mov dx,00080
CD13 int 013
C3 retn

ภาษารุ่นที่ 2
เป็นภาษาที่พัฒนาที่นับได้ว่าเก่าแก่ที่สุด และนับเป็นพื้นฐานในการพัฒนาภาษาคอมพิวเตอร์ใหม่ๆ ด้วย โดยมีจุดอ่อน คือ เป็นภาษาที่ไม่มีโครงสร้าง ไม่สามารถกำหนดชนิดข้อมูลได้ เช่น ภาษาฟอร์แทรน (FORTRAN), ภาษาโคบอล (COBOL - Common Business Oriented Language), ภาษา ALGOL (Algorithm Language) และภาษายอดนิยมที่สุด คือ ภาษา BASIC (Beginner's All Purpose Symbolic Instruction Code) ซึ่งหลายภาษา ยังได้รับความนิยมจนถึงปัจจุบัน
ตัวอย่างภาษา Cobol
working-storage section.
77 x pic 99.
procedure division.
move 0 to x.
perform cal-para until x >= 10.
stop run.
cal-para.
add 1 to x.
display x.

ภาษารุ่นที่ 3
เป็นภาษาที่นำเอาจุดด้อยของภาษารุ่นที่ 2 มาปรับปรุงและพัฒนา โดยปรับปรุงลักษณะ โครงสร้าง ตลอดจนขีดความสามารถของภาษารุ่นที่ 2 โดยแบ่งภาษารุ่นนี้ เป็นสองลักณะ คือ ภาษาสำหรับงานทั่วไป ได้แก่ ภาษา PL/I, Pascal, Modula-2, C, Ada โดยมีพื้นฐานการพัฒนามาจากภาษา ALGOL โดยนิยมนำมาใช้ในงานวิศวกรรม วิทยาศาสตร์ ธุรกิจ ตลอดจนงานระบบต่างๆ และภาษาสำหรับงานพิเศษ อันเป็นภาษาที่จัดทำขึ้นมาเพื่อใช้งานเฉพาะเจาะจง มีรูปแบบพิเศษออกไป เช่น ภาษา Lisp, Prolog, Smalltalk, APL และ FORTH เป็นต้น

ภาษารุ่นที่ 4
เป็นภาษาที่พัฒนาขึ้นมาเพื่อลดขั้นตอนการออกแบบระบบ โดยผู้ใช้ระบุผลลัพธ์ที่ต้องการ จากนั้นโปรแกรมก็จะใช้ความรู้ภายในตัวภาษา มาหาผลลัพธ์นั้นๆ แต่บางฟังก์ชันก็ยังต้องอาศัย การกำหนดเงื่อนไข และลำดับขั้นตอนของงานด้วย ภาษารุ่นนี้ เช่น ภาษาสอบถาม (Query Language) ซึ่งใช้ในการสืบค้นข้อมูลในฐานข้อมูล ได้แก่ ภาษา SQL (Sturctured Query Language) นอกจากภาษาสอบถาม ยังมีภาษาแบบตัวสร้างโปรแกรม (Program Generator) ซึ่งมักจะพบในโปรแกรมจัดการฐานข้อมูล เช่น dBASE, FoxPro เป็นต้น

ภาษารุ่นที่ 5
เป็นภาษารุ่นใหม่ที่นิยมใช้กันอย่างแพร่หลายในปัจจุบัน มีลักษณะการทำงานเชิงวัตถุ มีระบบช่วยเหลือต่างๆ มากมาย เช่น Visual Basic, Visual FoxPro เป็นต้น
ดังนั้น ภาษาของคอมพิวเตอร์นั้นมีอยู่ด้วยกันมากมายหลายภาษา โดยแต่ละภาษาจะประกอบไปด้วย ส่วนประกอบต่างที่ๆ ที่คล้ายกัน แต่คุณสมบัติและวิธีการนำคำสั่งมาจัดเรียงกัน อาจจะแต่ต่างกันบ้างในแต่ละภาษา
ภาษาคอมพิวเตอร์ส่วนใหญ่สร้างขึ้นจาก บริษัทต่างๆ เพื่อประโยชน์ในเชิงธุรกิจ แต่ก็มีภาษาบางส่วนที่ คิดค้นขึ้นมาจากนักวิจัยหรือนักศึกษาที่มี ความสามารถในการคิดค้นภาษาใหม่ๆ ขึ้นมาก็ได้ การที่ภาษาคอมพิวเตอร์มีหลายภาษา เนื่องมาจากความสามารถ ของแต่ละภาษาไม่เหมือนกัน เช่น โปรแกรมเมอร์ A ได้สร้างภาษาขึ้นมาภาษาหนึ่ง ซึ่งมีความสามารถของการทำงานในระดับหนึ่ง แต่ โปรแกรมเมอร์ B อาจจะเห็นมาว่าไม่สามารถทำงานได้อย่างเต็มที่ จึงได้สร้างภาษา อื่นขึ้นมา โดยอาจจะดีกว่า (หรือไม่ก็ได้)

ข้อแตกต่างระหว่างภาษาระดับต่ำกับภาษาระดับสูง
ภาษาระดับต่ำจะมีความแตกต่างกันเมื่อใช้กับเครื่องคอมพิวเตอร์ต่างเครื่องกัน ส่วนภาษาระดับสูงนั้นสามารถใช้ได้กับ คอมพิวเตอร์ต่างเครื่องกัน โดยอาจมีการปรับปรับปรุง หรือ เปลี่ยนแปลงเพียงเล็กน้อยเท่านั้น
ภาษาระดับสูงมนุษย์สามารถอ่านเข้าใจได้ง่ายกว่าภาษาระดับต่ำ เพราะภาษาระดับสูงมีลักษณะคล้ายกับมนุษย์ที่ใช้ในชีวิตประจำวัน ส่วนภาษาระดับต่ำอาจใช้รหัสหรือคำย่อแทนคำสั่งให้ทำงาน
ภาษาระดับต่ำจะต้องเขียนขั้นตอนการทำงานอย่างละเอียด จึงใช้เวลาในการเขียนโปรแกรมมากกว่าการเขียนโปรแกรมระดับสูง
การเขียนโปรแกรมด้วยภาษาระดับต่ำ จำเป็นต้องศึกษาและเข้าใจระบบการทำงานภายในคอมพิวเตอร์ แต่การเขียนโปรแกรมด้วยภาษาระดับสูงไม่จำเป็นต้องศึกษาอย่างลึกซึ้ง
  1. ภาษาฟอร์แทรน (FORTRAN)
    ภาษาฟอร์แทรน (FORTRAN - FORmula TRANslation) จัดได้ว่าเป็นภาษาระดับสูงภาษาแรกของโลก พัฒนาในปี ค.ศ. 1954 โดยทีมนักคอมพิวเตอร์ บริษัท ไอบีเอ็ม (IBM) นำทีมโดย จอห์น แบคคัส (John Backus) โดยแนะนำออกมาสองรุ่น คือ FORTRAN II และ FORTRAN IV ต่อมาได้พัฒนาภาษา เป็นมาตรฐานรุ่นแรก เรียกว่า FORTRAN-66 อย่างไรก็ตาม ยังมีข้อบกพร่อง อีกหลายประการ เช่น ไม่สามารถกำหนดชนิดข้อมูล ไม่สามารถทำงานกับ ข้อมูลประเภทสายอักขระ และไม่มีคำสั่งที่สามารถกำหนด โครงสร้างได้เหมาะสม จึงมีการปรับปรุงแก้ไข และออกมาเป็น FORTRAN-77 และ FORTRAN-88 ซึ่งยังมีใช้จนถึงปัจจุบัน
  2. ภาษาโคบอล (COBOL)
    ภาษาโคบอล (COBOL : Common Business Oriented Language) เป็นภาษาสำหรับใช้ในงานธุรกิจภาษาแรกของโลก พัฒนาในปี 1962 โดยคณะกรรมการโคดาซิล (The Conference on Data Systems Languages - CODASYL) มีจุดเด่นคือ สามารถใช้งานแฟ้มข้อมูลได้หลายแบบ กำหนดโครงสร้างข้อมูลได้สะดวก มีลักษณะการเขียนโปรแกรม แบบเอกสารอธิบายโปรแกรม ช่วยให้ข้อมูลกับนักพัฒนารุ่นถัดไปได้ง่าย และสะดวก
  3. ภาษา ALGOL
    ภาษา ALGOL หรือ Algorithmic Language คิดค้นโดยกลุ่มนักคอมพิวเตอร์ ที่มาประชุมวิชาการ ที่ซูริค ในปี 1958 และออกเผยแพร่ปี 1960 มีคำสั่งกำหนดโครงสร้าง และชนิดข้อมูลอย่างสมบูรณ์ และมีการนำไปเป็นพื้นฐานในการออกแบบภาษารุ่นที่ 3 ที่นิยมกันอย่างมากในปัจจุบัน เช่น Pascal โดยภาษา ALGOL ที่เป็นมาตรฐาน ได้แก่ ALGOL-60 และ ALGOL-68
  4. ภาษา BASIC
    ภาษาเบสิค (BASIC: Beginner's All Purpose Symbolic Instruction Code) พัฒนาโดย จอห์น เคมเมนี (John Kemeny) และ ธอมัส เดิรตส์ (Thomas Kurtz) วิยาลัยดาร์ทเมิร์ท (Dartmouth College) ในปี ค.ศ. 1963
    จุดประสงค์ เพื่อใช้สอนวิชา การเขียนโปรแกรม และได้รับความนิยมอย่างสูง บนเครื่องไมโครคอมพิวเตอร์ โดยมีการนำมาทำเป็น ชุดคำสั่งถาวร (Firmware) เก็บไว้ใน ROM บนไมโครคอมพิวเตอร์รุ่นแรกๆ ปัจจุบันมีการพัฒนารูปแบบ และตัวแปรภาษาออกมาหลายรุ่น เช่น Quick BASIC, Turbo BASIC และยังได้รับความนิยมอยู่จนถึงปัจจุบัน เนื่องจากมักเป็นภาษาแรก ที่ใช้ในการเรียนการสอนวิชาคอมพิวเตอร์
  5. ภาษา PL/1
    ภาษา PL/I เป็นภาษาที่พัฒนาขึ้นโดยทีมงานของบริษัทไอบีเอ็ม ที่ตั้งใจจะรวมความสามารถของภาษา FORTRAN, ALGOL, COBOL เข้าด้วยกัน ดังนั้นจึงอาจกล่าวได้ว่า ภาษานี้เป็นภาษาแรกที่ทำงานได้กว้างขวางจริงๆ ทั้งทางด้านวิทยาศาสตร์ วิศวกรรม และธุรกิจ แต่ขณะเดียวกัน ก็ทำให้ตัวแปลภาษาใหญ่มาก จนไม่สามารถนำไปใช้กับเครื่องขนาดเล็กได้ ภาษานี้กำหนดรูปแบบ/ประเภทข้อมูลได้หลายแบบ ทำงานหลายงานพร้อมกันได้ (Multitasking) ทำงานกับอุปกรณ์รับส่งข้อมูล ที่ซับซ้อนได้ และประมวลรายการได้ (List Processing) แต่ภาษานี้ไม่เป็นที่ยอมรับมากนัก
  6. ภาษา Pascal
    ภาษาปาสกาล เป็นภาษาที่นิคลอส เวิร์ธ (Prof. Niklaus Wirth ปี ค.ศ. 1970) แห่งสถาบัน Swiss Federal Institute of Technology สร้างขึ้นเพื่อใช้ในการสอนเทคนิคใหม่ๆ ทางด้านการพัฒนาซอฟต์แวร์ ซึ่งก็คือ เทคนิคการโปรแกรมแบบโครงสร้าง และเป็นภาษาที่ได้รับ ความนิยมอย่างสูง ถึงขึ้นที่มีเสียงเรียกร้องให้นำภาษานี้ ไปบรรจุเป็นภาษาเริ่มต้น ในคอมพิวเตอร์ แทนภาษาเบสิค บริษัทบอร์แลนด์ จึงได้นำตัวแปลภาษาปาสกาล ไปทำเป็นตัวแปลภาษา ในรูปของ Turbo Pascal ซึ่งมีราคาถูก ซึ่งเป็นเหตุหนึ่ง ที่ช่วยให้ภาษานี้แพร่หลายมากขึ้น และได้รับความนิยมสูง อาจกล่าวได้ว่าภาษาปาสกาล เป็นลูกของภาษา ALGOL โดยตรง เพราะมีโครงสร้าง และลักษณะที่คล้ายกันมาก
  7. ภาษา Modula-2
    ภาษา Modula-2 เป็นภาษาที่นิคลอส เวิร์ธ ปรับปรุงจากภาษาปาสกาล โดยพยายามให้มีลักษณะที่ดีของภาษา สำหรับเขียนโปรแกรมมากขึ้น เช่น การทำให้มีการซ่อนสารสนเทศ (Information Hiding) หลักการนามธรรม (Abstraction) การกำหนดชนิดข้อมูล ซึ่งสามารถนำไปใช้กับการดำเนินงานแบบ Recursion และ Concurrency ได้ด้วย ปัจจุบันภาษานี้ไม่ได้รับความนิยมเท่าที่ควร
  8. ภาษา C
    ภาษา C พัฒนาโดยกลุ่มนักคอมพิวเตอร์จากห้องปฏิบัติการเบลล์ เพื่อใช้กับงานระบบ (System) เช่นการนำไปใช้เป็นระบบปฏิบัติการ Unix ซึ่งเป็นภาษาที่ได้รับความนิยมอย่างสูง ในปัจจุบัน เพราะมีลักษณะที่น่าสนใจอย่างประการ เช่น กำหนดชนิดข้อมูลได้หลายแบบ ทำงานในระบบเครื่องได้ สามารถใช้ตัวชี้ตำแหน่ง (Pointer) ได้ มีวิธีดำเนินการ และการคำนวณกับข้อมูลได้มากมายหลายแบบ
  9. ภาษา Ada
    ภาษา Ada พัฒนาขึ้นตามสัญญาว่าจ้างของกระทรวงกลาโหม สหรัฐอเมริกา ที่ต้องการได้ภาษาคอมพิวเตอร์ ที่สามารถใช้แทนภาษาอื่นๆ ที่หน่วยงานต่างๆ ภายในกระทรวงกำลังใช้อยู่ในขณะนั้นได้ ภาษานี้มีโครงสร้างคล้ายภาษาปาสกาล แต่ทำงานได้มากกว่า เช่น ทำงานหลายงานได้พร้อมกัน (Mustitasking) จัดการกับการขัดจังหวะได้ (Interrupt handling) จัดจังหวะการทำงานให้เข้ากัน (Intertask Synchronization) เป็นต้น ซึ่งนับว่าเป็นภาษาที่มากด้วย โครงสร้างแบบต่างๆ จึงมีขนาดใหญ่ด้วย
  10. ภาษา Lisp
    ภาษา Lisp (LISt Processing) เป็นภาษาที่นับได้ว่าเก่าแก่พอๆ กับภาษาฟอร์แทรน พัฒนาในปี 1950 โดย จอห์น แมคคาร์ธี (John McCarthy) สถาบันเทคโนโลยีแห่งแมสสาชูเสตต์ เหมาะสมกับงานประมวลสัญลักษณ์ หรือรายการต่างๆ ในปัญหาประเภท Combinatorial ซึ่งใช้ในงานปัญญาประดิษฐ์ เช่น การพิสูจน์ทฤษฏี การค้นหาข้อมูล ที่จัดโครงสร้างแบบต้นไม้ เป็นต้น ภาษานี้มีโปรแกรมย่อย ในรูปของฟังก์ชัน ที่มีลักษณะเป็นเอกเทศ สามารถนำมาทำเป็นคลังฟังก์ชันขนาดใหญ่ได้ และเป็นการเน้นหลักการ ด้านการนำกลับมาใช้ใหม่ได้เป็นอย่างดี ปัจจุบันมีการนำมาใช้ในการสร้าง ระบบผู้เชี่ยวชาญกันมาก เพราะลักษณะของภาษา เอื้ออำนวยต่อการใช้ระบุความจริง กฎเกณฑ์ และการอนุมานต่างๆ อันจำเป็นต่องานระบบอิงฐานความรู้
  11. ภาษา Prolog
    ภาษา Prolog (PROgramming in LOGic) เป็นอีกภาษาที่นิยมใช้ในการสร้างระบบผู้เชี่ยวชาญ (Artificial Intelligence) เพราะเหมาะสำหรับใช้แสดงความรู้ (Knowledge Representation) โดยนำความรู้มาเขียนในรูปของ อนุประโยค (Clause) ซึ่งเป็นภาษาคู่แข่งกับภาษา Lisp พัฒนาโดย Colmerauer แห่ง University of Marseilles ในปี 1970 จากนั้น Clocksin กับ Mellish จาก University of Edinburgh ได้นำมาพัฒนาเพื่อใช้งานต่อ
  12. ภาษา APL
    ภาษา APL (A Programming Language) เป็นภาษาระดับสูงที่คิดสร้างโดย เค. อี. ไอเออร์สัน (Ken Iverson) แห่งบริษัทไอบีเอ็ม เมื่อปี 1960 มีลักษณะแตกต่างจาก ภาษาคอมพิวเตอร์ภาษาอื่นอยู่มาก เช่น ใช้สัญลักษณ์แทนการทำงาน หรือการดำเนินการทางเลขคณิต และอักขระ ทำให้โปรแกรมมีขนาดกระทัดรัด จึงเป็นภาษาที่นิยมใช้แก้ปัญหาคณิตศาสตร์

The Basic Structure of a Compiler
+ img (http://courses.cs.vt.edu/~cs1104/Compilers/Compilers.020.html)
The five stages of a compiler combine to translate a high level language to a low level language, generally closer to that of the target computer. Each stage, or sub-process, fulfills a single task and has one or more classic techniques for implementation.
1. วิเคราะห์การสะกด (Lexical Analyzer) : Analyzes the Source Code Removes "white space" and comments Formats it for easy access (creates tokens) Tags language elements with type information Begins to fill in information in the SYMBOL TABLE **
2. วิเคราะห์โครงสร้างประโยค (Syntactic Analyzer) : Analyzes the Tokenized Code for structure Amalgamates symbols into syntactic groups Tags groups with type information
3. วิเคราะห์ความหมาย (Semantic Analyzer) : Analyzes the Parsed Code for meaning Fills in assumed or missing information Tags groups with meaning information
4. สร้างโปรแกรม (Code Generator) : Linearizes the Qualified Code and produces the equivalent Object Code
5. ตรวจสอบโปรแกรมที่สร้างขึ้น (Optimizer) : Examines the Object Code to determine whether there are more efficient means of execution

ประวัติภาษาคอมพิวเตอร์ (Computer Language History)
+ http://www.levenez.com/lang/
ภาพแสดงประวัติของภาษาในแต่ละปีกว่า 50 ภาษา

http://www.jeckle.de/images/softwe1/OOP-Historie.gif
http://www.jeckle.de/vorlesung/sei/kII.html

จุดประสงค์เบื้องต้นของเทคนิคโครงสร้าง (#ครรชิตวิชิต p.11)
1. เพื่อสร้างโปรแกรมที่มีคุณภาพสูง และสามารถทำนายได้ว่าจะเกิดอะไรขึ้นในโปรแกรม
2. เพื่อสร้างโปรแกรมที่แก้ไขดัดแปลงง่าย
3. เพื่อทำให้ขั้นตอนการพัฒนาโปรแกรมเป็นระบบขึ้น และง่ายขึ้น
4. เพื่อทำให้การพัฒนาระบบรวดเร็ว และประหยัด

กิจกรรมการประมวลผลข้อมูล (#นงนุช p.26)
ส่วนนำเข้า (Input)
- การรวบรวมข้อมูล (Collection)
- การบันทึกข้อมูล
- การสอบทานข้อมูล
ส่วนดำเนินการ (Process)
- การเรียงลำดับ (Sorting)
- การจัดหมวดหมู่ (Classification)
- การคัดเลือก (Selection)
- การคำนวณ (Calculation)
- การสรุปผล (Summarization)
- การปรับปรุงข้อมูล (Updating)
ส่วนนำออก (Output)
- การทำรายงาน (Reporting)
- การจัดเก็บข้อมูล (Storing)

วัฏจักรซอฟต์แวร์ (Software life cycle) (#ครรชิตวิชิต p.30)
1. วิเคราะห์หาข้อกำหนดโปรแกรม (Analysis)
2. ออกแบบ (Design)
3. เขียนคำสั่ง (Implementation)
4. ทดสอบ (Testing)
5. บำรุงรักษา (Maintainance)
+ http://web-site-development-solutions.blogspot.com

วิธีการแสดงแบบซอฟต์แวร์ (#ครรชิตวิชิต p.39)
1. การพิมพ์โปรแกรมต้นฉบับ (Source listing)
2. ผังงาน (Flowchart)
3. ผังงานโปรแกรมโครงสร้าง (Structure flowchart)
4. ผังงานแบบ Nassi-Shneiderman
5. HIPO (Hierarchy plus input-process-output)
6. ผังงานแจ็คสัน (Jackson diagram)
7. ผังงานแบบวาร์นิแอร์-ออร์ (Warnier-Orr diagram)
8. ผังงานโครงสร้าง (Structure chart)
9. คำสั่งลำลอง (Pseudo code)
10. ตารางการตัดสินใจ (Decision table)

Optimization problems are made up of three basic ingredients:

An objective function which we want to minimize or maximize. For instance, in a manufacturing process, we might want to maximize the profit or minimize the cost. In fitting experimental data to a user-defined model, we might minimize the total deviation of observed data from predictions based on the model. In designing an automobile panel, we might want to maximize the strength.
A set of unknowns or variables which affect the value of the objective function. In the manufacturing problem, the variables might include the amounts of different resources used or the time spent on each activity. In fitting-the-data problem, the unknowns are the parameters that define the model. In the panel design problem, the variables used define the shape and dimensions of the panel.
A set of constraints that allow the unknowns to take on certain values but exclude others. For the manufacturing problem, it does not make sense to spend a negative amount of time on any activity, so we constrain all the "time" variables to be non-negative. In the panel design problem, we would probably want to limit the weight of the product and to constrain its shape.
ขอบซ้ายขอบบน
ภาคผนวก (Appendix)
แนะนำเว็บ (Web Guides)
  1. http://developer.mozilla.org/en/docs/Build_Documentation คำแนะนำการ compile mozilla
  2. ตัวอย่างการใช้ menu, toolbars + contructor ของ jcheckboxmenuitem
  3. อธิบายที่มาของ swing ได้ดีมาก ตัวอย่าง code และสารบัญจากหนังสือ มีให้ download
  4. Code เกี่ยวกับ Swing
  5. อธิบาย Java2D ได้ละเอียดมาก มีข้อมูลเรื่อง swing
  6. สอน JAVA เป็นภาษาอังกฤษได้ค่อนข้างสมบูรณ์
  7. Java API document : references
  8. เครื่องหมายปฏิบัติการ (Operation sign) โดย jana.net
  9. อธิบาย Array โดย jana.net
  10. Java lobby มีข้อมูล และเรื่องราวเกี่ยวกับ JAVA
  11. สอน Java (.pdf) โดย สุรเวช อึ้งประเสริฐ (รามคำแหง)
  12. แผนการสอน OOP วิทยาลัยปทุมธานี คณะ บริหารธุรกิจ : อ. ศิลา ชุณห์วิจิตรา
  13. ตัวอย่าง OOP ด้วยภาษา PHP โดย อ.ทองจุล ขันขาว
  14. วิชาโครงสร้างข้อมูล ของ มหาวิทยาลัยศรีนครินทรวิโรฒ (Uni.net.th)
  15. ข้อมูลเรื่อง Computer ละเอียดมาก ๆ มีหัวข้อประมาณ 100 หัวข้อ
  16. Software คืออะไร
  17. ภาษาคอมพิวเตอร์
  18. สอนเขียน COBOl ละเอียดมาก
  19. ข่าวเกี่ยวกับ Microsoft .net
  20. HTMl คืออะไร
  21. Glossary
  22. Java optimazation
  23. Global optimization
  24. Optimization technology center มีภาพเกี่ยวกับ Global optimization และอื่น ๆ
  25. What is optimization?
  26. Automatic Programming (แผนการสอนนิดหน่อย เรื่อง Optimization and OOP)
  27. OOP fundamentals By Jim Booth มีรายละเอียดสมบูรณ์ (Sample by VisualFoxpro)
  28. กระดานข่าวเกี่ยวกับ OOP เป็นภาษาไทย โดย narisa.com
  29. เรื่องราวของ Visualstudio.net โดย รังสรรค์ พลเสน (รามคำแหง)
  30. Compiler subject :: http://www.ashland.edu/~sgray/compilers/ch1.html [img]
  31. Compiler building :: http://compilers.iecc.com/crenshaw/
  32. Compiler generlators :: http://www.scifac.ru.ac.za/compilers/
  33. Programming language :: http://www.engin.umd.umich.edu/CIS/course.des/cis400.html **
  34. Programming language :: http://www.stanford.edu/class/cs242/slides/index.html (Slide in PPT)
  35. Introduction to programming I :: http://vu.msu.edu/preview/cse231/
  36. Programming language :: http://people.cs.uchicago.edu/~odonnell/OData/Courses/CS221/Lecture-Notes/contents.html
  37. Programming language concept :: http://www.math.grin.edu/~stone/courses/languages/
  38. Vocabulary :: http://www.stanford.edu/class/cs242/readings/vocabulary.html

คำอธิบายรายวิชา (Course Description)
CPSC 218 การเขียนโปรแกรมเชิงวัตถุ (Object-Oriented Programming)
การเขียนโรปแกรมเชิงวัตถุเบื้องต้น การวิเคราะห์โครงสร้างของโปรแกรมเชิงวัตถุ เทคนิคเบื้องต้นของการออกแบบซอฟต์แวร์ ฟังก์ชันการออกแบบเชิงวัตถุขั้นพื้นฐาน การออกแบบโปรแกรมเชิงวัตถุ โปรแกรมตัวอย่าง และการฝึกปฏิบัติในห้องปฏิบัติการ

CPSC 214 หลักการภาษาชุดคำสั่ง (Principles of Programming Languages)
ทฤษฎีของการออกแบบ และสร้างภาษา แนวคิดเกี่ยวกับภาษาฟอร์มัล รูปแบบ และคุณลักษณะทางไวยากรณ์เบื้องต้น ชนิด และโครงสร้างของข้อมูล โครงสร้างของการควบคุม และการเคลื่อนที่ของข้อมูล การพิจารณาเวลาในการประมวลผล อัลกอริทึมแบบขนาน การออพติไมซ์ การออกแบบ และสร้างลักษณะต่าง ๆ ของภาษา ลักษณะเฉพาะของภาษาแบบโครงสร้างบล๊อก แบบมอดูลาร์ แบบเชิงวัตถุ ประเภทของภาษาชุดคำสั่ง แบบกำหนดกระบวนการ และแบบไม่กำหนดกระบวนการ การวิเคราะห์ประโยคคำสั่งของภาษาคอมพิวเตอร์ ฝึกปฏิบัติการเขียน และทดสอบโปรแกรมด้วยภาษาปาสคาล ภาษาซี หรือภาษาระดับสูงอื่น ๆ

CPSC 213 โครงสร้างคอมพิวเตอร์ และภาษาแอสเซมบลี้ (Computer Organization and Assembly Language)
ระบบตัวเลขที่ใช้แทนข้อมูลและคำสั่งในเครื่องคอมพิวเตอร์ โครงสร้างระบบและภาษาเครื่อง หน่วยประมวลผลและหน่วยความจำ แบบจำลองของเครื่อง โปรแกรมภาษาแอสเซมบลี้ การทำงานกับโปรแกรมควบคุมระบบ อุปกรณ์ตรรกโปรซีเตอร์สำหรับอ่าน/เขียนข้อมูล ระบบแฟ้มข้อมูลเบื้องต้น การใช้บัฟเฟอร์หลายอัน รูปแบบและชนิดของคำสั่ง ภาษาแมคโครแอสเซมบลี้ การเชื่อมโยงส่วนจำเพาะ (Module linking) พื้นฐานของโปรแกรมควบคุมระบบ เช่น การจัดจังหวะประสาน มัลติโปรแกรมมิ่ง เทคนิคหน่วยความจำเสมือน

CPSC 211 วิทยาการคอมพิวเตอร์ (Computer Science)
หลักการเขียนโปรแกรมแบบโครงสร้าง หลักการออกแบบโปรแกรม การแทนข้อมูลแบบต่าง ๆ นิพจน์โครงสร้างแบบบล็อก แถวลำดับ ฟังก์ชัน และโปรแกรมย่อย โครงสร้าง และการประมวลผลแฟ้มข้อมูลแบบต่าง ๆ โครงสร้างข้อมูลเบื้องต้น การเรียกซ้ำ การเรียงลำดับ การค้นหา และการผสานข้อมูล ฝึกปฏิบัติการเขียน และทดสอบโปรแกรมด้วยภาษาปาสคาล ภาษาซี หรือภาษาระดับสูงอื่น ๆ

CPSC 101 ความรู้เบื้องต้นเกี่ยวกับโปรแกรมคอมพิวเตอร์ (Introduction to Computer Programming)
องค์ประกอบ และการทำงานของเครื่องคอมพิวเตอร์ ตรรก และการแก้ปัญหา ข้อมูล และรหัสที่ใช้แทนข้อมูลศึกษาพื้นฐานหลักการเขียนโปรแกรม การวิเคราะห์งาน การเขียนผังงาน การเขียนโปรแกรม และการนำเสนอการทดสอบโปรแกรม สภาพการผิดพลาดของโปรแกรม การบันทึก และการประมวลผลแฟ้มข้อมูลเบื้องต้น ฝึกปฏิบัติการเขียน และทดสอบโปรแกรมด้วยภาษาปาสคาล ภาษาซี หรือภาษาระดับสูงอื่น ๆ
หนังสืออ้างอิง (Book Referenced)
  1. การเขียนโปรแกรมเชิงวัตถุ , ผศ.ธวัชชัย งามสันติวงศ์, 2545 (#ธวัชชัย)
  2. การเขียนโปรแกรมเชิงวัตถุภาษาจาวา, ชุลีรัตน์ จรัสกุลชัย, 2543 (#ชุลีรัตน์)
  3. Java programming volume 1, ดร.วีระศักดิ์ ซึงถาวร, 2543 (#วีระศักดิ์)
  4. คัมภีร์ JAVA เล่ม 2, ณัฐดนัย สุขรัตน์, 2543 (#ณัฐดนัย)
  5. เทคนิคการออกแบบโปรแกรม , ดร.ครรชิต มาลัยวงศ์ และวิชิต ปุณวัตร์ (#ครรชิตวิชิต)
  6. การโปรแกรมแบบโอโอพี ด้วยเทอร์โบปาสคาล , บุญเลิศ เอี่ยมทัศนา (#บุญเลิศ)
  7. หลักการเขียนโปรแกรม , นงนุช วรรธนวหะ (#นงนุช กระทรวงศึกษาธิการ)
  8. โครงสร้างข้อมูล และอัลกอริทึม , ประกาศิต ชาติบุรุษ และอาทิตย์ จิตต์จุฬานนท์ (#ประกาศิต)
  9. หนทางสู่อาชีพนักคอมพิวเตอร์ , ครรชิต มาลัยวงศ์ (#ครรชิต)
  10. Concepts of programming languages, Rober W. Sebesta, 5th edition. (#robert)
  11. Programming by design, Philip L. Miller (#philip)
  12. Structured programming concepts, Keith LaBudde (#keith)
  13. Database system concepts, Korth Silberschatz (#korth)
  14. Introduction to Computer science [An algorithmic approach] , Jean-paul Tremblay (#jean)
  15. Data abstraction and problem solving with JAVA , Fank M. Carrano and Janet J. Prichard (#frank)
Technical Term
  1. Parse : แยก
  2. Primitive : type พื้นฐาน
  3. Simplicity : ง่าย
  4. Synthesis : การประกอบสิ่งต่าง ๆ ขึ้นเป็นรูปร่าง
  5. Contemporary : รุ่นเดียวกัน
  6. Abstract : รายการย่อ
  7. Implementation : ลงมือปฏิบัติ
  8. Lexicon : พจนานุกรม
  9. Syntax : ความสัมพันธ์ระหว่างถ้อยคำ หรือโครงสร้างประโยค
  10. Amalgamate : การรวม การผสาน
  11. Semantic : ความเกี่ยวข้องในความหมาย
  12. Equivalent : สมดุล เท่ากัน
  13. Semantic : ความหมาย หรือเกี่ยวกับ
  14. Bunch : พวง
  15. Particular : โดยเฉพาะ
  16. Swing : ส่วนสนับสนุน GUI เป็นส่วนหนึ่งขอ JFC (Java Foundation Class) ที่ขยายความสามารถของ AWT
  17. โปรแกรมคอมพิวเตอร์ (Computer Program) :: ชุดของคำสั่งภาษาคอมพิวเตอร์ที่กำหนดให้คอมพิวเตอร์ทำการประมวลผล ให้ได้ผลลัพธ์ตามความต้องการของผู้ใช้
"Imagination is more important than knowledge" - Albert Einstein
Home
Thaiabc.com
Thainame.net
Lampang.net
Nation university
PHP
MySQL
Visual basic.NET
TabletPC
Linux
Online quiz
Download
Search engine
Web ranking
Add website
Blog : Education
Blog : ACLA
Blog : Lampang
Facebook.com
Twitter.com
About us
My dream
Site map
Sponsor
http://goo.gl/72BPC