[Bao cao]tim hieu ve mo hinh lap trinh

Trường Đại Học Bách Khoa Hà Nội
2012-2013
BÁO CÁO
TÌM HIỂU VỀ CÁC MÔ HÌNH LẬP TRÌNH
Môn học:Kỹ Thuật Lập Trình
Giảng viên:Vũ Đức Vượng
Email:vuongvd@gmail.com
Mã lớp:54470
Người thực hiện
Sinh viên:Trần Xuân Quý
MSSV:20112030
Email:xuanquytxq@gmail.com
Báo cáo:Tìm hiểu về các mô hình lập trình 1

MỤC LỤC
I.Lời nói đầu........................................................................................................................ 2
II. Tổng quan về các mô hình lập trình phổ biến.......................................................... 2
1. Functional Paradigm…….............................................................................................. 2
2. Visual Paradigm……...................................................................................................... 3
2.1 Đặc điểm nổi bật của phương pháp lập trình trực quan ......................................... 4
3. Parallel Programming .................................................................................................. 5
3.1 Quá trình song song hóa gồm ba giai đoạn bước chính .......................................... 5
4. Distributed Programming ............................................................................................ 6
5. Extreme Programming ................................................................................................... 7
5.1 Ưu Điểm ........................................................................................................................ 7
5.2 Phương thức tiến hành XP ......................................................................................... 7
6. Concurrent Programming ............................................................................................ 8
6.1 Đặc điểm ....................................................................................................................... 8
III. Logic programming...................................................................................................... 8
1. Đặc điểm ......................................................................................................................... 8
2. Ngôn ngữ PROLOG .................................................................................................... 9
2.1 Giới thiệu...................................................................................................................... 9
2.2 Các yếu tố cơ bản của Turbo Prolog ........................................................................ 9
2.3 Cấu trúc của một chương trình Prolog .................................................................... 10
2.4 Các nguyên tắc của ngôn ngữ Prolog ....................................................................... 13
2.5 Bộ ký tự, từ khoá ....................................................................................................... 13
2.6 Các kiểu dữ liệu .......................................................................................................... 14
2.7 Các hàm xuất nhập chuẩn ......................................................................................... 17
2.8 Kỹ thuật đệ quy ........................................................................................................... 17
2.9 Một số ví dụ về chương trình prolog ....................................................................... 19
IV. Lời kết ......................................................................................................................... 20
V. Tài liệu tham khảo ........................................................................................................ 21

I.Lời nói đầu
Bất kỳ một ngôn ngữ lập trình nào cũng đều mang tính logic cao và tuân theo những quy
chuẩn cơ bản về toán học. Tuy vậy, mỗi ngôn ngữ lại có những phương thức riêng để thực hiện
những quy chuẩn đó, đặc biệt là trên các lĩnh vực như hàm (function), biến (variable), phương
thức (method) và đối tượng (object). Bên cạnh sự đa dạng của ngôn ngữ lập trình, cũng dần có
rất nhiều mô hình lập trình được ra đời, trong đó phổ biến nhất có thể kể đến như: Lập trình
hướng đối tượng (object-oriented programming), lập trình thủ tục (procedural programming) và
lập trình cấu trúc (structured programming). Mỗi một mô hình lập trình lại có những đặc trưng
riêng về cách sử dụng cũng như tính trừu tượng hóa đối với các quá trình xác định.
Ở thời kỳ đầu, công nghệ phần mềm hoàn toàn dựa trên những thao tác lập trình bằng mã
nhị phân hoặc mã máy, mà đại diện là các giá trị 0 và 1. Điều này khiến cho quá trình thiết kế,
kiểm soát sự hoạt động cũng như sửa lỗi đối với một ứng dụng trở nên vô cùng rắc rối và không
hiệu quả. Chúng ta coi những phương thức lập trình ở thời điểm này thuộc mô hình lập trình bậc
thấp (low-level programming paradigm). Về sau, cùng với sự phát triển của công nghệ, những
hạn chế của giai đoạn đầu tiên dần được xóa bỏ với sự ra đời của các ngôn ngữ lập trình thế hệ
thứ 3 là COBOL, Fortran và BASIC, đồng thời, một mô hình lập trình mới cũng xuất hiện và vẫn
tiếp tục được sử dụng hiệu quả và phổ biến cho đến ngày nay, đó là mô hình lập trình thủ tục
(procedural paradigm). Dần dần, chúng ta chứng kiến sự phát triển mạnh mẽ về số lượng của các
mô hình lập trình, mà cơ bản có thể kể đến các mô hình sau:
• Lập trình cấu trúc - Structured programming.
• Lập trình mệnh lệnh - Imperative programming.
• Lập trình truyền báo - Message passing programming.
• Lập trình thủ tục - Procedural programming.
• Lập trình chức năng - Functional programming.
• Lập trình trực quan - Visual programming.
• Lập trình song song - Parallel programming.
• Lập trình phân tán - Distributed programming.
• Lập trình tương tranh - Concurrent programming.
• Lập trình bậc giá trị - Value-level programming.
• Lập trình điều khiển theo luồng - Flow-driven programming.
II.Tổng quan về các mô hình lập trình phổ biến
1. Functional Programming
• Nguyên lý và ý tưởng: Toán học và lý thuyết về hàm.
• Các giá trị đã được tạo là không thể biến đổi.
• Trừu tượng hóa một biểu thức thành một hàm và ngược lại, một hàm có thể được tính
toán như một biểu thức.
• Hàm là lớp giá trị đầu tiên.
• Hàm là những giá trị hoàn chỉnh, tương tự như số, danh sách...
• Thích hợp với nh ững tính toán theo yêu cầu.

