Bỏ qua tới nội dung chính

Trước khi có công nghệ phần mềm

Nhập môn công nghệ phần mềm: làm phần mềm cùng nhau, và giữ cho nó sống lâu

Công nghệ phần mềm khác lập trình ở đâu: yêu cầu, thác nước và Agile, Git, xem lại code, ước lượng và định luật Brooks — và nên bắt đầu học từ đâu.

Ban biên tập OpenER

Cập nhật 09/11/2026 · 20 phút đọc · CC BY 4.0

Đồ án cuối kỳ, nhóm bốn người, hạn nộp sáng thứ Hai. Tối Chủ nhật, Nam gửi lên nhóm Zalo một file zip "bản mới nhất". Lan thì đã sửa suốt buổi chiều trên bản cũ từ hôm thứ Năm. Ghép hai bản lại, phần đăng nhập Nam viết biến mất. Chương trình chạy trên máy Lan nhưng báo lỗi trên máy thầy. Đến lúc bảo vệ, thầy hỏi: "Chức năng tìm kiếm đâu?" — cả nhóm nhìn nhau, vì mỗi người hiểu đề bài một kiểu.

Không ai trong nhóm viết code kém. Cái thiếu nằm ở chỗ nhiều người cùng làm một phần mềm trong nhiều tuần: hiểu đúng cần làm gì, chia việc, ghép việc, biết mình đang ở đâu so với hạn nộp. Giờ hãy nhân nhóm đó lên bốn trăm người, kéo thời gian ra mười năm, thêm hàng triệu người dùng. Cách làm việc trong hoàn cảnh ấy là nội dung của môn công nghệ phần mềm (software engineering) — có nơi gọi là kỹ thuật phần mềm.

Trước khi có công nghệ phần mềm

Trong thập niên 1950, một chương trình thường do một vài người viết, đủ nhỏ để một người nắm hết trong đầu. Máy đắt hơn người lập trình rất nhiều; phần mềm đi kèm máy, chưa ai coi nó là một sản phẩm cần quản lý riêng. Rồi mọi thứ đổi khác qua từng bước:

  1. Phần mềm phình to — thập niên 1960. Máy mạnh lên rất nhanh, tham vọng của phần mềm tăng theo. Hệ điều hành OS/360 cho họ máy System/360 của IBM (xem bài Kiến trúc máy tính) là một trong những dự án phần mềm lớn nhất thời đó, lúc đông nhất có hơn một nghìn người tham gia — và nó ra đời trễ, vượt ngân sách, đầy lỗi. Fred Brooks quản lý dự án trong những năm đầu. Người ta bắt đầu nói tới khủng hoảng phần mềm (software crisis): dự án trễ hạn, tốn hơn dự tính, giao xong không làm đúng việc, và không ai dám sửa.
  2. Đặt tên cho ngành — 1968. Tháng 10 năm đó, Ủy ban Khoa học của NATO họp các chuyên gia nhiều nước ở Garmisch (Tây Đức). Tên hội nghị, Software Engineering, được chọn cố ý để gây chú ý: làm phần mềm phải có nền tảng lý thuyết và kỷ luật như các ngành kỹ thuật lâu đời, chứ không chỉ dựa vào tài nghệ của từng người. Cụm từ đã lác đác xuất hiện trước đó, nhưng từ hội nghị này nó mới thành tên một ngành.
  3. Quy trình theo từng bậc — 1970. Winston Royce viết bài Managing the Development of Large Software Systems, trong đó có hình vẽ các bước nối đuôi nhau: yêu cầu, phân tích, thiết kế, viết code, kiểm thử, vận hành — như nước đổ từ bậc này xuống bậc kia. Người đi sau gọi nó là mô hình thác nước (waterfall) và áp dụng khắp nơi, nhưng nhiều người chỉ xem hình. Ngay bên dưới, Royce viết rằng làm đúng như hình thì rủi ro và dễ thất bại, vì phải tới bước kiểm thử mới biết thiết kế có ổn không. Phần sau của bài khuyên làm thử một bản trước và cho khách hàng tham gia suốt quá trình. Chữ "waterfall" thậm chí không có trong bài.
  4. Bài học về con người — 1975. Brooks viết The Mythical Man-Month (Huyền thoại người-tháng), đúc kết từ OS/360: phần khó của làm phần mềm phần lớn nằm ở người — hiểu nhau, chia việc, ước lượng.
  5. Vòng lặp ngắn — thập niên 1990. Nhiều nhóm thử làm theo chu kỳ vài tuần thay cho những dự án kéo dài nhiều năm: Scrum (Ken Schwaber và Jeff Sutherland, 1995), Extreme Programming (Kent Beck, cuối thập niên 1990). Tháng 2 năm 2001, mười bảy người làm phần mềm gặp nhau ở Utah (Mỹ) và viết Tuyên ngôn Agile (Agile Manifesto), với bốn điều coi trọng: con người và sự tương tác hơn quy trình và công cụ; phần mềm chạy được hơn tài liệu đầy đủ; cộng tác với khách hàng hơn đàm phán hợp đồng; thích ứng với thay đổi hơn bám theo kế hoạch. Câu cuối của tuyên ngôn hay bị quên: những thứ đứng sau chữ "hơn" vẫn có giá trị.

