Sembra molto probabile che tu abbia plagiato e, in tal caso, faresti meglio a procedere riconoscendo il tuo errore piuttosto che continuare a discutere.

Guardando il tuo codice, c'è un ottimo affare che sembra essere stato preso dal file HashMap.java. Sospetto fortemente che tu abbia iniziato con questo codice e poi lo abbia modificato per produrre il tuo codice, o lo abbia seguito da vicino come modello durante la scrittura del tuo. Le sezioni di codice evidenziate hanno raccolto alcune di queste, ma anche altre sezioni assomigliano molto all'altro file, sebbene con commenti e ordinamento leggermente alterati.

In questo caso, il codice che ci hai mostrato è non il tuo lavoro originale ma in realtà una versione plagiata di HashMap.java. Lasciando nelle due linee che sono scollegate è una pistola fumante del collegamento che probabilmente sarà conclusiva per il pannello. Il tuo punto di vista che non sono necessari in realtà conterà contro di te perché non sarai in grado di spiegare perché sono lì. E che questo fosse il tuo intento o meno, è probabile che il pannello (e il tuo professore) vedrà i tuoi commenti e ordini modificati come un tentativo di coprire le tue tracce e nascondere il tuo plagio da strumenti automatici.

È più probabile che il panel mostri clemenza nei confronti di uno studente che sembra almeno essere contrito e riconosce di aver commesso un errore, rispetto a uno studente che nega di aver commesso un errore di fronte a prove apparentemente molto forti.

Il titolo della tua domanda "due righe di codice copiato costituiscono un plagio", non è esattamente accurato, secondo me.

Penso che ti sarà molto difficile sostenere che questo non è Non / non era plagio. Le somiglianze tra il tuo codice e HashMap.java non finiscono su due righe o su un unico "algoritmo comune".

1) Hai scelto la stessa identica capacità predefinita e lo stesso fattore di carico:

  / ** Deve essere una potenza di 2 * / private static final int DEFAULT_CAPACITY = 16; / ** Il fattore di carico * / private static final float DEFAULT_LOAD_FACTOR = 0.75f;  

contro

  // La capacità iniziale predefinita - DEVE essere una potenza di due. int finale statico DEFAULT_INITIAL_CAPACITY = 16; // Il fattore di carico utilizzato quando nessuno è specificato nel costruttore. static final float DEFAULT_LOAD_FACTOR = 0.75f;  

In effetti, il commento "Deve essere una potenza di 2" significa già che sei colto in flagrante, perché, in effetti, c'è nessuna buona ragione per richiedere che la capacità sia una potenza di due nel codice. Il fatto che la dimensione sia una potenza di due viene utilizzato solo per un'ottimizzazione nella versione HashMap.java del codice e questa ottimizzazione non viene utilizzata nel codice. Probabilmente sei fortunato che il consiglio di condotta dello studente non sappia molto di programmazione.