• Mở ra những khả năng mới.
Functional Programming là thể loại lâu đời nhất trong ba paradigm lập trình chính. Ngôn ngữ
FP đầu tiên là IFP, được phát minh vào năm 1955, một năm trước khi có Fortran. Sau đó,
LISP ra đời năm 1958, một năm trước khi có COBOL. Cả Fortran và COBOL đều là những
ngôn ngữ imperative (hay còn gọi là procedural). Chúng đặc biệt thành công khi được ứng
dụng vào tính toán khoa học và nghiệp vụ, và trở thành paradigm thống trị trong suốt 30 đ ầu
của kỉ nguyên thông tin.
Ví dụ
Với n = 5, ta có th ứ tự tính toán của đoạn chương trình trên như sau:
giai_thua(5)
= 5 * giai_thua(4)
= 5 * 4 * giai_thua(3)
= 5 * 4 * 3 * giai_thua(2)
= 5 * 4 * 3 * 2 * giai_thua(1)
= 5 * 4 * 3 * 2 * 1
= 5 * 4 * 3 * 2
= 5 * 4 * 6
= 5 * 24
= 120
2. Visual Paradigm
int giai_thua(int n)
{
if (n == 1)
{
return n;
}
else
{
return n * giai_thua(n - 1);
}
}