Đặt cạnh nhau:

Không có công nghệ phần mềm
Có công nghệ phần mềm
Biết cần làm gì
Mỗi người hiểu một kiểu, lộ ra lúc bàn giao
Hỏi, ghi ra, cho người dùng xem bản chạy được từ sớm
Nhiều người sửa cùng code
Gửi file qua lại, bản sau đè mất bản trước
Mỗi thay đổi có tên người, lý do, quay lại được
Tiến độ
"Sắp xong" suốt nhiều tháng
Việc chia nhỏ, trễ thì biết sớm
Chất lượng
Một người viết, không ai khác đọc
Người khác đọc lại, kiểm thử tự động chạy trước khi gộp
Khi người viết nghỉ việc
Không ai dám sửa
Lịch sử còn đó, nhiều người đã đọc qua

Không phải phần mềm nào cũng cần những thứ này. Đoạn script năm mươi dòng để đổi tên ảnh trong máy bạn không cần nhánh, không cần người duyệt. Nhưng có những thứ lớn lên lặng lẽ từ một script như thế: phần mềm xếp thời khóa biểu của một trường cấp ba, do thầy dạy Tin tự viết từ nhiều năm trước, đầu năm học nào cũng chỉ thầy biết sửa. Người trong nghề gọi nửa đùa là hệ số xe buýt (bus factor): cần bao nhiêu người trong nhóm bỗng dưng vắng mặt — nghỉ việc, ốm, hay "bị xe buýt đâm" — thì dự án đứng hẳn? Với phần mềm của thầy, con số là một.

Môn này trả lời câu hỏi gì

Môn Công nghệ phần mềm trả lời câu hỏi: làm sao để một nhóm người xây đúng phần mềm người dùng cần, giao theo một nhịp đoán trước được, và giữ cho nó còn sửa được qua nhiều năm — khi người làm đến rồi đi, và yêu cầu thay đổi liên tục?

Cuốn Software Engineering at Google tóm sự khác biệt với lập trình trong một ý: công nghệ phần mềm là lập trình cộng dồn theo thời gian. Lập trình hỏi "chương trình chạy đúng chưa?". Công nghệ phần mềm hỏi thêm: năm năm nữa, khi người viết đã đi, còn sửa được không? Năm mươi người cùng sửa thì cách làm này còn chạy không? Làm nhanh hôm nay thì mai ai trả giá? Cái giá trả sau cho một lối tắt có tên nợ kỹ thuật (technical debt), kể kỹ trong bài Nguyên lý và mẫu thiết kế phần mềm.

Vì sao cần học? Vì gần như ai đi làm phần mềm cũng làm trong nhóm, trên code đã có từ trước khi mình đến. Và vì trí tuệ nhân tạo viết code ngày càng nhanh: viết code càng rẻ, phần việc còn lại càng đáng giá. Năm 1986, trong bài No Silver Bullet, Brooks viết rằng phần khó nhất khi xây một hệ thống phần mềm là quyết định chính xác cần xây cái gì. Chưa công cụ nào quyết hộ được việc đó.

Năm ý tưởng cốt lõi

1. Yêu cầu: lỗi đắt nhất là làm ra thứ không ai cần

