LOBACHEVSKY

Cài LAMP trên Ubuntu. Trong đó LAMP là viết tắt của Linux+Apache+MySql+Php.

1. Đầu tiên khởi động Terminate (Applications > Accessories > Terminal)
2. Cài đặtApache2 bằng lệnh: sudo apt-get install apache2
3. Cài đặt php5 bằng lệnh: sudo apt-get install php5 libapache2-mod-php5 php5-gd
4. Cài đặt mysql bằng lệnh: sudo apt-get install mysql-server libapache2-mod-auth-mysql php5-mysql mysql-client
5. Cài đặt phpmyadmin bằng lệnh: sudo apt-get install phpmyadmin
6. Khởi động lại service của Apache2: sudo /etc/init.d/apache2 restart
Sử dụng LAMP
Webserver: http://localhost (hoặc http://tenmay hoặc http://địa chỉ ip LAN hoặc http://172.0.0.1)
MySQL Database: http://localhost/phpmyadmin
Dường dẫn cho webserver: /var/www/


Tôi giả định các bạn đã cài đặt LAMP thành công trong Ubuntu

Tải về Joomla tại trang chủ: www.joomla.org

Unzip Joomla vào thư mục /var/www hoặc thư mục con /var/www/joomla. Để thuận lợi, tôi giả định folder cài đặt joomla là /var/www/joomla.

Các việc cần làm là:

* Thiết lập quyền ghi/xoá đối với các Joomla instance
* Thiết lập bảo mật: chmode cho file là 644 và folder là 755.
*

# 1. Allow writting in whole joomla subtree

sudo chown -R www-data:www-data /var/www/joomla


# 2. Handle file and directory permissions

cd /var/www/joomla
sudo find . -type f -exec chmod 644 {} \;
sudo find . -type d -exec chmod 755 {} \;

Đến đây, bạn có thể tiến hành cài đặt Joomla như thông thường.

Bước 2.1: Từ trình duyệt gõ http://localhost/Joomla, xuất hiện giao diện sau. Chọn ngôn ngữ mặc định là English.


Bước 2.2: Nếu các giá trị kiểm tra có màu xanh thì OK. nếu có màu đỏ thì xem lại phần phân quyền xem có đúng không. Mình chìm 2 ngày ngay phần này. hic


Bước 2.3: Hiển thị thông tin về bản quyền của Joomla. Nếu rãnh thì đọc.


Bước 2.4: Thiết lập các thông số kết nối đến CSDL MySQL


- Hostname: điền vào "localhost"

- User name: Tên tài khoản có quyền đối với cơ sở dữ liệu chứa Joomla của bạn.

- Password: Mật khẩu của tài khoản trên

- Availbe Collations: Bạn nên chọn là "utf8_general_ci"

- Database Name: Tên cơ sở dữ liệu của bạn. Ở đây là myCMS


Bước 2.5: Thiết lập các thông số FTP


Bỏ qua. Do cài trên localhost nên không cần quan tâm.


Bước 2.6: Thiết lập cấu hình site Joomla của bạn


- Site name: tên site của bạn.

- Your Email: địa chỉ email của bạn

- Admin Password: Mật khẩu để quản trị Joomla

Các thông số trên sau này đều có thể thay đổi dễ dàng nên bạn không cần bận tâm lắm. Chỉ cần nhớ mật khẩu là đủ.

- Install Defaul Sample Data: Cài đặt dữ liệu mẫu. Bạn nên nhấn nút này để Joomla tạo mẫu cho bạn một trang web đơn giản.


Bước 2.7: Kết thúc

- Lưu ý: tài khoản truy nhập hệ thống là: admin; mật khẩu: mật khẩu mà bạn đã gõ ở bước 6.

- Để xem Website của bạn: Trước tiên bạn phải xoá (với quyền root) thư mục installation trong /var/www/joomla
hoặc dùng lệnh:

Code:

sudo rm -R /var/www/joomla/installation/


Sau đó, nhấn vào nút Site và lúc ta có đường dẫn:

* http://localhost/Joomla/index.php

mới xem được.

- Để quản trị Website: Nhấn vào nút Admin và có đường dẫn:

* http://localhost/Joomla/administrator


Suu tam

static có tác dụng khác nhau phụ thuộc vào :
- đối tượng của nó (đi kèm theo một biến hay là một hàm).
- vị trí trong mã nguồn ( nó nằm bên trong 1 hàm, mốt lớp hay là 1 file)

1. Đối tượng là một biến