Như chúng ta đã biết, mỗi loại máy tính (sử dụng loại CPU – Central Processing Unit xác định)
chỉ có thểhiểu và thực hiện trực tiếp được các lệnh cũng như chương trình theo một loại ngôn
ngữ dành riêng được gọi là ngôn ngữ máy. Tuy nhiên, nếu triển khai các ứng dụng trong thực tế
mà phải viết chương trình trực tiếp bằng ngôn ngữ máy thì sẽ rất ph ức tạp, đòi hỏi thời gian và
công sức rất lớn, nhiều khi không thể thực hiện được. Vì vậy, người ta tìm cách xây dựng một
ngôn ngữ lập trình riêng gần với các ngôn ngữ tự nhiên, thuận lợi cho việc triển khai các ứng
dụng. Khi thực hiện các chương trình bằng ngôn ngữ này phải qua một bước dịch chương trình
đó sang ngôn ngữ máy để nó có thể thực hiện. Từ trước đến nay có rất nhiều ngôn ngữ lập trình
được ra đời và phục vụ đắc lực cho việc triển khai các ứng dụng trên máy tính.
Trong giai đoạn đầu, các ngôn ngữ lập trình tuy dễ sử dụng hơn ngôn ngữ máy nhưng rất khó
với các lập trình viên vì chưa đủ mạnh để dễ dàng triển khai các thuật toán. Chương trình chưa
có tính cấu trúc chặt chẽ về mặt dữ liệu cũng như tổ chức chương trình. Vì vậy, việc triển khai
các ứng dụng trong thực tế bằng các ngôn ngữ lập trình này là rất khó khăn.
Giai đoạn 2 là thời kỳ của các ngôn ngữ lập trình có cấu trúc. Các ngôn ngữ lập trình này có
đặc điểm là có tính cấu trúc chặt chẽ về mặt dữ liệu và tổ chức chương trình. Một loạt các ngôn
ngữ l ập trình có cấu trúc ra đời và dược sử dụng rộng rãi như : PASCAL, C, BASIC...
Giai đoạn 3 là thời kỳ của lập trình hướng đối tượng và phương pháp lập trình có bước biến
đổi mạnh. Trong các ngôn ngữ l ập trình có cấu trúc thì một ứng dụng bao gồm hai thành phần
riêng là dữ liệu và chương trình. Tuy chúng có quan hệ chặt chẽ nhưng là hai đối tượng riêng
biệt. Trong phương pháp lập trình hướng đối tượng thì mỗi một đối tượng lập trình sẽ bao hàm
cả dữ liệu và phương thức hành động trên dữ liệu đó. Vì vậy, việc lập trình sẽ đơn giản và mang
tính kế thừa cao, tiết kiệm được thời gian lập trình.
Tuy nhiên, với các phương pháp lập trình trên đều đòi hỏi lập trình viên phải nhớ rất nhiều câu
lệnh với mỗi lệnh có một cú pháp và tác dụng riêng, khi viết chương trình phải tự lắp nối các
lệnh để có một chương trình giải quyết từng bài toán riêng biệt.Trong xu hướng phát triển mạnh
mẽ hiện nay của tin học, số người sử dụng máy tính tăng lên rất nhanh và máy tính được sử dụng
trong hầu hết các lĩnh vực của đời sống nên đòi hỏi các ngôn ngữ lập trình cũng phải đơn gi ản,
dễ sử dụng và mang tính đại chúng c ao. Chính vì vậy phương pháp lập trình trực quan ra đời.
Đặc điểm của các ngôn ngữ lập trình trực quan là dễ sử dụng, triển khai các ứng dụng một cách
nhanh chóng.
2.1. Đặc điểm nổi bật của phương pháp lập trình trực quan
• Cho phép xây dựng chương trình theo hướng sự kiện (Event-Driven Programming, nghĩa
là một chương trình ứng dụng được viết theo kiểu này đáp ứng dựa theo tình huống xảy
ra lúc thực hiện chương trình. Tình huống này bao gồm người s ử dụng ấn một phím
tương ứng, chọn lựa một nút lệnh hoặc gọi một lệnh từ một ứng dụng khác chạy song
song cùng lúc.
• Người lập trình trực tiếp tạo ra các khung giao diện (interface), ứng dụng thông qua các
thao tác trên màn hình dựa vào các đối tượng (ojbect) như hộp hội thoại hoặc nút điều
khiển (control button), những đối tượng này mang các thuộc tính (properties) riêng biệt
như : màu sắc, Font chữ.. mà ta chỉ cần chọn lựa trên một danh sách cho sẵn.
• Khi dùng các ngôn ngữ lập trình trực quan ta rất ít khi phải tự viết các lệnh, tổ chức
chương trình... một cách rắc rối mà chỉ cần khai báo việc gì cần làm khi một tình huống
xuất hiện.
• Máy tính sẽ dựa vào phần thiết kế và khai báo của lập trình viên để tự động tạo lập
chương trình.

Như vậy với k ỹ thuật lập trình trực quan, lập trình viên giống như một nhà thiết kế, tổ chức để
tạo ra các biểu mẫu, đề nghị các công việc cần thực hiện và máy tính sẽ dựa vào đó để xây dựng
chương trình. Hiện nay các ngôn ngữ l ập trình, hệ quản trị cơ sở dữ liệu theo hướng trực quan
thường dùng như: Visual Basic, Visual Foxpro, Visual C, Delphi...
3. Parallel Programming
Tính toán song song (Parallel Computing) là việc chia một công việc ra thành các công việc
nhỏ và cho các công việc này thực hiện đồng thời với nhau bởi các hệ thống có nhiều bộ vi xử lý
(multiprocessor) hay bộ vi xử lý đa nhân (multicore) nhằm giảm thời gian thực hiện công việc đó
xuống. Việc lập trình để tách ra các công việc nhỏ và sắp xếp để xử lý song song thì được gọi là
lập trình song song.
“Số lượng transistor trong bộ vi xử lý sẽ tăng lên gấp đôi sau mỗi 24 tháng.” Gordon Moore -
sáng lập viên của tập đoàn Intel.

Cùng với định luật Moore, các máy tính hiện nay đã được trang bị các bộ vi xử lý đa nhân
mạnh mẽ. Tuy nhiên, để tận dụng được sức mạnh đó đòi hỏi các lập trình viên phải tận dụng
được hết các nhân trong bộ vi xử lý. Vì vậy, thay vì lập trình tuần tự như trước đây chỉ sử dụng
một nhân của bộ vi xử lý thì người lập trình viên ngày nay phải dùng kỹ thuật lập trình song song
để tận dụng hiệu suất của bộ vi xử lý đa nhân.
Bộ vi xử lý có nhiều nhân sẽ tăng tốc chương trình song song tuy nhiên không có nghĩa là nó sẽ
tăng lên 100% trên một nhân (core) được thêm vào. Thậm chí chương trình song song không hề
tăng hiệu suất lên trong một số trường hợp. Vì vậy lập trình viên phải biết quyết định khi nào sử
dụng lập trình song song bằng cách sử dụng các công cụ đo lường để xác định được tốc độ thực
thi của chương trình.
Lập trình song song là một công việc rất phức tạp so với lập trình tuần tự thông thường, người
phát triển phải thực hiện một quá trình “song song hóa”, biến đổi các chương trình tuần tự thành
chương trình song song có khả năng tận dụng tối đa sức mạnh của hệ thống.
3.1. Quá trình song song hóa gồm ba giai đoạn bước chính
 Phân chia chương trình thành các công việc con (Sub-task decomposition).
 Phân tích sự phụ thuộc (Dependence analysic).
 Định thời các công việc (Task scheduling).
4. Distributed Programming
Lập trình phân tán là một dạng của lập trình song song (tính toán song song). Lập trình song
song tạo ra mối liên hệ giữa máy tính và các đơn vị tính toán, khiến chúng hoạt động đồng thời
đối với một vấn đề cụ thể (dự báo thời tiết chẳng hạn). Các đơn vị tính toán có thể đặt rất gần
nhau hoặc tách rời nhau. Khi các đơn vị tính toán được đặt tách rời, ta gọi đó là lập trình phân
tán. Với mô hình lập trình này, các đơn vị tính toán thường rất khác nhau, cũng như sự khác
nhau giữa các hệ điều hành và thiết lập mạng máy tính. Những yếu tố đó khiến cho việc lập trình
các tính toán của máy tính trở nên tương đối phức tạp và khó khăn.
Lập trình mạng phân tán, thường có 2 khái niệm chính: peer to peer và client - server... peer to
peer là lập trình ngang hàng giữa 2 máy tính... còn lập trình client - server là lập trình cho phép n
máy client kết nối tới m máy server - đây cũng là mô hình chúng ta sẽ gặp nhiều trong thực tế …
Có thể chia lập trình mạng thành 3 cấp độ, căn cứ theo mức độ thân thiện với developer và khả
năng triển khai:
• Mức thấp nhất là lập trình sử dụng socket - có thể truyền từng byte, từng stream lên trên
mạng, ứng dụng này thường gặp trong các ứng dụng mạng cỡ nhỏ (vd: trong 2 máy tính,
trong 1 mạng LAN...).
• Mức cao hơn là lập trình sử dụng, triển khai ứng dụng theo mô hình dịch vụ (service) -
quản lí mạng theo mô hình: kết nối, tạo tham chiếu client trên server và trả về, gọi hàm
và truyền dữ liệu thông qua proxy của đối tượng trả về từ server (vd: RMI trên Java hay
Remoting trên.NET...), mô hình này thường gặp trong các ứng dụng mạng cỡ trung bình
và lớn, đòi hỏi tính performance cao (vd: các ứng dụng mạng đòi hỏi kết nối nhiều - liên
tục và sử dụng diện rộng như các dịch vụ chat, game online...), ưu điểm chính của mô
hình này là tính performance cao, bảo mật, nhưng nhược điểm là tính đa nền
(multiplatform) và tính khả chuyển chưa cao (server và client phải cùng 1 công nghệ phát
triển.)

• Mức cao nhất là triển khai ứng dụng theo mô hình triển khai trên web, điển hình nhất ta
có thể thấy là các web application và web service, mới nhất giờ có công nghệ WCF của
M$ (tổng hợp tất cả trong 1)... mô hình này cho phép triển khai trên diện rộng, phục vụ
lượng khách hàng lớn... nhưng cũng có nhược điểm là tính performance chưa cao, bù lai,
nó có khả năng mềm dẻo (flexibility) cao (server và client không cần sử dụng chung một
công nghệ). Chúng ta thường thấy những ứng dụng loại này trong các ứng dụng được
cung cấp từ một nhà cung cấp nào đó (vd: các số liệu chứng khoán, thời tiết …).
5. Extreme Programming
Lập trình cực độ (eXtreme Programming viết tắt là XP) là một trong những nhóm các phương
pháp phát triển phần mềm một cách linh hoạt. XP sử dụng các nhóm làm việc kết hợp gồm
những người lập trình, khách hàng và các nhà quản trị để phát triển phần mềm có chất lượng cao
trong thời gian nhanh chóng. Một chương trình chạy được là thước đo đầu tiên của tiến trình theo
XP. XP có thể phát triển và tồn tại được là do sự hiểu biết ngày một tiến bộ về các vấn đề đang
giải quyết và cũng là vì các công cụ sẵn có cho phép ta thay đổi được cái giá của sự thay đổi
(cost-of-change) ( đang là dạng hàm mũ trước đây ). XP giữ cho cái giá phải trả này ở mức thấp
do vậy sẽ thúc đẩy môi trường sản xuất phần mềm.
5.1. Ưu Điểm
Như ta đã biết hầu hết các phương pháp đều xem xét việc phát triển phần mềm như là một quy
trình gia công với tiến trình viết phần mềm đi theo một con đường:
Nhu cầu (thị trường) – Phân tích – Thiết kế – Viết code – Thử nghiệm – Bảo trì.
Cách tiếp cận này có một sự thừa nhận quan trọng đó là ta đã biết được sản phẩm cuối cùng
trước khi tiến trình bắt đầu. Nhưng hầu hết các dự án phần mềm hiện đại không thể thoả mãn cái
sự thừa nhận này. Khách hàng sẽ đưa ra một cách đầy đủ những cái gì mới và người sản xuất cần
những thông tin phản hồi một cách liên tục để đánh giá lại các lựa chọn của họ. Người lập trình
cần phải có một phương án để luôn sẵn sàng đón nhận những thay đổi trong Nhu cầu để họ có
thể đối phó được với các thông tin phản hồi. Nếu bạn làmviệc trong một môi trường mà ở đó các
Nhu cầu được chờ để thay đổi và các khách hàng sẽ được lợi từ việc bàn giao phần mềm sớm và
thường xuyên thì chắc chắn nên xem xét XP. Các nhóm làm theo XP sẽ thường xuyên nhận ra
rằng họ đang bàn giao các sản phẩm phần mềm chất lượng cao với số lượng rất lớn và nhanh
hơn trước đây rất nhiều.
5.2. Phương thức tiến hành XP
XP là một phương pháp có khả năng thích nghi, thích ứng. Điều đó có nghĩa là sẽ không có hai
dự án XP nào giống nhau cả. XP cung cấp một tập hợp các thực hành và được sử dụng như là
điểm khởi đầu, và sau đó được làm cho thích ứng để phù hợp với các ràng buộc của từng dự án
riêng. Sau đây là một tập hợp các nguyên tắc được mong đợi:
• Liên lạc: một XP team lớn mạnh dựa trên các kiến thức, sự hiểu biết bài toán và hiểu biết
phần mềm được chia sẻ. Các phương pháp giải quyết vấn đề được trao đổi trực tiếp.
Những thứ cản trở đến công việc đều được loại bỏ.
• Đơn giản hoá: công việc cần giảm tối thiểu độ phức tạp để đạt được hiệu quả cao nhất.

• Thông tin phản hồi thường các đội làm dự án và khách hàng của họ không nhận ra những
vấn đề rắc rối cho tới khi sắp bàn giao sản phẩm. Nhưng các XP teams thường xuyên lấy
feedback – trong quá trình làm việc, test, bàn giao sản phẩm… Khi đó sẽ control được
các vấn đề phát sinh.
• Thế mạnh: các đội làm phần mềm thành công cần phải kiểm soát được ngay cả khi xuất
hiện các lỗi. XP đưa ra 12 phương án thực hành, và điểm mạnh của XP chính là đã kết
hợp được các phương án này lại. Mỗi một phương án tuy đơn giản nhưng rất cần thiết
phải nắm vững, sẽ góp phần làm giảm bớt đáng kể cái giá của sự thay đổi.
6. Concurrent Programming
Lập trình tương tranh là một trong những kỹ thuật quan trọng và cũng là một thách thức. Một
mặt, nó đem lại khả năng sử dụng hiệu quả cho những hệ thống song song và phân tán. Mặt
khác, những rủi ro trong việc tương tác giữa các tiến trình thực hiện đồng thời có thể gây ra
những lỗi phần mềm không dễ dàng để tìm ra.
Trong lập trình tương tranh, một số dòng lệnh có thể được thực hiện đồng thời. Mỗi dòng lệnh
là một chương trình tuần tự, ngoại trừ một thực tế là các dòng lệnh có thể giao tiếp và gây trở
ngại lẫn nhau. Mỗi một dòng lênh là một luồng ( thread ), các chương trình tuần tự còn gọi là
chương trình đơn luồng, còn chương trình viết theo phương pháp tương tranh là chương trình đa
luồng.
6.1. Đặc điểm
• Người dùng có thể tương tác với các ứng dụng khi tiến trình đang thực thi.
• Những tiến trình chạy thời gian dài làm trì hoãn các tiến trình ngắn.
• Các chương trình phức tạp được thực hiện tốt hơn trên các bộ xử lý đa luồng.
• Những tiến trình đòi hỏi điều kiện tiên quyết có thể tạm dừng và đợi đến khi đáp ứng
được để tiếp tục xử lý.
III. Logic programming
Answer a question via search for a solution
1. Đặc điểm
• Mô hình lập trình logic hoàn toàn khác với các mô hình còn lại.
• Mô hình này đặc biệt phù hợp với những lĩnh vực liên quan đến việc rút ra những kiến
thức từ những sự kiện và quan hệ cơ bản – lĩnh vực trí tuệ nhân tạo. Có vẻ như mô hình
này không gắn với những lĩnh vực tính toán nói chung.
• Trả lời 1 câu hỏi thông qua việc tìm các giải pháp.
Các đặc trưng:
• Về nguyên tắc và ý tưởng : Tự động kiểm chứng trong trí tuệ nhân tạo
• Dựa trên các chân lý- tiên đề axioms,các quy luật suy diễn - inference rules, và các truy
vấn queries.

• Chương trình thực hiện từ việc tìm kiếm có hệ thống trong 1 tập các sự kiện, sử dụng 1
tập các luật để đưa ra kết luận.
• Trong lập trình logic, ta có thể sử dụng các vị từ để định nghĩa các khái niệm của tất cả
các môn khoa học khác.
Khi mô tả bài toán dưới dạng logic vị từ, ta có thể yêu cầu hệ thống tìm kiếm các lời giải liên
quan đến
các khai báo đó. Bài toán cần giải được xem là “mục tiêu” mà hệ thống phải chứng minh trên cơ
sở các tri thức
đã được khai báo.
Như thế, toàn bộ các ký hiệu của ngôn ngữ lập trình suy về một công thức đặc biệt:
• Phát sinh từ một yêu cầu.
• Nhằm chứng minh một mục tiêu. Để trả lời cho câu hỏi đó hệ thống xem nó như là một
“đích” và cố chứng minh “đích” đó bằng cách tạo những suy diễn trên cơ sở các tri thức
đã khai báo.
Một ngôn ngữ logic có thể được dùng trong giai đoạn đặc tả yêu cầu của quy trình xây dựng
một sản phẩm phần mềm. Hơn thế nữa, logic vị từ cho phép biểu diễn hầu hết các khái niệm và
các định lý trong các bộ môn khoa học.
2. Ngôn ngữ PROLOG
2.1. Giới thiệu
Prolog là một ngôn ngữ cấp cao, có đặc điểm gần với ngôn ngữ tự nhiên, từ những người mới
học đến những lập trình viên chuyên nghiệp đều có thể tiếp cận một cách nhanh chóng, viết ra
một chương trình ứng dụng hữu ích.
Prolog ra đời vào năm 1973 do C.Camerauer (Đại học Marseilles, Pháp) và nhóm đồng sự phát
triển. Từ đó đến nay, qua nhiều lần cải tiến, đặc biệt hãng Borland cho ra đời phần mềm TURBO
PROLOG với nhiều ưu điểm, thuận tiện cho người sử dụng. Để giải quyết một số vấn đề, ta nhận
thấy sử dụng ngôn ngữ Prolog cho ta chương trình gọn nhẹ hơn nhiều so với các ngôn ngữ khác.
Khác với những ngôn ngữ cấu trúc như Pascal, hay C mà ta đã làm quen, Prolog là một ngôn
ngữ mô tả, với một số sự kiện và quy luật suy diễn đã mô tả, Prolog sẽ suy luận cho ta các kết
quả.
2.2. Các yếu tố cơ bản của Turbo Prolog
Trong một chương trình Prolog, ta cần khai báo các yếu tố sau đây: đối tượng, quan hệ giữa các
đối tượng, sự kiện và các luật.
2.2.1. Đối tượng

Gồm có các hằng và biến. Hằng mang giá trị cho sẵn ở đầu chương trình hoặc trong quá trình
viết ta đưa vào; Các biến có giá trị thay đổi sẽ được gán giá trị khi chạy chương trình. Tên biến là
một ký tự hoa hoặc một chuỗi ký tự, bắt đầu bằng một ký tự hoa.
Có một loại biến đặc biệt gọi là biến tự do, biến này không có tên và người ta dùng ký hiệu _
(dấu gạch dưới) thay cho tên biến.
• Quan hệ giữa các đối tượng
• Quan hệ giữa các đối tượng được dùng dưới hình thức vị từ.
Ví dụ
• Thich(X,Y) là vị từ diễn tả câu “X thích Y” trong ngôn ngữ tự nhiên.
• Blue(car) là vị từ diễn tả câu “Car is blue”.
Như vậy các vị từ sẽ bao gồm tên của vị từ và các đối số của nó. Các đối số được đặt trong ngoặc
và phân cách nhau bởi dấu phẩy.
2.2.2. Sự kiện và luật
Sự kiện là một vị từ diễn tả một sự thật.
Ví dụ
“2 là một số nguyên tố” là một sự kiện vì nó diễn tả sự thật 2 là một số nguyên tố.
Luật là vị từ diễn tả quy luật suy diễn mà ta công nhận đúng. Luật được trình bày dưới dạng
một mệnh đề. Ví dụ để suy diễn số nguyên N bất kỳ là một số nguyên tố ta viết: “N là một số
nguyên tố nếu N>0, M là số nguyên tố nào đó, M<N và N không chia hết cho M”.
2.3. Cấu trúc của một chương trình Prolog
Một chương trình Prolog thường gồm có 3 hoặc 4 đoạn cơ bản: clauses, predicates, domains và
goal. Phần goal có thể bỏ đi, nếu ta không thiết kế goal trong chương trình, thì khi thực hiện, hệ
thống sẽ yêu cầu ta nhập goal vào.
2.3.1. Phần Domains
Đây là phần định nghĩa kiểu mới dựa vào các kiểu đã biết. Các kiểu được định nghĩa ở đây sẽ
được sử dụng cho các đối số trong các vị từ. Nếu các vị từ sử dụng đối số có kiểu cơ bản thì có
thể không cần phải định nghĩa lại các kiểu đó. Tuy nhiên để cho chương trình sáng sủa, người ta
sẽ định nghĩa lại cả các kiểu cơ bản.
Cú pháp: <danh sách kiểu mới> = <kiểu đã biết> hoặc <danh sách kiểu mới> = <danh sách
kiểu đã biết>
Trong đó các kiểu mới phân cách nhau bởi dấu phẩy, còn các kiểu đã biết phân cách nhau bởi
dấu chấm phẩy.

Ví dụ
Domains
ten, tac_gia, nha_xb, dia_chi = string
nam, thang, so_luong = integer
dien_tich = real
nam_xb = nxb(thang, nam)
do_vat = sach(tac_gia, ten, nha_xb, nam_xb); xe(ten, so_luong); nha(dia_chi, dien_tich)
Trong ví dụ trên, ta đã định nghĩa các kiểu mới, trong đó các kiểu mới ten, tac_gia, nha_xb,
dia_chi dựa vào cùng một kiểu đã biết là string; các kiểu mới nam, thang, so_luong dựa vào cùng
một kiểu đã biết là integer; kiểu mới dien_tich dựa vào kiểu đã biết là real; kiểu mới nam_xb dựa
vào kiểu nxb được xây dựng từ các kiểu đã biết là thang, nam; còn kiểu do_vat lại dựa vào các
kiểu sach, xe, nha mà các kiểu này lại dựa vào các kiểu đã biết.
2.3.2. Phần Predicates
Đây là phần bắt buộc phải có. Trong phần này chúng ta cần phải khai báo đầy đủ các vị từ sử
dụng trong phần Clauses, ngoại trừ các vị từ mà Turbo Prolog đã xây dựng sẵn.
2.3.2.1. Cú pháp
<Tên vị từ> (<danh sách các kiểu>)
Các kiểu là các kiểu cơ bản hoặc là các kiểu đã được định nghĩa trong phần domains và được
viết phân cách nhau bơi dấu phẩy.
Ví dụ
Predicates
so_huu (ten, do_vat)
so_nguyen_to(integer)
Trong ví dụ trên ta khai báo hai vị từ. Trong đó vị từ so_huu (ten, do_vat) để chỉ một người có
tên là ten sẽ sở hữu môt do_vat nào đó. Còn vị từ so_nguyen_to(integer) để xét xem một số
integer nào đó có phải là số nguyên tố hay không.
2.3.3. Phần Clauses
Đây là phần bắt buộc phải có dùng để mô tả các sự kiện và các luật, sử dụng các vị từ đã khai
báo trong phần predicates.
2.3.3.1. Cú pháp

<Tên vị từ>(<danh sách các tham số>) <kí hiệu>
<Tên vị từ 1>(<danh sách các tham số 1>) <kí hiệu>
………
<Tên vị từ N>(<danh sách các tham số N>) <kí hiệu>
Trong đó: Tên vị từ phải là các tên vị từ đã được khai báo trong phần predicates. Các tham số có
thể là các hằng hoặc biến có kiểu tương thích với các kiểu tương ứng đã được khai báo trong các
vị từ ở trong phần predicates; các tham số được viết cách nhau bởi dấu phẩy. Các kí hiệu bao
gồm:
• :- (điều kiện nếu).
• , (điều kiện và).
• ; (điều kiện hoặc).
• . (kết thúc vị từ)
Ví dụ
Clauses
so_nguyen_to(2):-!.
so_nguyen_to(N):-N>0,
so_nguyen_to(M),
M<N,
N MOD M <>0.
so_huu(“Nguyen Van A”, sach(“Do Xuan Loi”, “Cau truc DL”, “Khoa hoc Ky thuat”,
nxb(8,1985))).
Chú ý: Nếu trong các tham số của một vị từ có biến thì biến này phải xuất hiện ít nhất 2 lần trong
vị từ đó hoặc trong các vị từ dùng để suy diễn ra vị từ đó. Nếu chỉ xuất hiện một lần thì bắt buộc
phải dùng biến tự do.
Ví dụ
Để diễn tả sự kiện: Tổ hợp chập 0 của N (N bất kỳ) bằng 1, ta không thể viết Tohop(N,0,1) vì
biến N chỉ xuất
hiện đúng một lần trong vị từ này, do đó ta phải viết Tohop(_,0,1).
2.3.4. Phần Goal
Bao gồm các mục tiêu mà ta yêu cầu Turbo Prolog xác định và tìm kết quả. Đây là phần không
bắt buộc phải có. Nếu ta viết sẵn trong chương trình thì đó gọi là goal nội; Nếu không, khi chạy
chương trình Turbo Prolog sẽ yêu cầu ta nhập goal vào, lúc này gọi là goal ngoại.
2.3.4.1. Cú pháp
Giống như cú pháp phần clauses. Tức là ta đưa vào một hoặc một số các vị từ.

Nếu tất cả các tham số của vị từ là hằng thì kết quả nhận được là Yes (đúng) hoặc No (sai). Nếu
trong các tham số của vị từ có biến thì kết quả trả về sẽ là các giá trị của biến.
Ngoài các phần chủ yếu nói trên, ta có thể đưa vào các phần liên quan đến khai báo hằng, các
tập tin liên quan hoặc chỉ thị dịch.
Ví dụ
Constants
Pi = 3.141592653
2.4. Các nguyên tắc của ngôn ngữ Prolog
Việc giải quyết vấn đề trong ngôn ngữ Prolog chủ yếu dựa vào hai nguyên tắc sau: Đồng nhất,
quay lui.
2.4.1. Đồng nhất
• Một quan hệ có thể đồng nhất với một quan hệ nào đó cùng tên, cùng số lượng tham số, các
đại lượng con cũng đồng nhất theo từng cặp.
• Một hằng có thể đồng nhất với một hằng.
• Một biến có thể đồng nhất với một hằng nào đó và có thể nhận luôn giá trị hằng đó.
2.4.2. Quay lui
Giả sử hệ thống đang chứng minh goal g, trong đó g được mô tả như sau:
g :- g1, g2, …, gj-1, gj, …, gn.
Khi các gi kiểm chứng từ trái sang phải, đến gj là sai thì hệ thống sẽ quay lui lại gj-1 để tìm lời
giải khác.
2.5. Bộ ký tự, từ khoá
Prolog dùng bộ ký tự sau: các chữ cái và chữ số (A – Z, a – z, 0 – 9); các toán tử (+, -, *, /, <, =,
>) và các ký hiệu đặc biệt.
2.5.1. Một số từ khoá

• Trace: Khi có từ khoá này ở đầu chương trình, thì chương trình được thực hiện từng bước
để theo dõi; dùng phím F10 để tiếp tục.
• Fail: Khi ta dùng goal nội, chương trình chỉ cho ta một kết quả (mặc dù có thể còn những
kết quả khác), để nhận về tất cả các kết quả khi chạy goal nội, ta dùng toán tử Fail.
• ! hay còn gọi là nhát cắt, goal ngoại luôn cho ta mọi kết quả, muốn nhận chỉ một kết quả
từ goal ngoại, ta dùng ký hiệu !.
2.6. Các kiểu dữ liệu
Trong prolog có kiểu dữ liệu chuẩn và kiểu do người lập trình định nghĩa.
2.6.1. Kiểu dữ liệu chuẩn
Là kiểu dữ liệu do prolog định nghĩa sẵn. Prolog cung cấp các kiểu dữ liệu chuẩn là: char,
integer, real, string và symbol.
• Char: Là kiểu ký tự. Hằng ký tự phải nằm giữa hai dấu nháy đơn. Ví dụ: ‘a’, ‘#’.
• Integer: Là kiểu số nguyên, tập giá trị bao gồm các số nguyên từ -32768 đến 32767.
• Real: Là kiểu số thực, tập giá trị bao gồm các số thực thuộc hai đoạn: đoạn các số âm từ
-10307 đến -10307 và đoạn số dương từ 10-307 đến 10307.
• String: Là kiểu chuỗi ký tự. Hằng chuỗi ký tự phải nằm giữa hai dấu nháy kép. Ví dụ:
“Turbo prolog 2.0”
• Symbol: Là một kiểu sơ cấp, có hình thức giống chuỗi ký tự. Hằng symbol có hai dạng:
Dãy các chữ, số và dấu gạch dưới viết liên tiếp, ký tự đầu phải viết thường (chẳng hạn:
telephone_number); Dãy các ký tự ở giữa một cặp hai nháy kép (giống như chỗi ký tự) .
2.6.1.2. Phép toán số học
2.6.1.3. Phép toán quan hệ

2.6.1.4. Các vị từ như các hàm toán học
Toán tử NOT(X) : Nếu X là Yes thì NOT(X) là No và ngược lại.
2.6.2. Các kiểu dữ liệu do người lập trình định nghĩa
2.6.2.1. Kiểu mẩu tin

2.6.2.1.1. Cú pháp
<tên kiểu mẩu tin> = tên mẩu tin (danh sách các kiểu phần tử)
Ví dụ 1
Domains
ten, tac_gia, nha_xb, dia_chi = string
nam, thang, so_luong = integer
dien_tich = real
nam_xb = nxb(thang, nam)
do_vat = sach(tac_gia, ten, nha_xb, nam_xb); xe(ten, so_luong); nha(dia_chi, dien_tich)
predicates
so_huu(ten,do_vat)
clauses
so_huu(“Nguyen Van A”, sach(“Do Xuan Loi”, “Cau truc DL”, “Khoa hoc Ky thuat”,
nxb(8,1985))).
so_huu(“Le thi B”, xe(“Dream II”, 2)).
so_huu(“Nguyen Huu C”, nha(“3/1 Ly Tu Trong, tp Can Tho”, 100.5))
2.6.2.2. Kiểu danh sách
Cú pháp
<tên kiểu danh sách> = <tên kiểu phần tử>*
Ví dụ 1
Domains
intlist = integer*
Một danh sách là một dãy các phần tử phân cách nhau bởi dấu phẩy và đặt trong cặp dấu ngoặc
vuông.
Ví dụ 2
[]% Danh sách rỗng
[1,2,3] % Danh sách gồm ba số nguyên 1, 2 và 3.
Cấu trúc của danh sách bao gồm hai phần: Phần đầu là phần tử đầu tiên của danh sách và phần
đuôi là
một danh sách của các phần tử còn lại.
Danh sách được viết theo dạng [X|Y] thì X là phần tử đầu và Y là danh sách đuôi. Chẳng hạn
trong danh
sách [1,2,3] thì đầu là số nguyên 1 và đuôi là danh sách [2,3].
Trong danh sách cũng có thể dùng biến tự do, chẳng hạn ta có thể viết [_|Y] để chỉ một danh
sách có

đầu là một phần tử nào đó và có đuôi là danh sách Y.
2.7. Các hàm xuất nhập chuẩn
2.7.1. Xuất ra màn hình
 Write( Arg1, Arg2, … ,Argn) in ra màn hình giá trị của các đối số.
 Writef( Formatstring, Arg1, Arg2, … ,Argn) in ra màn hình giá trị của các đối số theo định
dạng được chỉ
định trong Formastring.
Trong đó Formastring là một chuỗi có thể là:
 “%d”: In số thập phân bình thường; đối số phải là char hoặc integer.
 “%c”: Đối số là một số integer, in ký tự có mã Ascci là đối số đó, chẳng hạn writef(“%c”,65)
được A.
 “%e”: In số thực dưới dạng lũy thừa của 10.
 “%x”: In số Hexa; đối số phải là char hoặc integer.
 “%s”: In một chuỗi hoặc một symbol.
2.7.2. Nhập vào từ bàn phím
 Readln(X): Nhập một chuỗi ký tự vào biến X.
 ReadInt(X): Nhập một số nguyên vào biến X.
 ReadReal(X): Nhập một số thực vào biến X.
 ReadChar(X): Nhập vào một ký tự vào biến X.
2.8. Kỹ thuật đệ quy
Đệ quy là kỹ thuật lập trình được sử dụng trong nhiều ngôn ngữ. Trong Turbo Prolog ta sử
dụng đệ quy
khi một vị từ được định nghĩa nhờ vào chính vị từ đó.
Như đã nói trong chương lập trình hàm, trong chương trình đệ quy phải có ít nhất một trường
hợp
dừng và lời gọi đệ quy phải chứa yếu tố dẫn đến trường hợp dừng. Trong Prolog, trường hợp
dừng được thể
hiện bằng một sự kiện, yếu tố dẫn đến trường hợp dừng thể hiện bằng một biến, liên hệ với biến
ban đầu bởi
một công thức.
Ví dụ 1: Tính n!
Predicates
Facto (integer, integer)
Clauses
Facto(0,1):- !.
Facto(N, FactN) :- N > 0, M = N – 1, facto(M, factM), factN = N*factM.

Ở ví dụ trên ta đã định nghĩa một vị từ dùng để tính giá trị giai thừa của một số tự nhiên, đối số
thứ
nhất là số cần tính giai thừa và đối số thứ hai dùng để nhận giá trị trả về.
Trường hợp dừng ở đây được xác đinh bởi sự kiện 0 giai thừa là 1.
Để tính N! ta tính M! với M= N-1. Yếu tố dẫn đến trường hợp dừng là biến M có giá trị bằng
N-1.
Ví dụ 2: Xác định một phần tử trong danh sách các symbol
domains
symbol_list = symbol*
predicates
element1(integer,symbol_list,symbol)
element (integer,symbol_list,symbol)
clauses
% element1 không suy diễn ngược được
element1(1,[X|_],X).
element1(N,[_|L],Y):-M=N-1,
element1(M,L,Y).
% element có thể suy diễn ngược
element(1,[X|_],X).
element(N,[_|L],Y):-element(M,L,Y),
N=M+1.
Sự suy diễn thuận chiều là cho danh sách và vị trí, tìm được phần tử tại vị trí đó, chẳng hạn, nếu
ta đưa
vào goal element(2,[a,b,c,d],X) ta được X=b.
TRƯỜNG ĐẠI HỌC BÁCH KHOA HÀ NỘI
Sự suy diễn ngược ở đây là cho danh sách và phần tử, tìm được vị trí của phần tử đó, chẳng
hạn, nếu ta
đưa vào goal element(N,[a,b,c,d], b) ta được N=2.
Ví dụ 3: Sắp xếp một danh sách các số nguyên
domains
list=integer*
predicates
insert(integer,list,list)
sort(list,list)
clauses
insert(E,[],[E]).
insert(E,[A|B],[E,A|B]):-E<=A.
insert(E,[A|B],[A|C]):-E>A,insert(E,B,C).
sort([],[]).
sort([X|R1],L):-sort(R1,R),

insert(X,R,L).
2.9. Một số ví dụ về chương trình prolog
2.9.1. Xét xem một số N có phải là số nguyên tố hay không.
domains
so_nguyen = integer
predicates
so_nguyen_to(so_nguyen)
Clauses
so_nguyen_to(2):-!.
so_nguyen_to(N):-N>0,
so_nguyen_to(M),
M<N,
N MOD M <>0.
goal
so_nguyen_to(13).
2.9.2. Tìm các cặp có thể kết bạn
Giả sử ta có bảng số liệu như sau:
Tiêu chuẩn kết bạn là hai người khác phái, người này hội đủ các tiêu chuẩn của người kia và
ngược lại.
Hãy viết chương trình để tìm ra các cặp có thể kết bạn với nhau.
domains
ten, g_tinh = symbol
predicates
gioi_tinh(ten, g_tinh)
dep(ten)
tot(ten)
giau(ten)
thong_minh(ten)
khoe(ten)
thich(ten,ten)
ket_ban(ten,ten)
clauses

gioi_tinh(lan,nu).
gioi_tinh(hong,nu).
gioi_tinh(thuy,nu).
gioi_tinh(anh,nam).
gioi_tinh(binh,nam).
gioi_tinh(hung,nam).
dep(lan).
dep(hong).
dep(binh).
khoe(thuy).
khoe(lan).
khoe(binh).
khoe(anh).
khoe(hung).
tot(lan).
tot(thuy).
thong_minh(hong).
thong_minh(anh).
thong_minh(hung).
thong_minh(binh).
giau(hong).
giau(thuy).
giau(hung).
thich(lan,X):-khoe(X), dep(X), thong_minh(X).
thich(hong,X):-khoe(X), thong_minh(X), giau(X).
thich(thuy,X):-khoe(X), dep(X), thong_minh(X).
thich(ann,X):-dep(X), tot(X), thong_minh(X).
thich(binh,X):-dep(X), khoe(X).
thich(hung,X):-khoe(X), tot(X), thong_minh(X).
ket_ban(X,Y):- gioi_tinh(X,M),
gioi_tinh(Y,N),
M<>N,
thich(X,Y),
thich(Y,X).
IV. Lời kết
Với lượng kiến thức vô cùng hạn chế cũng như chưa có nhiều thời gian để tìm hiểu chuyên sâu,
báo cáo này không hy vọng mang đến những gì mới mẻ mà đơn giản chỉ là sự tổng hợp, lược
dịch và chỉnh sửa lại các bài viết đã có trên internet, sách in và một số tài liệu khác. Sai sót về
mặt nội dung cũng như khiếm khuyết trong cách trình bày chắc chắn không thể tránh khỏi, rất
mong nhận được sự thông cảm và giúp đỡ của thầy để báo cáo được hoàn thiện hơn!

V. Tài liệu tham khảo
 What Is a Programming Paradigm? - Troy Holmes.
 Programming Paradigms - Kurt Nørmark © Department of Computer Science, Aalborg
University,
Denmark.
 Lập trình logic – ThS. Nguyễn Văn Linh.
 http://wikipedia.com
 http://congdongcviet.com
 …

[Bao cao]tim hieu ve mo hinh lap trinh

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (15)

Similar to [Bao cao]tim hieu ve mo hinh lap trinh

Similar to [Bao cao]tim hieu ve mo hinh lap trinh (20)

[Bao cao]tim hieu ve mo hinh lap trinh