Một phòng khám nhờ nhóm bạn làm ứng dụng "cho bệnh nhân đặt lịch khám qua điện thoại". Nghe đủ rõ để bắt tay viết code. Nhưng thử hỏi thêm:

  • Đặt trước tối đa bao nhiêu ngày? Hủy sát giờ thì sao?
  • Hai người cùng bấm vào khung 8 giờ cuối cùng thì ai được?
  • Bác sĩ nghỉ đột xuất thì những lịch đã đặt xử lý thế nào?
  • Một bà cụ bảy mươi tuổi không quen điện thoại có tự đặt được không?

Mỗi câu là một chỗ mà nếu đoán sai, cả nhóm sẽ viết code đúng — cho một bài toán sai. Đó là việc của kỹ nghệ yêu cầu (requirements engineering): hỏi, ghi ra, và kiểm lại với người sẽ dùng. Yêu cầu chức năng (functional requirement) nói hệ thống làm gì: "bệnh nhân hủy được lịch". Yêu cầu phi chức năng (non-functional requirement) nói làm tốt tới đâu: "trang đặt lịch mở trong dưới hai giây trên mạng 4G", "thông tin bệnh án không lộ ra ngoài".

Nhiều nhóm viết yêu cầu thành câu chuyện người dùng (user story) kèm tiêu chí chấp nhận (acceptance criteria) — những câu cụ thể tới mức kiểm được là đúng hay sai:

text
Câu chuyện: Là bệnh nhân, tôi muốn hủy lịch đã đặt,
            để người khác dùng được khung giờ đó.

Tiêu chí chấp nhận:
- Hủy trước giờ khám từ 2 tiếng trở lên: hủy được, khung giờ mở lại cho người khác.
- Hủy khi còn dưới 2 tiếng: không hủy được, hiện số điện thoại phòng khám.
- Hủy xong: bệnh nhân nhận tin nhắn xác nhận trong vòng 1 phút.

Có những dòng như vậy, nhóm và phòng khám có một thứ để cùng chỉ vào và nói "đúng rồi" hay "không phải thế". Mỗi tiêu chí về sau còn thành một ca kiểm thử — chuyện của bài Kiểm thử phần mềm.

Vì sao đây là lỗi đắt nhất? Một lỗi trong một hàm sửa trong vài phút. Một yêu cầu hiểu sai thì mọi thứ xây trên nó — thiết kế, code, kiểm thử, tài liệu — đều phải làm lại. Barry Boehm đã đo chuyện này từ thập niên 1970: lỗi phát hiện càng muộn, chi phí sửa càng tăng vọt.

2. Quy trình: thác nước hay những vòng lặp ngắn

Thử nghĩ tới hai cách đi Đà Lạt ba ngày. Cách thứ nhất: ba tháng trước, lên lịch từng giờ — ăn quán nào, mấy giờ ra thác — rồi đặt cọc hết. Cách thứ hai: đặt vé xe và khách sạn đêm đầu, còn lại mỗi tối cả nhóm xem thời tiết, xem ai mệt, rồi chốt chuyện ngày mai.

Cách thứ nhất là thác nước: làm xong hẳn từng bước rồi mới sang bước sau. Nó hợp khi biết chắc mình muốn gì và thay đổi giữa chừng rất đắt, như phần mềm cho thiết bị y tế hay máy bay phải qua kiểm định. Cách thứ hai là phát triển lặp (iterative development), nền của các phương pháp Agile: chia việc thành những vòng ngắn, cuối mỗi vòng có phần mềm chạy được để người dùng góp ý. Nó hợp khi chưa ai chắc sản phẩm nên trông thế nào, như phần lớn ứng dụng web và di động.

Trong Scrum, cách làm Agile phổ biến nhất, mỗi vòng gọi là một sprint, thường dài hai tuần và không quá một tháng:

  • đầu sprint, nhóm chọn từ danh sách việc của sản phẩm (product backlog) những việc quan trọng nhất làm kịp trong vòng này;
  • mỗi ngày gặp nhau mười lăm phút, nhiều nhóm vẫn dùng ba câu quen thuộc: hôm qua làm gì, hôm nay làm gì, đang vướng gì;
  • cuối sprint, cho người dùng xem phần mềm chạy được, rồi cả nhóm hỏi nhau lần sau nên làm khác đi điều gì — buổi nhìn lại (retrospective).

Hai cách không đối nghịch tuyệt đối. Chính Royce khuyên làm lặp; còn một nhóm Agile tốt vẫn viết tài liệu và lập kế hoạch, chỉ là kế hoạch ngắn và sẵn sàng sửa. Câu hỏi đúng không phải "Agile hay thác nước", mà là yêu cầu chắc tới đâu, và phát hiện sai muộn thì tốn bao nhiêu.