a. Nếu biến đó là biến cục bộ (local variable), tức là biến đó nằm bên trong một hàm nào đó, thì từ khoá static có tác dụng kéo dài thời gian sống (timelife) của biến đó cho đến khi chương trình thực hiện xong. Chắc là bạn đã biết, trong C/C++ một biến cục bộ thường thường chỉ sống một thời gian ngắn. Một khi chương trình thoát ra khỏi block hoăc hàm, nơi mà biến đó được khai báo, thì biến đó cũng không còn tồn tại nữa, tức là giá trị mà biến đó đang lưu trữ cũng sẽ bị mất. Bằng cách dùng từ khoá static khi khai báo biến, ta có thể thay đổi được thời gian sống của biến cục bộ. Tôi xin đưa ra một ví dụ:
#include <iostream>
using namespace std;

int Count()
{
int count = 0;

count++;
return count;
}
int main()
{
int count1, count2;

count1 = Count();
count2 = Count();
cout << "count1 = " << count1 << ", count2 = " << count2 << endl;
return 0;
}
Trong ví dụ này hàm Count() được gọi 2 lần, và kết quả in ra là cả 2 lần hàm đều trả về giá trị 1. Đó là bởi vì biến cục bộ count chỉ lưu trữ giá trị cho đến khi chương trình thoát ra khỏi hàm. Nếu dùng tư khoá static khi khai báo count thì kết quả in ra sẽ khác, lần thứ nhất hàm trả về 1, lần thứ hai hàm trả về 2 :
int Count()
{
static int count = 0;

count++;
return count;
}
Bạn có biết vì sao lại thế không? lý do là sau lần gọi hàm thứ nhất, biến count có giá trị 1. Đến khi hàm được gọi lần thứ hai thì giá trị của count từ lần gọi trước vẫn được lưu giữ, nến nó sẽ trở thành 2. Bạn hãy lưu ý dòng:

static int count = 0;

dòng này có nghĩa là "khỏi tạo biến count với giá trị ban đầu là 0". Vì sau khi sinh ra, count tồn tại cho đến khi chương trình kết thúc nên nó cũng chỉ được khỏi tạo một lần. Lần thứ hai khi chúng ta gọi hàm thì giá trị cũ của count sẽ được sử dụng, chứ không phải nó sẽ được khởi tạo một lần nữa với giá trị 0.

b. Nếu là biến có phạm vi hoạt động là "FILE SCOPE" , tức là biến đó nằm bên ngoài tất cả các hàm và lớp, thì static lại có tác dụng khác. Một biến "FILE SCOPE" thì hiển nhiên nó sẽ sống cho đến khi chương trình thực hiện xong, vì thế từ khoá static không có tác dụng kéo dài thời gian sống của biến, mà nó có tác dụng hạn chế phạm vi hoạt động của biến (scope) trong file đó, nơi mà biến đó được khai báo. Nếu ta không dùng từ khoá static thì từ một điểm bất kỳ trong chương trình, ta có thể truy cập tới biến đó. Khi khai báo biến đó là static thỉ chi những hàm trong file đó mới có thể truy cập đến biến. Bên ngoài file thì biến đó là invisible. Ví dụ ta có 2 file là unit1.cpp và unit2.cpp:
/* unit1.cpp */
int count;
void f1()
{
....
}
/* unit2.cpp */
extern int count; // ba'o cho compiler biet la` ta muon du`ng
// bien count khai ba'o trong unit1.cpp
void f2()
{
....// dung count o day
}
biến count là biến toàn cục nên ta có thể truy cập nó từ unit2.cpp, mặc dù nó được định nghĩa ở unit1.cpp. Nếu ta muốn phạm vi hoạt động của count chỉ hạn chế trong unit1.cpp thôi, thì khai báo nó như sau:

/* unit1.cpp */
static int count;
void f1()
{
....
}

Khi đó chỉ có những hàm trong unit1.cpp mới truy cập được tới count, những hàm trong unit2.cpp không thể sư dụng count được.

c. Nếu biến đó nằm trong phần khai báo của một lớp (class) thì từ khoá static làm cho biến đó có những đặc điểm sau:

- biến được sinh ra từ khi chương trình bắt đầu thực hiện và tồn tại cho đến khi chương trình kết thúc, kể cả khi ta không hề tạo ra bất cứ một đối tượng nào của lớp. Ví dụ:
#include <iostream>
using namespace std;

class CPrint
{
public:
CPrint() { cout << "CPrint constructor" << endl;}
};
class CMyClass
{
static CPrint myPrint;
};
CPrint CMyClass::myPrint;

