मैं अपनी कंपनी के गोपनीय शोध कोड से ओपन सोर्स कोड रिलीज़ बनाने का सबसे अच्छा प्रबंधन कैसे कर सकता हूं?

Question

मेरी कंपनी (चलो उन्हें एक्मे टेक्नोलॉजी कहते हैं) के पास लगभग एक हजार स्रोत फ़ाइलों का एक पुस्तकालय है जो मूल रूप से अपने एकमे लैब्स अनुसंधान समूह से आया है, एक दो वर्षों के लिए एक विकास समूह में संलग्न है, और हाल ही में कुछ मुट्ठी भर ग्राहकों को प्रदान किया गया है गैर प्रकटीकरण। एक्मे खुले स्रोत समुदाय के लिए कोड का शायद 75% रिलीज करने के लिए तैयार हो रहा है। अन्य 25% बाद में जारी किया जाएगा, लेकिन अभी के लिए, या तो ग्राहक उपयोग के लिए तैयार नहीं है या भविष्य के नवाचारों से संबंधित कोड शामिल हैं जो उन्हें प्रतियोगियों के हाथों से बाहर रखने की आवश्यकता है।

कोड वर्तमान में #ifdefs के साथ स्वरूपित किया गया है जो पूर्व-उत्पादन प्लेटफार्मों के साथ काम करने के लिए एक ही कोड आधार की अनुमति देता है जो विश्वविद्यालय के शोधकर्ताओं और वाणिज्यिक ग्राहकों की एक विस्तृत श्रृंखला के लिए उपलब्ध होगा, जबकि यह एक ही समय में खुला स्रोत पर जाता है। भविष्य के मंच के साथ प्रयोग और प्रोटोटाइप और आगे संगतता परीक्षण के लिए उपलब्ध है। एक भी कोड आधार रखते हुए अपने समूह के अर्थशास्त्र (और विवेक) जो एक कठिन समय समानांतर में दो प्रतियां बनाए रखने के लिए होता है के लिए आवश्यक माना जाता है।

हमारे वर्तमान आधार की फाइलें कुछ इस तरह दिखती हैं:

> // Copyright 2012 (C) Acme Technology, All Rights Reserved.
> // Very large, often varied and restrictive copyright license in English and French,
> // sometimes also embedded in make files and shell scripts with varied 
> // comment styles. 
> 
> 
>   ... Usual header stuff...
>
> void initTechnologyLibrary() {
>     nuiInterface(on);
> #ifdef  UNDER_RESEARCH
>     holographicVisualization(on);
> #endif
> }

और हम उन्हें कुछ इस तरह बदलना चाहते हैं:

> // GPL Copyright (C) Acme Technology Labs 2012, Some rights reserved.
> // Acme appreciates your interest in its technology, please contact [e-mail] 
> // for technical support, and www.acme.com/emergingTech for updates and RSS feed.
> 
>   ... Usual header stuff...
>
> void initTechnologyLibrary() {
>     nuiInterface(on);
> }

क्या कोई उपकरण, पार्स लाइब्रेरी, या लोकप्रिय स्क्रिप्ट है जो कॉपीराइट की जगह ले सकती है और न केवल #ifdefs से स्ट्रिप कर सकती है, बल्कि #if परिभाषित (UNDER_RESEARCH), आदि जैसी विविधताएं भी हो सकती हैं?

कोड वर्तमान में Git में है और संभवतः Git का उपयोग करने वाले कहीं होस्ट किया जाएगा। क्या रिपोजिटरी को सुरक्षित रूप से जोड़ने का एक तरीका होगा ताकि हम खुले स्रोत संस्करणों के साथ अपने सुधारों को कुशलता से लागू कर सकें? अन्य नुकसानों के बारे में सलाह का स्वागत है।

Comments

यह कोडबेस शाखाओं के लिए चिल्ला रहा है।

— फ्लोरियन मार्गाइन