3. Quản lý phiên bản: cỗ máy thời gian cho code

Thứ nhóm đồ án ở đầu bài thiếu trước tiên là một hệ quản lý phiên bản (version control system): công cụ ghi lại mọi thay đổi của code — ai sửa, sửa gì, khi nào, vì sao — và cho nhiều người sửa song song rồi gộp lại. Công cụ kiểu này có từ đầu thập niên 1970; ngày nay gần như cả ngành dùng Git, do Linus Torvalds viết năm 2005 để quản lý code nhân Linux.

Bạn có thể thử ngay (cần Git từ bản 2.28, đã khai tên và email bằng git config; gõ trong Git Bash trên Windows, hoặc terminal của macOS, Linux). Lan và Nam cùng sửa giờ mở cửa của phòng khám:

bash
git init -b main phong-kham && cd phong-kham
echo 'GIO_MO_CUA = "7:00"' > cau_hinh.py
git add cau_hinh.py
git commit -m "Thêm giờ mở cửa"

git switch -c nam                  # Nam tách một nhánh riêng để làm
echo 'GIO_MO_CUA = "7:30"' > cau_hinh.py
git commit -am "Đổi giờ mở cửa theo lịch mới"

git switch main                    # trong lúc đó, Lan sửa trên nhánh chính
echo 'GIO_MO_CUA = "6:30"' > cau_hinh.py
git commit -am "Mở sớm cho người đi làm"

git merge nam                      # gộp việc của Nam vào

Mỗi commit là một bức ảnh chụp toàn bộ dự án, kèm một dòng giải thích. Mỗi nhánh (branch) là một dòng thời gian riêng, nơi một người làm việc mà không đụng tới người khác. Lệnh cuối gộp hai dòng thời gian lại — và lần này Git dừng:

text
Auto-merging cau_hinh.py
CONFLICT (content): Merge conflict in cau_hinh.py
Automatic merge failed; fix conflicts and then commit the result.

Mở file ra, Git đã đánh dấu cả hai phiên bản:

text
<<<<<<< HEAD
GIO_MO_CUA = "6:30"
=======
GIO_MO_CUA = "7:30"
>>>>>>> nam

Đây là xung đột khi gộp (merge conflict). Hai người sửa hai chỗ không sát nhau trong một file thì Git tự gộp. Nhưng khi cả hai cùng sửa một dòng, Git không đoán ai đúng — và nó không nên đoán, vì đây không phải câu hỏi về code mà là câu hỏi về yêu cầu: phòng khám mở cửa lúc mấy giờ? Hỏi phòng khám xong, sửa file cho đúng, commit thêm một lần, rồi xem lại lịch sử:

text
$ git log --oneline --graph
*   811511e Gộp nhánh nam: phòng khám chốt mở cửa 6:30
|\
| * a53d70b Đổi giờ mở cửa theo lịch mới
* | 9158429 Mở sớm cho người đi làm
|/
* c4aad49 Thêm giờ mở cửa

(Dãy mã đầu mỗi dòng sẽ khác trên máy bạn.) Không ai mất code của ai, và sáu tháng sau, ai thắc mắc "sao lại 6:30?" chỉ cần đọc lịch sử. Vì vậy dòng mô tả commit đáng được viết cẩn thận: nó là lá thư gửi người đọc code sau này — mà người đó rất thường là chính bạn.

Các dịch vụ như GitHub, GitLab giữ một bản chung trên mạng để cả nhóm cùng đẩy lên, kéo về — và thêm một bước trước khi gộp: cho người khác đọc.

4. Xem lại code và làm việc nhóm

Trước khi một thay đổi được gộp vào nhánh chính, ít nhất một người khác đọc nó. Đó là xem lại code (code review). Trên GitHub, người viết mở một pull request — "mình xin gộp nhánh này, mọi người xem giúp" — và người đọc bình luận ngay cạnh từng dòng:

text
dat_lich.py
- if so_ngay_truoc > 7:
+ if so_ngay_truoc >= 7:
      return "Chỉ đặt được trước tối đa 7 ngày"

Hà:  Yêu cầu cho đặt trước đúng 7 ngày, nhưng với >= 7 thì ngày thứ 7 bị chặn.
     Mình nghĩ nên giữ > 7. Bạn xem lại giúp mình nhé?