2) I due metodi get sono molto simili:

  public V get (K key) {if (key == null) return null; int hash = key.hashCode ()% data.length; // System.out.printf ("Recupero di% d% d% s \ n", key.hashCode (), hash, // key.toString ()); for (MyEntry<K, V> e = data [hash]; e! = null; e = e.next) {if (e.hash == hash && (e.getKey () == key || key.equals (e. getKey ()))) return e.getValue (); } return null;}  

rispetto

  public V get (Object key) {if (key == null) return getForNullKey (); int hash = hash (key.hashCode ());
for (Entry<K, V> e = table [indexFor (hash, table.length)]; e! = null; e = e.next) {Object k; if (e.hash == hash && ((k = e.key) == key || key.equals (k))) return e.value; } return null;}  

Sembra strano che entrambi abbiate scelto esattamente lo stesso modo molto specifico per fare il confronto delle chiavi (prima confrontando gli hash, poi i puntatori delle chiavi e infine using key.equals).

3) ... così come il put-method:

  public MyEntry<K, V> put (K key , Valore V) {int hash = key.hashCode (); // System.out.printf ("Aggiunta di% d% d% s \ n", key.hashCode (), hash, key.toString ()); int i = hash% data.length; // Collisioni per (MyEntry<K, V> e = data [i]; e! = Null; e = e.next) {if (e.hash == hash && (e.getKey () == key || key.equals (e.getKey ()))) {MyEntry<K, V> old = e; e.setValue (valore); tornare vecchio; }} addEntry (hash, key, value, i); return null;}  

contro

  public V put (K key, V value) {if (key == null) return putForNullKey (value); int hash = hash (key.hashCode ()); int i = indexFor (hash, table.length); for (Entry<K, V> e = table [i]; e! = null; e = e.next) {Object k; if (e.hash == hash && ((k = e.key) == key || key.equals (k))) {V oldValue = e.value; e.value = valore; e.recordAccess (this); return oldValue; }} modCount ++; addEntry (hash, key, value, i); return null;}  

4) ... come lo sono i metodi add e grow :

  void addEntry (int hash, K key, V value, int bucketIndex) {MyEntry<K, V> e = data [bucketIndex];
data [bucketIndex] = new MyEntry<> (hash, key, value, e); keyList.add (chiave); if (size ++ > = threshold) grow ();} / ** * Aumenta l'array 2x dimensione corrente * / private void grow () {int newSize = 2 * data.length; @SuppressWarnings ("unchecked") MyEntry<K, V> [] newArr = new MyEntry [newSize]; // Copia per (int i = 0; i < data.length; i ++) {MyEntry<K, V> e = data [i]; se (e! = null) {data [i] = null; fare {MyEntry<K, V> next = e.next; int j = e.hash% newSize; e.next = newArr [j]; newArr [j] = e; e = successivo; } while (e! = null); }} data = newArr; soglia = (int) (newSize * DEFAULT_LOAD_FACTOR);}  

rispetto a

  void addEntry (int hash, K key, V value, int bucketIndex) { Entry<K, V> e = table [bucketIndex]; table [bucketIndex] = new Entry<> (hash, key, value, e); if (size ++ > = threshold) resize (2 * table.length);} void transfer (Entry [] newTable) {Entry [] src = table; int newCapacity = newTable.length; for (int j = 0; j < src.length; j ++) {Entry<K, V> e = src [j]; se (e! = null) {src [j] = null; do {Entry<K, V> next = e.next; int i = indexFor (e.hash, newCapacity); e.next = newTable [i]; newTable [i] = e; e = successivo; } while (e! = null); }}}  

Ovviamente, una tabella hash è una struttura dati abbastanza comune e ci sono solo tanti modi per implementare un dato algoritmo. Tuttavia, le due righe copiate mostrano che hai sicuramente utilizzato HashTable.java come punto di partenza per la tua implementazione e le ulteriori somiglianze nel design, i commenti illogici e la struttura del codice porterebbero a credere che hai preso più di un semplice una piccola "ispirazione" da HashTable.java.

Nota che sia il tuo che i loro metodi put e get usano un ciclo for per iterare su un elenco collegato, mentre i metodi grow / transfer usano un ciclo while per Fai lo stesso. Sembra strano che entrambi i pezzi di codice prendano la stessa decisione in modo indipendente.

I nostri progetti sono piuttosto vasti poiché non ci è permesso usare java.util. * (Come 1k + righe per ogni progetto in 8 giorni) e non ho copiato nessun altro codice. Direi che l'effettiva implementazione della struttura dati è pensata solo per richiedere circa 1/5 del nostro tempo speso per progetto.