इस उद्देश्य के लिए शाखाओं का उपयोग करने का एक उदाहरण सबसे स्वागत योग्य होगा।

— DeveloperDon

Answer 1

ऐसा लगता है कि यह बहुत मुश्किल preprocessors पार्स करने के लिए एक स्क्रिप्ट लिखने के लिए नहीं होगा, उन्हें परिभाषित स्थिरांक (की एक सूची से तुलना UNDER_RESEARCH, FUTURE_DEVELOPMENTआदि) और, अगर निर्देश झूठी दिए गए क्या परिभाषित किया है, ऊपर निकालें सब कुछ करने के लिए मूल्यांकन किया जा सकता अगले करने के लिए #endif।

पायथन में, मैं कुछ ऐसा करूँगा;

import os

src_dir = 'src/'
switches = {'UNDER_RESEARCH': True, 'OPEN_SOURCE': False}
new_header = """// GPL Copyright (C) Acme Technology Labs 2012, Some rights reserved.
// Acme appreciates your interest in its technology, please contact [e-mail] 
// for technical support, and www.acme.com/emergingTech for updates and RSS feed.
"""

filenames = os.listdir(src_dir)
for fn in filenames:
    contents = open(src_dir+fn, 'r').read().split('\n')
    outfile = open(src_dir+fn+'-open-source', 'w')
    in_header = True
    skipping = False
    for line in contents:
        # remove original header
        if in_header and (line.strip() == "" or line.strip().startswith('//')):
            continue
        elif in_header:
            in_header = False
            outfile.write(new_header)

        # skip between ifdef directives
        if skipping:
            if line.strip() == "#endif":
                skipping = False
            continue
        # check
        if line.strip().startswith("#ifdef"):
            # parse #ifdef (maybe should be more elegant)
            # this assumes a form of "#ifdef SWITCH" and nothing else
            if line.strip().split()[1] in switches.keys():
                skipping = True
                continue

        # checking for other forms of directives is left as an exercise

        # got this far, nothing special - echo the line
        outfile.write(line)
        outfile.write('\n')

मुझे यकीन है कि इसे करने के लिए और अधिक सुंदर तरीके हैं, लेकिन यह त्वरित और गंदा है और लगता है कि काम पूरा हो जाएगा।

Comments

वाह धन्यवाद। एक अच्छा फिल्टर बनाने के लिए संभावित रूप से बहुत सारे तर्क हैं और मैं आपके उदाहरण की सराहना करता हूं। मुझे पुन: उपयोग के लिए कुछ खोजने की उम्मीद है, और मेरी विकास मशीन एक बड़ी मेमोरी के साथ तेज़ है इसलिए कॉपीराइट और डिफाइन के लिए अलग-अलग फ़िल्टर चलाने या एक से अधिक बार परिभाषित फ़िल्टर चलाने के लिए प्रदर्शन बहुत बड़ी चिंता नहीं है। हमारे पास वास्तव में ऐसे कीवर्ड से संबंधित कई परिभाषित हैं जो भविष्य की कई परियोजनाओं को डिज़ाइन करते हैं और कुछ पिछले प्रोजेक्ट हैं जो खुले स्रोत को जारी नहीं किए जाएंगे, लेकिन फिर भी आंतरिक रूप से और शुरुआती ग्राहकों को अपनाते हुए उपयोग किए जाते हैं।

— DeveloperDon

Answer 2

मैं केवल मैक्रोज़ का विस्तार करने के लिए प्रीप्रोसेसर के माध्यम से आपके कोड को पारित करने के बारे में सोच रहा था, इस प्रकार केवल दिलचस्प भाग का उत्पादन कर रहा हूं #ifdef।

कुछ इस तरह काम करना चाहिए:

gcc -E yourfile.c

परंतु:

• आप सभी टिप्पणियाँ खो देंगे। आप -CCउन्हें संरक्षित कर सकते हैं (तरह तरह के), लेकिन फिर भी आपको पुराने कॉपीराइट नोटिस को हटाना पड़ेगा
• #includes का विस्तार भी किया गया है, इसलिए आप एक बड़ी फ़ाइल के साथ सम्‍मिलित हेडर फ़ाइलों की सभी सामग्री समाप्‍त करेंगे
• आप "मानक" मैक्रोज़ खो देंगे।

मैक्रो को विस्तारित करने के लिए सीमित करने का एक तरीका हो सकता है; हालाँकि यहाँ मेरा सुझाव है कि फाइलों पर (संभावित रूप से खतरनाक) प्रसंस्करण करने के बजाय, चीजों को विभाजित किया जाए (वैसे, आप उन्हें बाद में बनाए रखने की योजना कैसे बनाएंगे? जैसे कि ओपनसोर्स संस्करण से कोड को आपके बंद स्रोत में फिर से डालना?)।

यही है, कोड को आप बाहरी पुस्तकालयों में जितना संभव हो उतना खोलना चाहते हैं, जितना संभव हो सके उतना डालने का प्रयास करें, फिर उन्हें किसी अन्य पुस्तकालय के साथ उपयोग करें, अन्य "कस्टम" बंद-स्रोत पुस्तकालयों के साथ एकीकृत करें।

यह पता लगाने में थोड़ा समय लग सकता है कि चीजों का पुनर्गठन कैसे किया जाए, लेकिन यह निश्चित रूप से इसे पूरा करने का सही तरीका है।

Comments

मैंने विचार किया था कि क्या ऐसा कुछ हो सकता है जो प्रीप्रोसेसर के साथ चुनिंदा ब्लॉक को खत्म कर सकता है जिसे हम अभी तक जारी नहीं करेंगे। कोड जटिल है और हमें कम के बजाय अधिक टिप्पणियों की आवश्यकता होगी, लेकिन आपका सुझाव निश्चित रूप से मंथन सूची में होने के लायक है। डब्ल्यूआरटी सवाल करता है कि हम स्रोत को बनाए रखने और कोड को पिछड़े और समुदाय को आगे बढ़ाने की योजना कैसे बनाते हैं, इसके लिए अधिक योजना की आवश्यकता है। मालिकाना कोड में कोड लाने से कुछ अच्छे सवाल उठते हैं।

— DeveloperDon

Answer 3

मेरे पास इसका हल है लेकिन इसके लिए थोड़ी मेहनत करनी होगी

pypreprocessor एक पुस्तकालय है जो अजगर के लिए एक शुद्ध सी-शैली प्रीप्रोसेसर प्रदान करता है जिसे अन्य प्रकार के स्रोत कोड के लिए GPP (सामान्य प्रयोजन पूर्व-प्रोसेसर) के रूप में भी उपयोग किया जा सकता है।

यहाँ एक मूल उदाहरण दिया गया है:

from pypreprocessor import pypreprocessor

pypreprocessor.input = 'input_file.c'
pypreprocessor.output = 'output_file.c'
pypreprocessor.removeMeta = True
pypreprocessor.parse()

प्रीप्रोसेसर अत्यंत सरल है। यह स्रोत के माध्यम से एक मार्ग बनाता है और जो परिभाषित किया गया है, उसके आधार पर सशर्त रूप से स्रोत से टिप्पणी करता है।

परिभाषित किया जा सकता है या तो स्रोत में # अतिरिक्त बयानों के माध्यम से या उन्हें pypreprocessor.defines सूची में सेट करके।

इनपुट / आउटपुट पैरामीटर सेट करने से आपको स्पष्ट रूप से परिभाषित करने की अनुमति मिलती है कि कौन सी फाइलें खोली / बंद की जा रही हैं ताकि एक ही प्रीप्रोसेसर को वांछित होने पर बड़ी संख्या में बैच प्रक्रिया के लिए सेटअप किया जा सके।