Nam: Đúng rồi, mình đọc nhầm. Đã sửa lại, thêm một ca kiểm thử cho ngày thứ 7.

Review bắt được lỗi, nhưng đó không phải lợi ích duy nhất. Mỗi lần đọc code của nhau, hiểu biết về hệ thống lan ra cả nhóm — hệ số xe buýt tăng lên, và người mới học được cách nhóm viết code. Ở Google, gần như mọi thay đổi, dù nhỏ tới đâu, đều phải có ít nhất một người khác duyệt trước khi gộp. Vài thói quen giúp review vừa có ích vừa dễ chịu:

  • Thay đổi nhỏ. Hai mươi dòng thì người đọc soi từng dòng; hai nghìn dòng thì họ thường lướt rồi bấm "đồng ý".
  • Nói về code, không nói về người: "chỗ này lỗi khi danh sách rỗng", không phải "bạn lại quên rồi".
  • Để máy làm phần của máy. Mỗi lần có thay đổi, một máy chủ tự build và chạy toàn bộ kiểm thử — gọi là tích hợp liên tục (continuous integration — CI). Người review dành sức cho thứ máy không thấy: code có làm đúng yêu cầu không, có dễ hiểu không, có cách nào đơn giản hơn không.

Cách nhóm tổ chức còn in dấu lên chính phần mềm. Năm 1968, Melvin Conway nhận xét rằng tổ chức nào thiết kế hệ thống cũng sẽ làm ra hệ thống mang cấu trúc giao tiếp của chính tổ chức đó. Nhận xét ấy nay gọi là định luật Conway, và người ta dùng nó theo chiều ngược lại: muốn hệ thống có các phần tách bạch, ranh giới rõ, thì chia nhóm theo đúng các phần đó.

5. Ước lượng, và vì sao thêm người lúc muộn lại càng muộn

Dự án trễ hạn, sếp hỏi: "Cần thêm mấy người?" Nghe hợp lý: bốn người làm mười tuần thì tám người làm năm tuần. Đơn vị "người-tháng" ngầm giả định như thế — người và tháng đổi cho nhau được. Brooks gọi đó là một huyền thoại, và đúc kết thành định luật Brooks: thêm người vào một dự án phần mềm đang trễ chỉ làm nó trễ thêm (nguyên văn: "Adding manpower to a late software project makes it later").

Có ba lý do. Người mới cần thời gian làm quen, và người kèm họ lại chính là những người nắm việc nhất nhóm. Không phải việc nào cũng chia được: thêm người gặt thì ruộng lúa xong sớm hơn, nhưng thêm người canh thì nồi cơm không chín nhanh hơn — Brooks dùng hình ảnh mang thai, giao cho bao nhiêu người cũng vẫn chín tháng. Và lý do dễ thấy nhất bằng con số: chi phí trao đổi. Trong nhóm n người, nếu ai cũng phải phối hợp với ai, số cặp cần trao đổi là n(n − 1)/2 — Brooks viết đúng công thức này trong sách:

python
def so_kenh(n):
    """Số cặp người cần trao đổi với nhau trong một nhóm n người."""
    return n * (n - 1) // 2

def viec_moi_ngay(n, ton_moi_kenh=0.05):
    """Mỗi người làm được 1 phần việc mỗi ngày, nhưng mỗi kênh trao đổi
    ngốn 0,05 phần việc mỗi ngày (con số giả định cho dễ thấy)."""
    return n - ton_moi_kenh * so_kenh(n)

for n in [2, 5, 10, 20, 30, 40]:
    print(f"{n:2d} người: {so_kenh(n):3d} kênh, làm được {viec_moi_ngay(n):5.2f} phần việc/ngày")

Kết quả:

text
 2 người:   1 kênh, làm được  1.95 phần việc/ngày
 5 người:  10 kênh, làm được  4.50 phần việc/ngày
10 người:  45 kênh, làm được  7.75 phần việc/ngày
20 người: 190 kênh, làm được 10.50 phần việc/ngày
30 người: 435 kênh, làm được  8.25 phần việc/ngày
40 người: 780 kênh, làm được  1.00 phần việc/ngày

