Cosa devo fare per NON rubare il codice "Hello World" con una licenza GPL?

Nel progetto, ho trovato un file math.c, con una grande intestazione GPL e ...

//------------------------------------------------------------------------------
/// Returns the minimum value between two integers.
/// \param a  First integer to compare.
/// \param b  Second integer to compare.
//------------------------------------------------------------------------------
unsigned int min(unsigned int a, unsigned int b)
{
    if (a < b) {
        return a;
    }
    else {
        return b;
    }
}

OK, bello, quindi ho bisogno di ottenere il valore minimo e ... questo file !? Quindi ho bisogno di aprire l'intero progetto per questo? O devo reinventare la matematica?

Non credo che sia semplicemente folle, quindi la domanda è: quando possiamo semplicemente rimuovere l'intestazione GPL?

Devo essere uno strano e farlo ?

unsigned int min(             unsigned int
JEIOfuihFHIYEFHyigHUEFGEGEJEIOFJOIGHE,
unsigned int hyrthrtRERG            ) {  if
(JEIOfuihFHIYEFHyigHUEFGEGEJEIOFJOIGHE
< hyrthrtRERG            ) {  return JEIOfuihFHIYEFHyigHUEFGEGEJEIOFJOIGHE;  }
else {return hyrthrtRERG            ;    } }

Seriamente, vogliono che scriva codice come sopra?

A differenza di molti degli utenti qui, vorrei semplicemente suggerire: copiarlo!

Assicurati che la formattazione del codice corrisponda al tuo standard di codifica e che probabilmente dovresti rimuovere o riscrivere il commento. Nessuno saprà mai che l'hai copiato: quando un pezzo di codice è così semplice, potresti anche averlo scritto da zero. Se il tuo standard di codifica in qualche modo richiede che la funzione appaia esattamente come nel frammento, così sia - purché sembri come se l'avessi scritta da zero.

Pensaci, questa è appena (!) La prima volta che questo esatto pezzo è stato scritto - quando qualcosa è così banale, ci sono poche ragioni per non copiarlo, se non hai voglia di scriverlo da solo.

Anche avere questa discussione mi sembra un po 'superfluo: dobbiamo essere pragmatici se vogliamo fare un vero lavoro!

Non risponde direttamente alla tua domanda, ma prova questo:

#define min(a,b) ((a) < (b) ? (a) : (b))

Con la presente rilascio questa macro gloriosa e complessa di dominio pubblico. Anche se potrei dover pubblicare un articolo su questa tecnica.

Se sei macro-fobico, prova questa versione in linea (davvero, a meno che tu non stia codificando su uno SPARC, risparmierai molti cicli della CPU non avvolgendo una funzione onnipresente come minnel codice di invio / uscita):

inline int min(int a, int b)
{
    return a < b ? a : b;
}

La questione della concessione di licenze di codice per frammenti banali è un po 'fastidiosa, davvero. Verificare con un avvocato, ma sono tentato di supporre che non possano davvero essere autorizzati e / o che le licenze non possano essere applicate nella pratica. Come se non fosse possibile tutelare il copyright o il marchio commerciale della parola "parola", quindi affidarsi alle persone che la usano. (Oops)

Disclaimer : non sono un avvocato. Usa il mio consiglio a tuo rischio e pericolo.

Questa implementazione di nonmin è copyrightable , poiché ci sono solo pochissimi modi ragionevoli per scriverlo.

Nel mondo legale, questa è conosciuta come la dottrina della fusione (nota anche come divisione idea-espressione). Si dice che l' idea (non copyrightable) della funzione si sia "unita" con l' espressione (potenzialmente copyrightable) . Pertanto, il codice non è soggetto a copyright: sei libero di usarlo.

Per essere al sicuro, non copiarlo alla lettera . Usa nomi diversi per le variabili, applica la tua formattazione, non copiare i commenti parola per parola. L'esatta rappresentazione letterale di questo codice può essere coperta da copyright.

Tieni presente che questo non garantisce che qualcuno non ti farà causa, ma almeno avrai una forte difesa.

