C++ डेवलपर के जीवन का एक दिन: कोड, डेडलाइन और जादू

सुबह: कॉफी, कोड और संदर्भ स्विचिंग

घड़ी 9:15 दिखाती है। आप लैपटॉप खोलते हैं, अपने अंदर कॉफी का पहला कप डालते हैं और Slack देखते हैं। 23 अपठित संदेश, बिल्ड फेल होने की तीन सूचनाएँ और एक टीम लीड से संक्षिप्त संदेश: "कोड रिव्यू देखो, वहाँ तुम्हारा बग प्रोडक्शन में है"। सुप्रभात, C++ डेवलपर। आपका दिन प्लानिंग मीटिंग से नहीं, बल्कि मेमोरी डंप और stack trace पढ़ने से शुरू होता है।

C++ डेवलपर का एक सामान्य कार्य दिवस - नया कोड लिखने, legacy को डीबग करने और संचार के बीच एक निरंतर संतुलन है। Java या Python के विपरीत, जहाँ "बस काम करता है" थोड़ा अधिक बार मिलता है, C++ में हर पंक्ति छह महीने बाद आपको नुकसान पहुँचा सकती है। इसलिए सुबह कल की समस्याओं को सुलझाने का समय है।

पहली कार्रवाई: CI/CD की जाँच

आप Jenkins (या GitLab CI) खोलते हैं - बिल्ड फेल हो गया है। Linter ने छोड़ दिया, और GCC 13 कंपाइलर ने एक रहस्यमयी त्रुटि दी। मामला क्या है? हम देखते हैं:

// उदाहरण: किसी ने move semantics के बारे में भूल गया\nstd::vector<std::string> getNames() {\n    std::vector<std::string> names = {"Alice", "Bob"};\n    return names; // NRVO काम करेगा, लेकिन हमेशा नहीं\n}\n\n// और ऐसा नहीं करना चाहिए:\nstd::vector<std::string> getNamesBad() {\n    std::vector<std::string> names;\n    names.push_back("Charlie");\n    return std::move(names); // NRVO को रोकता है!\n}\n

आप इसे ढूंढते हैं और ठीक करते हैं। फिक्स पुश करते हैं। CI हरा हो जाता है। जी सकते हैं। लेकिन यह तो केवल शुरुआत है।

प्लानिंग मीटिंग: C++ डेवलपर क्यों कहता है "यह जितना लगता है उससे कहीं अधिक जटिल है"?

10:00 बजे - daily standup। हर कोई बताता है कि उसने कल क्या किया। आप कहते हैं: "इमेज प्रोसेसिंग मॉड्यूल को रिफैक्टर किया, raw pointers को smart pointers में बदला"। कोई जूनियर पूछता है: "क्यों? तो काम तो कर रहा था"। आप आह भरते हैं और समझाते हैं कि आधुनिक C++ में raw pointers बिना नक्शे के माइनफील्ड पर चलने जैसे हैं। टीम लीड सिर हिलाता है। जूनियर अपनी नोटबुक में लिखता है: "RAII सीखना है"।

इस प्लानिंग मीटिंग में, वैसे, C++ डेवलपर के लिए एक दिलचस्प कार्य सामने आता है: पुराने मॉड्यूल को void* से टाइप-सेफ std::variant में फिर से लिखना। यह एक सामान्य दिनचर्या है - C++ प्रोजेक्ट में C-शैली की विरासत से लड़ना।

मुख्य कार्य: कोड, बग और टेम्पलेट्स का जादू

प्लानिंग मीटिंग के बाद आप मुख्य कार्य में डूब जाते हैं। आज - कॉन्फिग पार्स करने के लिए एक नए एल्गोरिदम का कार्यान्वयन। आवश्यकता: JSON से अधिक प्रदर्शन और सख्त टाइपिंग। आप std::optional और std::expected (C++23 से, लेकिन अभी Boost के माध्यम से उपलब्ध) का उपयोग करने का निर्णय लेते हैं।

कोड लिखना: सुरक्षित पार्सिंग

आप एक फंक्शन बनाते हैं जो std::optional<Config> लौटाता है। यदि पार्सिंग विफल होती है - तो आप std::nullopt लौटाते हैं। बिना exceptions, बिना nullptr, बिना undefined behavior के।

#include <optional>\n#include <string>\n#include <fstream>\n\nstruct Config {\n    int port;\n    std::string host;\n    bool debug;\n};\n\nstd::optional<Config> parseConfig(const std::string& path) {\n    std::ifstream file(path);\n    if (!file.is_open()) {\n        return std::nullopt;\n    }\n    Config cfg;\n    file >> cfg.port >> cfg.host >> cfg.debug;\n    if (file.fail()) {\n        return std::nullopt;\n    }\n    return cfg;\n}\n\n// उपयोग:\nauto config = parseConfig("app.cfg");\nif (config) {\n    std::cout << "Port: " << config->port << "\\n";\n} else {\n    std::cerr << "Failed to parse config\\n";\n}\n

आप मेमोरी लीक (valgrind), गति (perf) और शुद्धता (asan) के लिए कोड की जाँच करते हैं। सब कुछ साफ है। आप कमिट करते हैं। लेकिन जल्दी खुश न हों - एक घंटे बाद QA से बग रिपोर्ट के साथ एक संदेश आएगा।

दोपहर का भोजन और Rust के बारे में बातचीत

13:00 बजे - दोपहर का भोजन। कैंटीन में सहकर्मी समाचार पर चर्चा कर रहे हैं: कोई Rust में लिख रहा है, कोई C++20 पर स्विच कर रहा है। आप बीच में कहते हैं: "और मैंने कल आखिरकार std::jthread और cancellation tokens समझ लिया"। कोई भी समझ नहीं पाया