Con số 0,05 là giả định, không phải số đo. Nhưng hình dạng thì đúng: số người tăng theo đường thẳng, số kênh trao đổi tăng theo bình phương. Với giả định này, nhóm 40 người làm được đúng bằng một người. Vì thế các tổ chức lớn chia thành nhiều nhóm nhỏ, mỗi nhóm một phần việc có ranh giới rõ — Scrum Guide ghi một nhóm thường từ mười người trở xuống — thay vì để ai cũng phải hỏi ai.

Bản thân việc ước lượng cũng khó, vì lúc bắt đầu chưa ai biết hết những gì sẽ gặp. Một ước lượng tốt là một khoảng ("ba tới sáu tuần, nhiều khả năng là bốn"), giống khoảng tin cậy trong bài Xác suất và thống kê. Chia việc thành phần nhỏ vài ngày, rồi so ước lượng với thực tế sau mỗi vòng: vài sprint sau, nhóm có số liệu của chính mình để đoán sát hơn.

Công nghệ phần mềm nằm ở đâu trong chồng tầng

Trong chồng tầng của bài Từ electron đến ứng dụng, công nghệ phần mềm chạm vào hai chỗ. Ở tầng trên cùng — bài toán nói bằng ngôn ngữ con người — nó là việc biến một câu nói mơ hồ thành đặc tả. Ở tầng phần mềm ứng dụng, nó là cách nhiều người cùng xây một chương trình lớn mà không giẫm chân nhau: mỗi nhóm giữ một mô-đun và thỏa thuận giao diện với nhóm khác — còn cách dựng những tầng nhỏ như thế bên trong chương trình là chuyện của bài Nguyên lý và mẫu thiết kế phần mềm.

Nhưng khác với hệ điều hành hay mạng, công nghệ phần mềm không phải một tầng mà là cách làm việc ở mọi tầng: nhân Linux, trình biên dịch hay một ứng dụng web đều được xây bằng Git, review và những vòng lặp như đã kể.

Đưa lên

Một phần mềm làm đúng việc người dùng cần, đến tay họ theo một nhịp đều, và vẫn sửa được sau nhiều năm, kể cả khi người viết ban đầu đã đi.

Giấu đi

Ai viết dòng nào, bao nhiêu lần làm lại, những cuộc tranh luận trong review, những nhánh bỏ dở. Người dùng chỉ thấy phiên bản mới.

Học trước và học sau

· 6 môn

Lập trình

Programming

Biến, hàm, gỡ lỗi, viết code cho người đọc — nền phải vững trước khi làm cùng người khác. Nên học trước.

Xem chủ đề trên OpenER: Programming

Cấu trúc dữ liệu và giải thuật

Data Structures and Algorithms

Viết được chương trình cỡ vừa, chọn đúng cấu trúc dữ liệu — thứ người review hay hỏi đầu tiên. Nên học trước.

Xem chủ đề trên OpenER: Data Structures and Algorithms

Nguyên lý và mẫu thiết kế phần mềm

Software Engineering Principles and Patterns

Chia mô-đun, thiết kế giao diện, nguyên lý và mẫu thiết kế — phần mà bài này mới chạm tới.

Xem chủ đề trên OpenER: Software Engineering Principles and Patterns

Kiểm thử phần mềm

Software Testing

Biến tiêu chí chấp nhận thành kiểm thử tự động chạy trong CI. Học song song hoặc ngay sau.

Xem chủ đề trên OpenER: Software Testing

Ứng dụng web

Web Applications

Nơi tốt để thực hành cả môn: một dự án nhóm nhỏ, có Git, review và một bản chạy thật trên mạng.

Xem chủ đề trên OpenER: Web Applications

Tương tác người – máy

Human-Computer Interaction

Hỏi người dùng đúng cách và kiểm xem họ có dùng được không — nửa còn lại của kỹ nghệ yêu cầu.

Xem chủ đề trên OpenER: Human Computer Interaction

Ứng dụng thật và nghề nghiệp

  • Kỹ sư phần mềm: gần như mọi vị trí — frontend, backend, di động, nhúng — đều làm trong nhóm, với Git, review và sprint.
  • Trưởng nhóm kỹ thuật (tech lead): chia việc, ước lượng, giữ chất lượng code, kèm người mới.
  • Phân tích nghiệp vụ (business analyst), quản lý sản phẩm (product manager): làm việc với khách hàng, viết yêu cầu, xếp thứ tự ưu tiên.
  • Đảm bảo chất lượng (QA), DevOps: kiểm thử, dựng hệ thống CI, đưa phần mềm lên chạy thật an toàn.
  • Gia công phần mềm (outsourcing): nhiều công ty ở Việt Nam làm phần mềm cho khách nước ngoài; ở đó, đọc và hỏi lại yêu cầu bằng tiếng Anh, ước lượng và báo cáo tiến độ được coi trọng ngang viết code.
  • Mã nguồn mở: Python, VS Code, React nhận đóng góp từ khắp nơi qua đúng quy trình pull request và review — một cách tốt để luyện nghề và có hồ sơ công khai.