Inoltre, tieni presente che anche se un pezzo di codice non è protetto da copyright, potrebbe comunque essere coperto da un brevetto software (non è il caso della tua minfunzione).

Sto rilasciando il seguente codice con la licenza BSD . Dato che la licenza è molto più permissiva, non dovresti incorrere in problemi di copyright se usi la mia implementazione.

unsigned int min(unsigned int a, unsigned int b)
{
    return (a > b? b: a);
}

È una situazione assurda, sono d'accordo, ma hai solo te stesso da incolpare. Se stai scrivendo un codice proprietario, non dovresti leggere i file sorgente con licenza GPL, punto. Rimuovi math.c dal tuo filesystem, conserva la documentazione e sentiti libero di implementare nuovamente qualsiasi parte dell'API di cui hai bisogno. Se non leggi il codice, non devi preoccuparti se il tuo codice risulta simile.

Spreco, dici? La GPL impedisce intenzionalmente di beneficiare del codice gratuito senza restituire all'ecosistema. Se non puoi o non rispetti i suoi termini e non vuoi implementare ancora un'altra libreria matematica, puoi sempre acquistarne una o trovarne una gratuita fornita con una licenza che puoi accettare.

I programmatori di Microsoft non sono autorizzati a leggere codice open source per proteggere l'azienda da problemi legali. Per motivi puramente etici, dovresti fare lo stesso con qualsiasi programma a cui non intendi aderire.

Non hai il diritto di utilizzare questo math.c, ma nessuno sta cercando di spaccare il mercato sulle implementazioni di min. L'obiettivo della GPL è aumentare la "libertà" del programmatore (e la libertà dell'utente finale), non limitarla. La licenza GNU, la FSF e il movimento per il software libero sono iniziati con Richard Stallman e Stallman ha iniziato con la reimplementazione da zero ogni nuova versione di Symbolics lisp non appena è uscita. La FSF non voleva (e non poteva) cercare nessuno per la reimplementazione di una libreria GPL.

Risposta: Solo con esplicito permesso dell'autore.

Questo è un codice protetto da copyright. Non è possibile copiarlo senza il permesso dell'autore.

Dovrai scrivere la tua versione mino copiare una variante minche utilizza una licenza diversa.

Ricorda, con il copyright, è il codice che è protetto, non l'algoritmo. La legge sul copyright deriva dal testo. Anche se "math.c" non era altro che commenti e non aveva alcun codice eseguibile, sarebbe comunque protetto da copyright.

Questo è ciò che Google presumibilmente ha fregato. Sembra un buon senso per un array.

 908     /**
 909      * Checks that fromIndex and toIndex are in range, and throws an
 910      * appropriate exception if they aren't.
 911      *
 912      * @param arrayLen the length of the array
 913      * @param fromIndex the index of the first element of the range
 914      * @param toIndex the index after the last element of the range
 915      * @throws IllegalArgumentException if fromIndex > toIndex
 916      * @throws ArrayIndexOutOfBoundsException if fromIndex < 0
 917      *         or toIndex > arrayLen
 918      */
 919     private static void rangeCheck(int arrayLen, int fromIndex, int toIndex) {
 920         if (fromIndex > toIndex)
 921             throw new IllegalArgumentException("fromIndex(" + fromIndex +
 922                        ") > toIndex(" + toIndex+")");
 923         if (fromIndex < 0)
 924             throw new ArrayIndexOutOfBoundsException(fromIndex);
 925         if (toIndex > arrayLen)
 926             throw new ArrayIndexOutOfBoundsException(toIndex);
 927     }

Non userò questo codice comunque, perché il commento non corrisponde a quello che fa il codice. Il commento parla integer, mentre il codice usa unsigned int. Chi sa quali errori sono sepolti nelle profondità di questa funzione?

Seriamente, è qui che "Non reinventare la ruota" diventa ridicolo e ti sei dimenticato di prenderlo con un granello di sale. Scrivi la tua versione da zero, abbinala alla convenzione di denominazione e alla guida di stile del tuo codice (ad es. math_min_uint(x, y)), Assicurati che funzioni (unit test o altro) e continua con la vita e senza problemi di copyright.