RemoveMeta पैरामीटर को True पर सेट करते हुए, प्रीप्रोसेसर को स्वचालित रूप से केवल पोस्ट-प्रोसेस्ड कोड को छोड़कर किसी भी और सभी प्रीप्रोसेसर स्टेटमेंट को निकालना चाहिए।

नोट: आमतौर पर यह स्पष्ट रूप से सेट करने की आवश्यकता नहीं होगी क्योंकि बाइटकोड के संकलन के दौरान अजगर ने स्वचालित रूप से टिप्पणी कोड हटा दिया।

मैं केवल एक किनारे का मामला देखता हूं। क्योंकि आप C स्रोत को प्रीप्रोसेस करना चाह रहे हैं, इसलिए आप प्रोसेसर को स्पष्ट रूप से परिभाषित कर सकते हैं (यानी pypreprocessor.defines के माध्यम से) और यह बताएं कि स्रोत में #define स्टेटमेंट को अनदेखा करें । इसे गलती से किसी भी स्थिरांक को हटाने से रोकना चाहिए जो आप अपने प्रोजेक्ट के स्रोत कोड में उपयोग कर सकते हैं। वर्तमान में इस कार्यक्षमता को सेट करने के लिए कोई पैरामीटर नहीं है, लेकिन इसे जोड़ना तुच्छ होगा।

यहाँ एक तुच्छ उदाहरण दिया गया है:

from pypreprocessor import pypreprocessor

# run the script in 'production' mode
if 'commercial' in sys.argv:
    pypreprocessor.defines.append('commercial')

if 'open' in sys.argv:
    pypreprocessor.defines.append('open')

pypreprocessor.removeMeta = True
pypreprocessor.parse()

फिर स्रोत:

#ifdef commercial
// Copyright 2012 (C) Acme Technology, All Rights Reserved.
// Very large, often varied and restrictive copyright license in English and French,
// sometimes also embedded in make files and shell scripts with varied 
// comment styles.
#ifdef open
// GPL Copyright (C) Acme Technology Labs 2012, Some rights reserved.
// Acme appreciates your interest in its technology, please contact [e-mail] 
// for technical support, and www.acme.com/emergingTech for updates and RSS feed.
#endif

नोट: जाहिर है, आपको इनपुट / आउटपुट फ़ाइलों को सेट करने के लिए एक तरीके को छाँटना होगा लेकिन यह बहुत मुश्किल नहीं होना चाहिए।

प्रकटीकरण: मैं pypreprocessor का मूल लेखक हूं।

---

एक तरफ: मैंने मूल रूप से इसे खतरनाक अजगर 2k / 3x रखरखाव मुद्दे के समाधान के रूप में लिखा था। मेरा दृष्टिकोण था, एक ही स्रोत फ़ाइलों में 2 और 3 विकास करना और प्रीप्रोसेसर निर्देशों का उपयोग करके मतभेदों को शामिल करना / शामिल करना। दुर्भाग्य से, मैंने मुश्किल तरीके से पता लगाया कि एक सच्चे शुद्ध लिखना असंभव है (अर्थात, सी में प्रीप्रोसेसर की आवश्यकता नहीं है) क्योंकि प्रीप्रोसेसर को चलाने का मौका मिलने से पहले लेक्सर ने असंगत कोड में सिंटैक्स त्रुटियों को चिह्नित किया है। किसी भी तरह से, यह आपकी सहित परिस्थितियों की एक विस्तृत श्रृंखला के तहत अभी भी उपयोगी है।

Comments

यह चट्टानें। यदि हम कुछ और नहीं कर सकते हैं, तो तीन तरह से भिन्न हो सकते हैं जो उन फ़ाइलों को संसाधित करते हैं जिनके साथ और जिस कोड को हम बाहर करना चाहते हैं, उनके बिना, अपने अंतर को ले लिया, फिर मूल से अलग लाइनों को हटा दिया।

— DeveloperDon