Sembra chiaro che non ti era permesso usare HashMap.java, e che, se avessi voluto usare una tabella hash, avresti bisogno di implementarne una tua. Copiando gran parte di HashMap.java hai cercato di aggirare questa restrizione. "È solo una piccola parte del progetto" non toglie il fatto che hai preso il codice, che non era il tuo lavoro, e hai cercato di farlo passare per tuo (anche se l'aspettativa era che lo scrivessi parte del compito da soli).

Se gli incarichi fossero veramente irrealistici dato il periodo di tempo assegnato, sarebbe stato meglio consegnare una soluzione fallimentare. Se molti studenti si fossero rivelati una soluzione fallimentare, il professore avrebbe potuto considerare la possibilità che il compito fosse troppo difficile. Se il plagio fosse passato inosservato, il professore avrebbe potuto concludere (erroneamente) che il compito era di adeguata difficoltà, penalizzando gli studenti che (tentavano) di completare l'incarico in modo equo e secondo le regole.

Le sanzioni per il plagio possono variare notevolmente a seconda dell'istituzione. -100% sull'incarico potrebbe essere pesante, ma presso il nostro istituto la sanzione potrebbe essere compresa tra lo 0% sull'assegnazione, un fallimento automatico per il corso in questione all'espulsione dai tuoi studi per 12 mesi. Il plagio, nella maggior parte delle istituzioni, è trattato in modo simile all'imbroglio durante un esame e le punizioni potrebbero essere severe. Se l'unica punizione fosse ottenere lo 0% sull'assegnazione plagiata, non ci sarebbe nulla di male nel "provare" a plagiare se fallissi comunque l'incarico senza ricorrere al plagio.

Il plagio è considerare il lavoro di qualcun altro come tuo. Da quello che vedo, hai passato il lavoro di qualcun altro come tuo. A tua difesa, fornisci un elenco di affermazioni:

• il frammento di codice plagiato è piccolo
• il frammento di codice plagiato non è necessario
• i compiti del professore sono difficili
• il professore si è appena laureato
• il comitato per la condotta degli studenti sa poco di programmazione

Non riesco a vedere come di loro sono rilevanti per la questione in questione. La domanda centrale è: hai usato il lavoro di qualcun altro nel tuo senza riferimenti. Se l'hai fatto, hai plagiato e stai affrontando le conseguenze. Impara la lezione e non ripetere più l'errore.

Domande che devi porsi:

• Hai citato le tue fonti?

Sebbene l'argomento del plagio attraversi diversi campi, non tutti i campi sono lo stesso. Scrivere un programma non è la stessa cosa che scrivere un saggio. Sebbene entrambi condividano componenti di pensiero simili, grammatica = tabulazioni / spazi, nomi = oggetti, preposizioni = puntatori, ecc. Funzionalmente sono diversi. Come parte del tuo incarico, hai citato di aver ottenuto le sezioni di codice da una libreria open source? Anche se non fosse una citazione formale, forse all'interno dei commenti che collegano alla libreria?

• In quanti modi una persona può realizzare realisticamente un determinato obiettivo?

Se l'attività fosse sommare un elenco di numeri interi. Sarebbe un plagio se il codice di 10 programmatori usasse sum (object)?

un algoritmo comune per il concatenamento che posso spiegare a fondo

Qui è dove è necessario sostenere che c'è un punto in cui un dato pezzo di codice è diventato un'informazione comune, ma è necessario dimostrare che è in effetti comune. Un non esperto non avrebbe le conoscenze di base per presumere che ciò che dici sia corretto. Dovresti fornire esempi. (Pensa a Hello World, chi lo "possiede" davvero?)

• Brevettare il software è complicato

IANAL, ma sembrerebbe che la legge stessa sia complicata.

Oltre il 30% della classe è stato segnalato per violazioni dell'integrità accademica su progetti nel corso del semestre e il professore neolaureato non sembra pensare se stesso o i suoi incarichi sono il problema.

Un professore di informatica non è un avvocato, ma certamente ha la capacità di comprendere le questioni di informatica e chiedersi se o no è coinvolto un intento dannoso. Se le affermazioni di plagio possono essere affrontate con un semplice documento in cui citi le tue fonti (librerie, progetti open source, repository GitHub), le affermazioni dovrebbero diminuire.

La conoscenza e l'apprendimento non avvengono nel vuoto.

Grazie per questo. Come ho detto prima, citare il codice mi è estraneo (e sto programmando dall'età di 8 anni) e NON ho (ma DOVREBBE) citare quelle righe. Dimenticare di citare due righe e commettere plagio sull'intero progetto sono due cose diverse, però, soprattutto su un progetto di queste dimensioni. Come lo affronteresti?

Sostieni che i test attuali per determinare il plagio (come in inglese) non funzionano bene quando si tratta di programmazione e script, citando e documentando il tuo fonti è funzionalmente diverso. In un saggio, la citazione serve a dimostrare da dove ti è venuta l'idea. In un programma, serve a documentare come lo snippet di codice ti aiuterà a raggiungere i tuoi obiettivi. Lo scopo si sposta da "dare credito dove è dovuto" a "come questo aiuterà e cosa fa".

Con questo in mente, guarda "ciao mondo". È un'introduzione universalmente nota ai linguaggi di programmazione. Ma nessun programmatore esperto ha bisogno di "citarlo" per capirlo. È diventato "comune" in tutte le lingue. Tuttavia, un compilatore specifico in C che gli consentirà di controllare un braccio robotico, non è abbastanza comune da consentire a un programmatore esperto (indipendentemente dalla lingua) di riconoscerlo facilmente, da qui la necessità di documentazione. Nel mondo di Java, tuttavia, spetterebbe a te dimostrare che il codice che ti è stato assegnato sarebbe abbastanza "comune" da non essere considerato come oggetto di citazione.

Per quanto riguarda il caso stesso, puoi sostenere che le tue azioni non costituiscono le definizioni tradizionali e testare il plagio. Ma non aspettarti che il tuo pubblico (compagni di pari) capisca data la gravità e le credenziali dell'attore (il tuo professore). Un'altra strada sarebbe quella di sostenere come la gravità della pena -100% non sia coerente con la portata del presunto plagio. È presunto, non provato. Fino a quando non viene emesso un giudizio definitivo, è aperto al dibattito.

Per fallire unilateralmente uno studente per plagio sarebbe e dovrebbe essere fatto appello a una "autorità superiore" o, almeno, rivisto da un gruppo di individui consapevoli (contro laici). Hai affermato che questa classe ha una (secondo me, enorme) percentuale di affermazioni di plagio. Anche se non ho statistiche per sostenere la mia dichiarazione, il 30% è incredibilmente alto. Nella mia carriera accademica, il plagio è stato un evento RARO. Quindi un altro punto che puoi fare è se il professore stia applicando erroneamente il concetto di plagio tradizionale a un campo in cui è fondamentalmente diverso.

Un altro argomento che puoi fare è che la citazione del codice non è mai stata insegnata / sottolineata / prevista dal professore in classe. Ti è stato insegnato cos'è il plagio prima, molto probabilmente quando si trattava di comporre saggi, ma non ti è mai stato insegnato come si applicava alla codifica. Anche se a questo argomento potrebbero mancare una o due gambe (specialmente nel regno di, dovresti già saperlo), ma come sarebbe ragionevole ritenerti responsabile di qualcosa che non ti è mai stato insegnato a cercare?

Grazie, questo è un buon punto da sollevare. Usa solo il MOSS di Stanford, come ho collegato nell'OP. Non conosco il suo limite di percentuale di somiglianza prima che accusi le persone.

Un rilevatore di plagio come quello è uno strumento per dare credito al fatto che X è stato plagiato, un strumento tra i tanti. Non è affatto un test definitivo per determinare il plagio.

Fai un test di analisi del respiro per le DUI, ad esempio, se mangiassi semi di papavero e risultassi positivo, ci sarebbero fattori attenuanti? Se tutto ciò che il tuo professore usa per determinare il plagio è uno strumento, chiedi se gli strumenti possono essere difettosi.

Sebbene questa sia più retorica e logica che programmazione, sono sicuro che nessuno potrà mai affermare che un programma è perfetta. (Tranne COBOL, perché è perfetto al 100%) Quindi, se è davvero l'unica metrica utilizzata dal tuo professore, qual è la possibilità di falsi positivi? Sarebbe giusto punire ingiustamente gli studenti se un programma stabilisse che hanno imbrogliato?

Detto questo, leggi il manuale dello studente se puoi avere un consulente accademico durante il processo. Contatta anche i servizi del difensore civico se la tua scuola ne ha uno. Questo ufficio può arbitrare questioni come questa se l'istituto lo consente.

A mio parere, un gruppo di studenti (senza background legale o di programmazione) non sarebbe più adatto per determinare se si è verificato un plagio di programmazione.

Chiarisci, -100% è effettivamente 0%? Oppure il tuo professore non solo ti dà uno 0% per l'incarico, ma ti penalizza ulteriormente di un importo aggiuntivo? Cioè A + B + C = 100 (A = 20, B = 20, C = 60), uno 0% su A significherebbe l'80% totale, un -100% su A significherebbe il totale del 40%. - Frank FYC

Mi sta ulteriormente penalizzando di un importo aggiuntivo. Non riceverei uno zero sul progetto (cosa che il mio voto potrebbe permettermi), ma in realtà il mio voto complessivo è stato ferito PIÙ del 7% del valore del progetto. –TheSmartWon

Cosa complicata qui ... (visto l'aggiornamento) se il consiglio trova a tuo favore, questo non significa che il professore ti tratterebbe come farebbe con altri studenti che si trasferiscono inoltrare. Potresti trovarti sotto un'analisi ancora più attenta.

@ user2264247 Ha guardato il MOSS con me per circa 5 minuti oggi (esattamente quello che ho postato nell'OP), e lui concentrato solo su quell'hash funzione. Non sapeva nemmeno cosa facesse la funzione prima di parlare, quindi non credo che l'abbia rivista in precedenza. Lui e la sua collega (idkwhy era nella stanza) hanno dichiarato che, poiché ho copiato due righe, il mio intero programma è colpevole di plagio e che mi avrebbero accusato. , probabilmente a causa del gran numero di casi che affrontano. - TheSmartWon

@FrankFYC Anche lui e quel collega pubblicano articoli insieme e tengono corsi di accompagnamento. Sono buoni amici. È solo il suo nome che mi accusa sul "rapporto di violazione dell'integrità", ma solleverò questo punto di sicuro. Non ho idea di cosa stesse facendo nella stanza, tutto ciò che è successo è stato respingere rapidamente tutti i miei argomenti che il mio professore avrebbe potuto altrimenti ascoltare . Le dava gioia provare che avevo torto su ogni punto che sollevavo, era un po 'sadico. Ero come un altro insetto intrappolato nella loro rete! - TheSmartWon

Se fossero gli Stati Uniti. Ulteriori informazioni su FERPA. Non sono un esperto, ma presumo che se il tuo professore permettesse a un altro membro della facoltà di vedere i tuoi voti, sarebbe una violazione. Questo potrebbe essere l'atto che esplode in faccia. Se risiedi negli Stati Uniti, assicurati di stabilire il fatto che entrambi i professori erano nella tua stessa stanza quando hai discusso il rapporto.

Consulta la risposta di aeismail a una domanda.

Dato il numero di altri casi, presumereste che anche l'altro professore fosse in quei casi? Ad esempio, l'altro professore era al corrente del voto di un altro studente?

Possono negare tutto ciò che vogliono, ma se più di uno studente afferma che entrambi i professori erano nella stanza, ciò sarebbe in effetti, un class action (ah, scusa il gioco di parole).

Documenta tutto e fissa un appuntamento con il coordinatore FERPA della tua università (come un dipartimento organizzato per ricevere Reclami FERPA).

Potresti ritirare il tuo ricorso (se possibile)

A prima vista, la tua argomentazione sembra del tutto ragionevole. Questo è, se hai copiato due righe di codice (supponendo che fosse consentito) ma semplicemente non hai incluso una citazione o ti sei dimenticato di rimuoverlo (come hai affermato), allora questo potrebbe essere sostanzialmente attribuito a un errore onesto, su -par con un errore di battitura. Un errore del genere sarebbe sfortunato, ma difficilmente merita una punizione maggiore.

Tuttavia, come altri hanno notato, uno sguardo più attento al codice fa sembrare che tu abbia copiato completamente il codice originale e poi sia andato fuori strada per cercare di offuscare questo fatto. Questo fa sì che ogni simpatia vada fuori dalla finestra; semmai, potresti scendere troppo alla leggera.

Ma allora c'è il tuo fascino. L'appello stesso sembra essere basato su una premessa disonesta, proprio come fa questa domanda. Sembra che tu stia mentendo al consiglio d'onore!

Una simile bugia sembrerebbe essere un motivo per ulteriori punizione. Questo è, prima c'era l'inganno - la gravità di cui ora hai richiamato l'attenzione - e poi anche la difesa apparentemente fraudolenta.

Non so cosa dirti. Da un lato, questo è piuttosto grossolano e potrebbe effettivamente essere meglio se hai imparato la lezione ora. Ma come risposta a questa domanda, supponendo che tu stia cercando di ridurre al minimo la punizione, sembrerebbe che potresti voler uscire dall'appello e lasciare le cose da sole, piuttosto che rischiare di peggiorarle.

Riferimento : Riguardo al diritto di non autoincriminarsi

Nel sistema legale americano, a volte si pensa che gli imputati possano rivendicare l'innocenza senza ulteriori penali se tale affermazione viene successivamente ritenuta falsa. Ciò deriva dal quinto emendamento alla costituzione degli Stati Uniti che garantisce protezione contro l'autoincriminazione.

La parte divertente di questo è che, se guardi molti spettacoli di tipo Law-&-Order (come fanno molti americani), potresti essere usato all'idea che gli imputati possano mentire sul non essere colpevoli senza penalità, cosa che si potrebbe essere inclini ad applicare ad altri contesti simili a quelli di un tribunale, ad es. una revisione del consiglio d'onore.

Il fatto è che i consigli d'onore non sono tribunali; il diritto a non autoincriminarsi non si applica. Quindi, se menti in tua difesa davanti a un consiglio d'onore, stai comunque mentendo davanti alle persone esatte che ti giudicheranno per quell'esatto comportamento scorretto.

Modifica: è andato al fatto -controllato su questo punto, sembra che la Corte Suprema abbia stabilito che mentire in propria difesa può aumentare la pena:

La Corte Suprema ha stabilito oggi all'unanimità che gli imputati criminali che prendono posizione e testimoniano falsamente nella propria difesa possono costituzionalmente essere soggetti a un periodo di reclusione aggiuntivo per aver ostacolato la giustizia.

La decisione ha annullato una sentenza di una corte d'appello federale a Richmond, che ha dichiarato nel 1991 che la Costituzione vieta ai giudici di imporre un'ulteriore condanna ai sensi delle linee guida federali come punizione per "un rifiuto miscredente di colpevolezza sotto giuramento".

- "Court Says False Testimony Can Bring Longer Sentence", NYTimes (1993).

Quindi, a quanto pare, gli imputati possono essere penalizzati per aver mentito a loro difesa anche nei tribunali statunitensi.

Potrebbero non esserci molti algoritmi ragionevoli che implementano il concatenamento, ma ci sono letteralmente miliardi di possibili algoritmi hash a 32 bit. Non ha senso affermare che uno di loro in particolare è "di conoscenza comune", o che è stato rilasciato sotto GPL, o che stavi per rimuoverlo. Se lo facessi rimuoverlo, il tuo caso apparirebbe completamente diverso e direi che dovresti rivendicare la duplicazione indipendente. Nella tua posizione attuale non penso che tu possa convincere nessuno che hai scelto lo stesso algoritmo di hash indipendentemente da OpenJDK.

Quindi credo che la tua migliore opzione sia riconoscere l'errato, quindi sostenere che la quantità di il codice effettivamente plagiato è relativamente piccolo e la sanzione che il tuo professore vuole applicare è sproporzionata.

Altre risposte hanno affrontato questioni filosofiche / morali come "È plagio?" "È sbagliato?" ecc. Ma, direi che dovresti concentrarti sul problema pratico in questione, che è:

Non sono sicuro di come difenderlo l'intero caso davanti a un comitato per la condotta degli studenti.

Quindi hai un caso da discutere ...

Per prima cosa, leggi legalmente -documenti pertinenti:

• Regolamento disciplinare degli studenti
• Procedure del consiglio studentesco
• Elenchi di leggi esterne che si applicano ufficialmente
• Dichiarazione esatta delle accuse contro di te
• Precedente: gli ex studenti conducono le decisioni del consiglio su tali questioni.
• Protocolli di sessione delle precedenti sessioni del consiglio dello studente (se disponibili, che potrebbe non essere il case).

Quindi stabilisci se ti è permesso, e se è una buona idea, essere rappresentato da qualcuno: Un laywer; uno studente di legge; un membro della facoltà; un membro del consiglio studentesco ecc. Se questo è disponibile per te, dovresti almeno consultarne uno (anche se non finisci per portarli con te): sicuramente hanno più esperienza di te.

Ora, determina se vuoi davvero sostenere "questa parte di ciò che ho copiato non costituisce plagio". Forse potresti fare questo argomento, non lo so. Anche ai profani - se hai abbastanza tempo (cosa che potresti non avere), potresti essere in grado di spiegare come i programmi vengono compilati dal codice sorgente e come parte del codice non viene realmente utilizzato. Potresti presentare esempi di quello che sembra un plagio, ma in realtà è un codice quasi identico scritto indipendentemente da persone diverse.

Francamente, dubito che questo ti porterebbe molto avanti, viste le circostanze. Anche se in teoria hai ragione (una domanda su cui non sto commentando), e anche se potresti spiegarlo al consiglio, potrebbe non voler sentire un argomento del genere.

D'altra parte, immagino (senza fondamento!) che un argomento più convincente potrebbe essere qualcosa del tipo (breve riassunto):

Mi dispiace molto per quello che ho fatto e non nego che sia stato vietato, inappropriato e immorale.
Sono stato tentato di plagiare a causa dell'ABC che, pur non giustificando il mio comportamento, ha portato anche il 30% della classe a essere tentato di plagiare, suggerendo un problema oggettivo oltre al mio errore personale.
Ho fatto ammenda nei modi XYZ.
Nei casi C1 e C2, che ritengo comparabili, la penalità era molto più bassa.
Infine, vorrei che il consiglio prendere in considerazione le mie circostanze personali DEF quando si considera questo caso.
Mi atterrò a qualsiasi decisione presa dal consiglio di amministrazione.

e lascio perdere.

Ho esperienza nell'insegnamento (e nella gestione del plagio) e nella brevettazione / contenzioso del software.

Ho classificato gruppi di compiti che mostrano tutti lo stesso errore o la stessa imperfezione. Ho visto studenti non in grado di avviare il loro IDE con soluzioni per i compiti concise ed esperte, in cui tutte le variabili avevano nomi come "theCounter", "variableA" e "me stesso", ma a parte questo, il loro autore sembrava avere già 10 anni di esperienza nel settore e chiaramente non necessita di una laurea.

Un caso di brevetto software può essere ridotto a dimostrare che una singola riga come "x = 0" è stata plagiata. Ciò include dimostrare il movente, le persone (il fatto che l'azienda A ha attratto persone dall'azienda B) e lo stato dell'arte al momento del presunto plagio (e non ora, quando l'approccio proposto è ovvio per tutti). Le prove sui brevetti software non sono discussioni sterili su come l'algoritmo Smith – Waterman si è comportato sul codice del querelante e dell'imputato.

Nel tuo caso, sembra che tu abbia almeno "guardato" il codice OpenJDK prima di iniziare il tuo. Una prova inconfutabile è la funzione hash: la probabilità di replicarla per caso, secondo Mr. Data e C-3PO, è una su 67 trilioni di miliardi. È inoltre chiaro che non stavi cercando una funzione hash, ma un'implementazione della mappa hash. La ricerca di "funzione hash per stringhe" o "funzione hash per stringhe java" non produce un risultato da OpenJDK.

Dopo aver visto l'implementazione OpenJDK di hashMap, il problema era chiaro. Tra tutti i modi possibili di avvicinarsi a hashMap, cosciente o meno, hai scelto quello di OpenJDK, perché eri terribilmente di parte.

I commenti sul codice sono inutili. Commentare "lunghezza" come "lunghezza" dimostra che non hai compreso il problema e il commento qui era inteso semplicemente per soddisfare un requisito di valutazione. Perdi il tempo del selezionatore. Sarebbe corretto: "hash = l'hash dell'elemento da cercare", "Lunghezza: la dimensione della tabella hash" "restituisce la posizione nella tabella hash della lunghezza specificata per l'elemento di hash h. Non supera mai la lunghezza meno uno". Inoltre, dici "get restituisce il valore all'indice", che è palesemente sbagliato per una mappa hash. Get restituirà il valore alla chiave. Mescolare chiave e indice è un "reato capitale" se fai strutture di dati.

Il mio giudizio qui sarebbe "colpevole in quanto accusato". Non hai speso tempo a pensare alla soluzione, ma hai preso una soluzione esistente e probabilmente implementata in modo indipendente. Ha sconfitto lo scopo dei compiti, che avevano lo scopo di farti pensare alle strutture dei dati. Citare la fonte di OpenJDK renderebbe solo la tua colpa più ovvia (un classico caso di autoincriminazione durante la difesa). È come ricevere un problema di matematica e si finisce per citare il libro e la pagina che mostrano una soluzione del problema. Hai svolto un buon lavoro di ricerca, ma l'intento del problema era farti risolvere.

Dovresti assolutamente protestare contro la punizione proposta, perché molte istituzioni non consentono una punizione come quella che il tuo professore vuole valutare. (In altre parole, il tuo insegnante non può darti un voto di -100% o qualsiasi voto inferiore a zero per una data parte del tuo voto.)

Per quanto riguarda la copia del codice come plagio, questa è un'affermazione molto più spinosa. Usare il codice di qualcun altro è un problema, ma se davvero non c'è un altro modo per fare qualcosa, allora come si fa a dichiarare plagio? Il plagio non si estende alle affermazioni "ovvie". Ad esempio, non è plagio se due libri di testo di calcolo risolvono un integrale usando una serie di equazioni nello stesso modo, perché fondamentalmente è l'unico modo per farlo. D'altra parte, se scrivi un po 'di testo attorno ad esso è lo stesso, allora hai commesso un plagio.

Il plagio è un argomento difficile in informatica, poiché esiste solo un numero limitato di pezzi di codice che portano allo stesso risultato e solo uno di essi può essere considerato una soluzione ottimale.

Tu in Infatti ha copiato il codice dalle librerie Java, sia il codice effettivo che la denominazione delle variabili lo suggeriscono. Quindi sarebbe stato tuo dovere citarlo correttamente. In questo punto di vista rigoroso il tuo professore ha ragione, e probabilmente ha ragione anche negli altri casi che hai citato. Se molte persone commettono errori, è ancora il problema della persona che commette l'errore, non quello che lo corregge.

Se è etico è comunque un argomento completamente diverso.

Quando si programmano funzioni complesse è buona norma non reinventare la ruota, ma utilizzare invece codice esistente e ben testato da altri. Tuttavia, come dall'articolo collegato, "reinventare la ruota è spesso necessario per aggirare le incompatibilità di licenza del software"

Se avevi l'ordine specifico di non copiare il codice esistente e non sei riuscito a obbedire a quell'ordine, il problema è dalla tua parte. La brevettazione del software è un grave problema negli Stati Uniti, diverse società più piccole sono fallite a causa di ciò, le società più grandi possiedono determinati brevetti solo per utilizzarli per contro-citare in giudizio (vedere Apple vs Samsung). Essenzialmente i brevetti software si sono trasformati in una sorta di arma che può essere utilizzata per cancellare la concorrenza indesiderata dal mercato. Pertanto è importante per qualsiasi sviluppatore di software (nel tuo paese) essere in grado di rilevare e risolvere tali problemi di licenza.

Non conosco le intenzioni del tuo professore, ma potrebbe essere possibile che lui ha aggiunto quella clausola specificamente perché è consapevole delle conseguenze del "furto di codice" e la sua dura reazione è un modo per insegnarti a evitare questi problemi in situazioni in cui sarebbe davvero doloroso.

In altre parti del mondo non così ristrette, i brevetti software o il "plagio" come nel tuo caso sono molto meno problematici. Ciò significa che in altri paesi il tuo lavoro avrebbe potuto essere considerato in modo diverso, alcuni potrebbero persino aver ridotto i tuoi punti per non aver copiato il codice esistente (reinvenzione non necessaria della ruota). Ma tu non vivi in ​​"altri paesi", quindi anche da un punto di vista etico il tuo professore potrebbe essere duro ma ha comunque ragione.