Con la crescente esperienza, questi banali frammenti di cui hai bisogno ancora e ancora sono solo nella tua cassetta degli attrezzi e li riscriverai senza pensarci troppo o semplicemente li otterrai dalla tua libreria.

Le persone sembrano dimenticare che la legge sul copyright, sia nello spirito che nella lettera, significa che l'atto di copiare realmente è proibito - non l'atto di esprimere lo stesso pensiero da soli, anche se il risultato risulta sospettosamente simile.

Se prendi il codice GPL, lo modifichi, lo usi in modo contrario alla licenza in base alla quale lo hai ricevuto e affermi che non è un'opera derivata, allora stai violando la legge. Anche se usi la tua seconda versione, hai cambiato i nomi di tutte le variabili e modificato la formattazione, ma è comunque derivato dall'originale.

Se, tuttavia, scrivi la tua versione di min, e a causa della banalità del compito, il fatto che ci sono solo così tanti modi in cui puoi sensibilmente scrivere una cosa del genere, e un po 'di coincidenza, la tua versione finisce per essere esattamente identica nel codice GPL'd, quindi non hai copiato nulla.

Se una delle due storie sarebbe passata in tribunale è comunque una questione diversa. Se un campione di codice più grande o più complesso viene visualizzato da qualche altra parte, completo di commenti, formattazione ed errori di ortografia, avrai difficoltà a convincere chiunque lo abbia scritto in modo indipendente, tanto più se si può dimostrare che si conosceva l'originale fonte (che, dato che l'hai pubblicato qui, dovrebbe essere abbastanza banale).

Se il codice è davvero banale come l'esempio "min", c'è un'alta probabilità che qualcun altro abbia già implementato la stessa funzionalità con una diversa licenza open source.

A seconda della licenza, è possibile che sia possibile includere il codice nell'applicazione chiusa.

Scrivilo tu stesso in 30 secondi. Puoi usare esattamente lo stesso algoritmo. Basta non copiare / incollare.

Il copyright protegge solo l'espressione di un'idea, non l'idea stessa. Puoi utilizzare l'idea direttamente a condizione che non la copi.

FWIW, dubito che copiare un codice così banale ti metterebbe comunque nei guai. I danni sarebbero zero e probabilmente rientrerebbero nel giusto uso nella maggior parte delle giurisdizioni. Ma i casi legali sono un tale dolore che non vorrei rischiare.

Come suo codice GPL la grande domanda qui è che stai pianificando di distribuire il tuo codice o vendere il tuo software.

Se lo stai usando solo internamente, la GPL ti dà la completa libertà di fare ciò che desideri.

Se hai intenzione di distribuire il tuo pacchetto, la cosa più semplice è GPL il tuo pacchetto alle stesse condizioni di qualsiasi fonte GPL che hai usato. Ci sono altri modi ma diventa complicato.

Se hai intenzione di vendere il tuo software, devi distribuire il codice sorgente per qualsiasi codice GPL che hai usato e / o modificato con la stessa licenza GPL con cui lo hai ottenuto.

Se stai usando C ++ e non C, elimina questo problema usando la libreria standard std::mino std::maxin <algorithm>:

http://www.cplusplus.com/reference/algorithm/min/

Questo ti compra generalità e funzionerà per qualsiasi tipo comparabile. Inoltre: quando qualunque d-bag proverà a dichiarare di averlo inventato ed è coperto da brevetti software, romperanno con il comitato ISO ... non tu.

Nel caso generale, prendere nota di chi ha pubblicato il codice. Società o individuo sano di mente? Se è un individuo sano di mente (come nel caso di molti open source), scrivi una bella nota a loro e ottieni il permesso. Salva la loro risposta dicendo che va bene. Problema risolto.

Per il caso generale: codice più complesso che è sicuramente in grado di proteggere il copyright, al contrario di min e max (che può o meno essere in grado di proteggere il copyright).

Quindi autorizza il tuo codice in conformità con la libreria ie GPL! Si noti tuttavia che ci sono librerie LGPL (e GPL con eccezioni) che ti consentono di utilizzare le loro implementazioni dando al tuo codice la licenza che desideri.