@DeveloperDon हां, यह सामान्य विचार है। इसे संभालने के लिए कुछ अलग तरीके हैं, यह इस बात पर निर्भर करता है कि आप किस तरह से कमिट-रिलीज़ साइकिल का प्रबंधन करते हैं। यह टुकड़ा बस बहुत सारे काम को स्वचालित करता है जो अन्यथा थकाऊ और / या त्रुटि का शिकार होगा।

— इवान प्लेट

Answer 4

शायद यह अच्छा विचार होगा

1.dd टिप्पणी टैग की तरह:

> // *COPYRIGHT-BEGIN-TAG*
> // Copyright 2012 (C) Acme Technology, All Rights Reserved.
> // Very large, often varied and restrictive copyright license in English and French,
> // sometimes also embedded in make files and shell scripts with varied 
> // comment styles. 
> // *COPYRIGHT-ENG-TAG*
>   ... Usual header stuff...
>
> void initTechnologyLibrary() {
>     nuiInterface(on);
> #ifdef  UNDER_RESEARCH
>     holographicVisualization(on);
> #endif
> }

2. सभी फ़ाइलों के माध्यम से जाने और COPYRIGHT-BEGIN-TAG और COPYRIGHT-ENG-TAG टैग के बीच पाठ को बदलने के लिए ओपन सोर्स बिल्डर के लिए स्क्रिप्ट लिखें

Comments

क्या मुझे शुरुआती टैग की आवश्यकता है? अब तक हमारी सभी स्रोत फाइलें पहली पंक्ति में कॉपीराइट के साथ शुरू होती हैं, और हमारी शेल स्क्रिप्ट दूसरी पंक्ति में कॉपीराइट के साथ शुरू होती हैं। बहुत सारी फाइलें हैं, इसलिए मैं बहुत कम मात्रा में हस्त संपादन करना चाहता हूं जो संभव है।

— DeveloperDon

मुझे लगता है कि कुछ फाइलें अपने फंक्शन, पैरामीटर और रिटर्न वैल्यू नामों को डिलीट करने के लिए Doxygen का इस्तेमाल कर सकती हैं। उन फ़ाइलों के लिए जो पहले से ही इस तरह से सेटअप नहीं करते हैं, यह वास्तव में बहुत अधिक संपादन हो सकता है अगर हमने एक विकल्प बनाया जो उस दिशा में आगे बढ़ा।

— DeveloperDon

कम से कम आपको इसे एक बार बदलना होगा। यदि आपकी कॉपीराइट नीति बदल गई है तो आप इसे प्रबंधित कर सकते हैं।

— एलेक्स हाशिमी

Answer 5

मैं आपको अपना कोडबेस बदलने के लिए एक टूल दिखाने जा रहा हूं, पहले से ही बहुत सारे जवाब। बल्कि, मैं आपकी टिप्पणी का जवाब दे रहा हूं कि इसके लिए शाखाएं कैसे संभालनी चाहिए।

आपकी 2 शाखाएँ होनी चाहिए:

• समुदाय (आइए इस तरह खुले स्रोत संस्करण को कॉल करें)
• व्यावसायिक (इस तरह बंद स्रोत संस्करण को कॉल करें)

प्रीप्रोसेसर मौजूद नहीं होने चाहिए। आपके दो अलग-अलग संस्करण हैं। और एक क्लीनर कोडबेस कुल मिलाकर।

आप समानांतर में दो प्रतियां बनाए रखने से डरते हैं? चिंता न करें, आप विलय कर सकते हैं!

यदि आप सामुदायिक शाखा में संशोधन कर रहे हैं, तो उन्हें व्यावसायिक शाखा में मिला दें। गिट यह वास्तव में अच्छी तरह से संभालती है ।

इस तरह, आप अपने कोडबेस की 2 अनुरक्षित प्रतियां रखते हैं। और खुले स्रोत के लिए एक को जारी करना पाई के रूप में आसान है।