int main()
{
return 0;
}
Khi chạy chương trình này thì dòng chữ CPrint constructor sẽ được in ra màn hình, mặc dù hàm main() chỉ có duy nhất lệnh return, và trong chương trình không tồn tại một đối tượng nào kiểu CMyClass.
- Đặc điểm thứ hai là ta có thể truy cập đến biến đó trực tiếp thông qua tên lớp. Ví dụ:
CMyClass
{
public:
CMyClass() {}
static int _data;
};
int CMyClass::_data = 5;
main()
{
int data;
CMyClass myClass;

myClass._data = 10; // truy cap theo cach binh thuong
data = CMyClass::_data; // truy cap thong qua ten lop
}
- Đăc điểm thứ ba và cũng là tính chất quan trọng nhất của biến static trong 1 lớp, đó là nó là biến chung cho tât cả các đối tượng có kiểu là lớp đó. Giả sử ta có 2 đối tượng kiểu CMyClass:
main()
{
CMyClass myClass1, myClass2;

myClass1._data = 10;
myClass2._data = 20;
cout << "data = " << myClass1._data << endl;
}
chương trình này sẽ in ra giá trị 20, mặc dù mới đầu chúng ta đã gán giá trị 10 cho _data trong đối tượng myClass1. Đó là bởi vì _data là biến static nên nó là chung cho tất cả các đối tượng kiểu CMyClass, và nếu ta thay đổi giá trị của nó ở một đối tượng này thì cũng tức là ta thay đổi nó ở tất cả các đối tượng còn lại.

2. Đối tượng của static là hàm.
Ngoài trường hợp đi kèm với 1 biến, từ khoá static còn có thể áp dụng cho 1 hàm. Khi dó có 2 khả năng có thể sảy ra: hàm đó thuộc class và hàm đó không thuộc một class nào cả.
a. Dùng static với hàm thuộc lớp. Khi đó cũng giống như là biến static thuộc lớp, ta có thể gọi hàm static trực tiếp thông qua tên lớp. Ví dụ:
class CMyClass
{
public:
CMyClass() {}
static void SetData(int data) { _data = data; }
static int GetData() const { return _data; }

private:
static int _data;
};
int CMyClass::_data;
int main()
{
CMyClass myClass;

myClass.SetData(10);
cout << "data = " << CMyClass::GetData() << endl;
return 0;
}
Một hàm thành viên là static thì nó khác gì với một hàm thành viên bình thường ? Trước hết hàm thành viên static chỉ có thể thao tác với các biến static của lớp. Nếu như _data trong ví dụ trên không phải là biến static thì cả 2 hàm GetData() và SetData() đều không thể truy cập đến _data được. Điểm khác thứ hai là chúng ta có thể gọi 1 hàm thành viên static mà không cần phải tạo ra đối tượng, bằng cách dùng tên lớp giống như ví dụ trên. Bạn cần chú ý là cả biến static và hàm static đều tuân theo quy tắc truy cập giống như các biên và hàm khác, tức là nếu chúng nằm trong phần private của lớp thì chỉ có những hàm thuộc lớp mới có thể sử dụng chúng. Vì thế thường thường các hàm static hay nằm ở phần public, còn các biến static thì hay nằm ở phần private.

b. Dùng static với một hàm nằm ngoài lớp. Nếu một hàm không thuộc một lớp nào thì nó là global trong chương trình. Giả sử chương trình của bạn gồm 2 file là unit1.cpp và unit2.cpp, khi đó các hàm trong unit2.cpp có thể gọi các hàm trong unit1.cpp. Nếu bạn muốn một hàm nào đó trong unit1.cpp chỉ được phép dùng bên trong file đó thôi thì bạn có thể định nghĩa nó là static (giống như là trường hợp với biến static vậy). Làm như thế có 2 cái lợi. Thứ nhất, nếu chúng ta cần thay đổi những hàm đó thì nó chỉ liến quan đến file đó thôi, chứ nó không ảnh hưởng tới những phần khác của chương trình. Thứ hai là bảo đảm không bị trùng lặp về signature của các hàm trong các file khác nhau.

Trich luoc tu vninformatics

Lâu quá mình mới ghé vô Opera. Bây giờ mình mới thật sự thấy nó có ích. Từ khi dự cuộc phỏng vấn bên MSP, mình rút ra được nhiều điều hay, rất hay, rất có ích cho mình. Ra ngòai nhiều mới biết mình thiếu hụt nhiều thứ quá. Cái mình thiếu nhất chính là tri thức. Ai cũng có trình độ hơn mình. Và chính người phỏng vấn MSP đã chỉ cho mình thấy nhược điểm to lớn đó.
Nếu giả dụ mình cứ học bình thường, học cũng khá trong lớp, thì mình cũng là một học sinh, sinh viên khá. Nhưng đó chỉ là xét trong môi trường nhỏ bé của học xá. Khi ra ngòai, muốn trở thành một người nổi bật giữa bao người, thì mình cần có cái riêng. Và đó là điều mình đang cần, đang làm và phải đạt được.