Học xong làm được gì, bắt đầu từ đâu

Sau môn này bạn có thể:

  • hỏi đúng câu để biến một yêu cầu mơ hồ thành câu chuyện người dùng và tiêu chí chấp nhận kiểm được;
  • chọn quy trình hợp với dự án, và làm trong một nhóm Scrum mà hiểu vì sao có từng buổi họp;
  • dùng Git hằng ngày: commit có ý nghĩa, làm trên nhánh, gộp và giải quyết xung đột;
  • mở pull request, review code của người khác và nhận review một cách xây dựng;
  • ước lượng bằng khoảng, chia việc nhỏ, và giải thích được vì sao thêm người lúc này chưa chắc đã nhanh hơn.

Nên biết trước: lập trình vững một ngôn ngữ, đã tự viết vài chương trình vài trăm dòng, và dùng được dòng lệnh.

Bắt đầu trên OpenER: trang chủ đề Introduction to Software Engineering có các khóa học đã chọn lọc, và hướng dẫn học gợi ý thứ tự đi qua chúng. Khóa chính là Software Engineering của NPTEL (IIT Kharagpur, Rajib Mall): video bài giảng công khai, từ mô hình vòng đời, Agile tới đặc tả yêu cầu, thiết kế và kiểm thử. Muốn học theo dự án thì có Software Engineering: Introduction của Đại học British Columbia trên edX; muốn đi sâu vào quy trình và làm việc nhóm thì có 17-313 Foundations of Software Engineering của Carnegie Mellon. Sách chính là Software Engineering at Google, đọc miễn phí bản HTML. Lời khuyên: học bằng một dự án nhóm thật, dù nhỏ. Rủ hai, ba người bạn làm một ứng dụng trong một tháng: dùng Git từ ngày đầu, mỗi thay đổi đi qua một pull request, mỗi tuần nhờ một người ngoài nhóm dùng thử. Xung đột, review, ước lượng sai — những bài học này chỉ thấm khi tự mình gặp.

Tài liệu tham khảo

  • Peter Naur, Brian Randell (biên tập) — Software Engineering: Report on a Conference Sponsored by the NATO Science Committee, Garmisch, 7–11/10/1968 (xuất bản 1969).
  • Winston W. Royce — Managing the Development of Large Software Systems, Proceedings of IEEE WESCON, 1970.
  • Frederick P. Brooks Jr. — The Mythical Man-Month: Essays on Software Engineering, Addison-Wesley, 1975; bản kỷ niệm 20 năm (1995) in kèm bài No Silver Bullet.
  • Melvin E. Conway — How Do Committees Invent?, tạp chí Datamation, 4/1968.
  • Manifesto for Agile Software Development (agilemanifesto.org), 2001.
  • Ken Schwaber, Jeff Sutherland — The Scrum Guide (scrumguides.org), bản 2020.
  • Titus Winters, Tom Manshreck, Hyrum Wright — Software Engineering at Google, O'Reilly, 2020; bản HTML miễn phí tại abseil.io/resources/swe-book.
  • Ian Sommerville — Software Engineering, bản thứ 10, Pearson, 2015.
  • Scott Chacon, Ben Straub — Pro Git, bản thứ 2, đọc miễn phí tại git-scm.com/book (tài liệu chính thức của Git).
  • NPTEL — Software Engineering (IIT Kharagpur, Rajib Mall); Carnegie Mellon 17-313 Foundations of Software Engineering (Christian Kästner, Michael Hilton, 2018); University of British Columbia — Software Engineering: Introduction (Reid Holmes, edX).

Ban biên tập OpenER, “Nhập môn công nghệ phần mềm: làm phần mềm cùng nhau, và giữ cho nó sống lâu”, OpenER, 2026. Phát hành theo CC BY 4.0: được chia sẻ, chỉnh sửa, kể cả thương mại, miễn ghi công tác giả và dẫn link bài gốc.