#software-engineering
41 bài viết về chủ đề này
Algorithm Speed — Đừng chỉ code, hãy biết code chạy nhanh thế nào (Pragmatic Programmer #39)
Cảm nhận về Topic 39 'Algorithm Speed' trong sách The Pragmatic Programmer — Big O notation, ước lượng tốc độ thuật toán, và cách áp dụng vào thực tế coding hằng ngày.
Programming by Coincidence — Đừng để may mắn quyết định chất lượng code (Pragmatic Programmer #38)
Topic 38 từ The Pragmatic Programmer: Programming by Coincidence — lập trình dựa vào sự tình cờ, tại sao nó nguy hiểm và làm sao để lập trình một cách có chủ đích.
Listen to Your Lizard Brain — Lắng nghe trực giác khi code (Pragmatic Programmer #37)
Khám phá Topic 37: Listen to Your Lizard Brain từ The Pragmatic Programmer. Học cách lắng nghe trực giác và 'lizard brain' để code hiệu quả hơn.
Blackboards — Khi Code Nói Chuyện Qua Một Cái Bảng Đen (Pragmatic Programmer #36)
Topic 36 'Blackboards' từ 'The Pragmatic Programmer' dạy chúng ta về mô hình blackboard — nơi các module trao đổi dữ liệu ẩn danh và bất đồng bộ, giống như các thám tử cùng phá án trên một cái bảng đen.
Actors và Processes — Khi concurrency không cần shared state (Pragmatic Programmer #35)
Cảm nhận về Topic 35 'Actors and Processes' — cách xây dựng hệ thống concurrent không shared memory, không lock, không deadlock nhờ actor model.
Shared State Is Incorrect State — Trạng thái dùng chung là trạng thái sai (Pragmatic Programmer #34)
Topic 34 từ cuốn The Pragmatic Programmer: Shared State Is Incorrect State — giải thích về race condition, nonatomic updates, semaphore/mutex, và cách tránh shared state trong lập trình đồng thời.
Breaking Temporal Coupling — Phá Vỡ Sự Phụ Thuộc Theo Thời Gian (Pragmatic Programmer #33)
Cảm nhận về Topic 33 trong chương Concurrency của The Pragmatic Programmer: Temporal Coupling là gì, tại sao nó nguy hiểm và cách break nó để code linh hoạt hơn.
Topic 32. Configuration — Đừng Hard-code, Hãy Cấu Hình! (Pragmatic Programmer #32)
Một trong những bài học đắt giá nhất: tách rời code khỏi cấu hình. Học cách viết phần mềm linh hoạt, dễ thay đổi mà không cần sửa code.
Topic 31. Inheritance Tax — Đừng trả 'thuế' kế thừa nữa (Pragmatic Programmer #31)
Inheritance là coupling, và coupling là kẻ thù của sự thay đổi. Tìm hiểu 3 alternatives mạnh mẽ thay thế inheritance từ 'The Pragmatic Programmer'.
Transforming Programming — Biến Đổi Dữ Liệu Trong Code (Pragmatic Programmer #30)
Cảm nhận về Topic 30 trong The Pragmatic Programmer: cách nhìn lập trình như chuỗi transformation dữ liệu giúp code sạch và dễ maintain hơn.
Juggling the Real World — Làm sao để code chạy giữa đời thực? (Pragmatic Programmer #29)
Cảm nhận về Topic 29: Juggling the Real World - Bốn chiến lược xử lý sự kiện trong thế giới thực: Finite State Machines, Observer Pattern, Pub/Sub và Reactive Programming.
Decoupling — Tách Biệt Code Để Dễ Thay Đổi (Pragmatic Programmer #28)
Cảm nhận về Topic 28 Decoupling trong chương Bend or Break của sách The Pragmatic Programmer. Học cách viết code linh hoạt, ít phụ thuộc để dễ maintain và mở rộng.
Đừng Chạy Nhanh Hơn Tầm Nhìn Của Mình! — Don't Outrun Your Headlights (Pragmatic Programmer #27)
Pragmatic Programmer Topic 27 — Don't Outrun Your Headlights: bài học về việc chỉ nên tiến xa trong tầm nhìn của mình, lấy feedback làm tốc độ giới hạn.
Topic 26. How to Balance Resources — Cân Bằng Tài Nguyên (Pragmatic Programmer #26)
Cảm nhận về cách cân bằng tài nguyên trong lập trình từ cuốn The Pragmatic Programmer. Tip thực tế để tránh leak memory, file và các resource khác.
Think Like a Programmer #9 — Chương 8: Tư duy như một lập trình viên — Master Plan của riêng bạn
Kết thúc series cảm nhận 'Think Like a Programmer' của V. Anton Spraul — Chương 8: master plan cá nhân, điểm mạnh/yếu, cheating hangman, và bài học cuối cùng về tư duy lập trình viên.
Topic 25. Assertive Programming — Lập trình quyết đoán (Pragmatic Programmer #25)
Assertive Programming dạy chúng ta đừng bao giờ tin vào câu 'chuyện này không bao giờ xảy ra'. Dùng assertion để ngăn chặn những điều tưởng như impossible — Tip 39 của The Pragmatic Programmer.
Think Like a Programmer — Chương 8: Solving Problems with Code Reuse (Tái sử dụng mã nguồn)
Cảm nhận về Chương 8 sách Think Like a Programmer: nghệ thuật tái sử dụng code, cân bằng giữa NIH syndrome và copy-paste programming, và cách dùng code người khác một cách thông minh.
Dead Programs Tell No Lies — Crash Early, Don’t Trash (Pragmatic Programmer #24)
Topic 24 trong chương Pragmatic Paranoia: Tại sao chương trình chết lại tốt hơn là chương trình 'bị thương' và tiếp tục chạy? Cảm nhận của mình sau khi đọc.
Think Like a Programmer #7 — Đệ quy: Khi hàm gọi lại chính mình
Cảm nhận Chương 6 sách Think Like a Programmer của V. Anton Spraul — Big Recursive Idea, head vs tail recursion, đệ quy với linked list và binary tree.
Topic 23. Design by Contract — Hợp đồng trong code (Pragmatic Programmer #23)
Design by Contract (DBC) là một trong những nguyên lý quan trọng nhất của Pragmatic Programmer — giúp phân định trách nhiệm giữa các module bằng hợp đồng rõ ràng. Preconditions, Postconditions và Class Invariants là nền tảng.
Think Like a Programmer #6 — Lớp đối tượng: Từ code chạy được đến code có kiến trúc
Cảm nhận Chương 5 sách Think Like a Programmer của V. Anton Spraul — class, encapsulation, Rule of Three, interface design, và tư duy thiết kế phần mềm
Engineering Daybooks — Ghi chép hàng ngày cho lập trình viên (Pragmatic Programmer #22)
Tại sao một cuốn sổ tay và cây bút lại là công cụ mạnh mẽ nhất mà một lập trình viên có thể sở hữu? Bài học từ Topic 22 của The Pragmatic Programmer về engineering daybooks.
Think Like a Programmer #5 — Con trỏ và Bộ nhớ Động: Khi "địa chỉ" là chìa khoá
Cảm nhận Chương 4 sách Think Like a Programmer của V. Anton Spraul — con trỏ, bộ nhớ động, linked list, memory leak, và cách tư duy về memory ownership
Text Manipulation — Đừng Viết Code Khi Có Tool Sẵn (Pragmatic Programmer #21)
Cảm nhận về Topic 21 trong The Pragmatic Programmer. Học cách tận dụng sed, awk, Perl để thao tác văn bản hiệu quả thay vì viết code thủ công.
Think Like a Programmer #4 — Solving Problems with Arrays: Khi dữ liệu cần được tổ chức
Cảm nhận Chương 3 sách Think Like a Programmer của V. Anton Spraul: mode, lookup tables, non-scalar arrays, và tư duy tổ chức dữ liệu với array.
Debugging — Tâm lý và cách tiếp cận đúng khi fix bug (Pragmatic Programmer #20)
Cảm nhận về Topic 20 Debugging trong The Pragmatic Programmer. Bình tĩnh thu thập dữ liệu, dùng debugger, và coi bug là cơ hội học hỏi.
Think Like a Programmer #2 — Pure Puzzles: Khi 'bài toán thuần tuý' mới thấy mình yếu ở đâu
Chương 2 của Think Like a Programmer dạy về giải quyết những bài toán 'thuần tuý' — nơi cú pháp đơn giản nhất nhưng tư duy mới là thử thách thật sự.
Version Control — The Basic Tools (Pragmatic Programmer #19)
Cảm nhận về Topic 19 Version Control trong The Pragmatic Programmer. Tại sao version control là công cụ cơ bản quan trọng nhất cho dev.
Think Like a Programmer #1: Strategies for Problem Solving — Bài Học Đầu Tiên Về Tư Duy Giải Quyết Vấn Đề
Mở đầu series cảm nhận 'Think Like a Programmer' của V. Anton Spraul. Chương 1: Strategies for Problem Solving — 8 chiến lược giải quyết vấn đề mà lập trình viên nào cũng cần.
Power Editing — The Pragmatic Programmer #18
Cảm nhận về Topic 18 Power Editing trong cuốn The Pragmatic Programmer. Học cách dùng editor mạnh mẽ để tăng năng suất lập trình.
Think Like a Programmer: Introduction — Tư duy khác biệt giữa học cú pháp và giải quyết vấn đề
Cảm nhận về Introduction sách Think Like a Programmer của V. Anton Spraul: tại sao học cú pháp khác với học giải quyết vấn đề, và cạm bẫy Kobayashi Maru trong lập trình.
🐚 Shell Games — Làm chủ terminal, làm chủ công cụ (Pragmatic Programmer #17)
Shell Games (Topic 17) trong The Pragmatic Programmer so sánh terminal với bàn làm việc của người thợ mộc. Tại sao lập trình viên cần làm chủ command line?
The Power of Plain Text — Sức mạnh của sự đơn giản (Pragmatic Programmer #16)
Topic 16 của The Pragmatic Programmer nói về plain text — thứ tưởng xưa mà hoá ra là vũ khí lợi hại nhất của lập trình viên.
Estimating — Nghệ thuật ước lượng (Pragmatic Programmer #15)
Topic 15 của The Pragmatic Programmer nói về estimating — kỹ năng ước lượng mà dev nào cũng cần rèn. Làm sao để ước lượng trung thực, không biến estimate thành commit.
Domain Languages — Ngôn ngữ của riêng bài toán mình (Pragmatic Programmer #14)
Topic 14 trong series The Pragmatic Programmer: Domain Languages — xây dựng ngôn ngữ nhỏ cho riêng bài toán, giúp code gần gũi với domain hơn và dễ maintain hơn.
Prototypes and Post-it Notes — Học hỏi, không phải để dùng lại (Pragmatic Programmer #13)
Topic 13 trong series The Pragmatic Programmer: Prototypes and Post-it Notes — một trong những topic làm mình suy nghĩ lại rất nhiều về cách mình vẫn thường làm việc. Prototype không chỉ dành cho code, mà còn có thể dùng Post-it Notes để thiết kế UI nữa cơ!
Orthogonality — Khi 'mỗi thứ lo việc của mình' là chìa khóa của code sạch
Tính trực giao (orthogonality) giúp code dễ bảo trì, dễ mở rộng và ít bug hơn. Cùng mình tìm hiểu qua góc nhìn từ cuốn The Pragmatic Programmer.
DRY — The Evils of Duplication: Khi 'đừng lặp code' bị hiểu sai
DRY không phải là đừng copy-paste code, mà là đừng lặp kiến thức. Cùng mình ôn lại một trong những nguyên lý quan trọng nhất của lập trình viên qua góc nhìn từ cuốn The Pragmatic Programmer.
Stone Soup và Boiled Frogs — Chuyện nấu súp với luộc ếch trong Pragmatic Programmer
Topic 4 trong The Pragmatic Programmer kể hai câu chuyện ngụ ngôn: Stone Soup dạy chủ động, Boiled Frogs dạy tỉnh táo.
🧹 Software Entropy — Tại sao "cửa sổ vỡ" lại nguy hiểm?
Cảm nhận về Topic 3: Software Entropy trong The Pragmatic Programmer — tại sao cửa sổ vỡ lại nguy hiểm với codebase của bạn?
The Pragmatic Programmer — Hành trình lập trình viên trách nhiệm
Topic 2: The Cat Ate My Source Code — Nghe cái tên hài hước vậy thôi, nhưng nội dung bên trong lại nói về một trong những phẩm chất quan trọng nhất của một lập trình viên: tinh thần trách nhiệm.