Nghĩ về điều này cũng có khá nhiều thú vị. Chẳng hạn, khi mình học về pointer trong C++, mình phát hiện chính bản thân mình mắc phải một sự nhầm lẫn tai hại. Chính xác hơn là mình bị nhầm lẫn về khả năng của một dynamic memory. Khi tự học C++, đọc tới phần dynamic memory là mình lung túng nhất (trước khi học C++ trong trường). Mình thật sự không hiểu những điều sau đây:

-Tại sao người ta cần cấp phát một dynamic memory làm gì khi đã có static memory.
-Làm sao các phần tử của “mảng động” lại có thể lien kết với nhau nếu nó cấp một bộ nhớ ngẫu nhiên.
-Khi cấp một vùng nhớ động, ta có thể dung một biến để khởi tạo. Vậy ý nghĩa nó là gì.
-Và cuối củng là: Tại sao gọi nó là “động”.

Thật sự khi tự học đến phần này, mình đã tự tìm đủ mọi lý do để giải thích cho những câu hỏi trên. Những câu hỏi đó nếu được giảng dạy hàn lâm thì có lẽ điều đó không khó. Bất kỳ một bạn học lập trình nào cung có thể trả lời nhưng câu hỏi đó. Tuy nhiên, cái khác biệt chính là cái mình hiểu nó như thế nào.

Khi chưa được dạy C++, mình đã cố trả lời những câu hỏi ấy như sau (lúc này mình chẵng biết heap là gì):

-Người ta cấp phát bộ nhớ động để dễ dàng thao tác và xử lý với mảng. Mảng tĩnh cũng tốt nhưng có lẽ nó hơi cứng nhắc (vì nó là một khối bộ nhớ liền mạch đã được khai báo trước).

-Mình có đọc sơ qua về giáo trình Cơ sở dữ liệu bên Bách Khoa, thấy rằng một danh sách động được tổ chức bằng cách ghi nhớ địa chỉ của ô nhớ kế tiếp. Do đó mình nghĩ mảng động chắc cũng vậy. Mỗi phần tử của mảng cũng sẽ có 2 ô nhớ : 1 phần chứa dữ liệu, phần còn lại chứ address của ô nhớ kế.

- Cái này là một tai nạn trong nhận thức của mình. Cũng từ cuốn giáo trình Cơ sở dữ liệu, mình thấy rằng việc them hay bớt 1 thành phần (hay phần tử trong danh sách là rất dễ dàng). Vậy khi khai báo một mảng động, ta có thể dùng 1 biến để khởi tạo. Vậy nếu ta cho biến ấy tăng thì như một danh sách, mảng cũng tương tự tăng số lượng phần tử.(và ngược lại).

-Vậy tại sao nó là động. Nó động vì nó linh họat như một danh sách liên kết. Nó có thể cấp phát bất cứ đâu trong bộ nhớ và việc truy xuất trên nó thật dễ dàng.

Có lẽ nếu ai đã học lập trình thì đọc đến đây sẽ cừơi phá lên: “Ha ha sao thằng này ngu quá, có chút xíu vậy cũng không hiểu”. Ừ, mình thừa nhận là những điều trên đây không đúng hòan tòan. Nhưng đó là cái mình đã nghĩ, đã nhận xét dù lúc đó mình chẳng có chút ý niệm gì về bộ nhớ máy tính.

Chính cái ý niệm đó là một trở ngại của mình. Khi tham dự cuộc vui ACM trong trường (lúc này mình cũng chưa được dạy về C), mình đã dùng bộ nhớ động. Một số bài trong đề thi thật sự không khó, nếu không muốn nói là rất dễ. Ấy vậy mà lần nào nộp bài, hệ thống cũng báo là bài mình bị sai. Tức thật, tại sao mình test thì chạy ok mà khi nộp hệ thống lại báo sai. Tức lắm chứ. Mình nghĩ mình cũng không thể thiểu năng trí tuệ đến nỗi bài toán tìm kiếm đơn giản cũng không làm được. Tại sao mình test bằng tay thì chạy ngon lành mà lên đó thì bị break. Bộ hệ thống nó chơi mình hả.