Google batte Oracle: Android fa un uso corretto delle API Java

Ahahaha
Ma cosa vuoi mettere in croce. Al massimo avrai al solito vinto la battaglia sulle quisquilie e pinzillacchere che non sono il centro del discorso.
Sei tu che son anni che vai dicendo scemenze una dietro l'altra per poi rimescolare le carte e dire che quello che dicevi non lo hai mai detto, però avevi ragione sulla virgola fuori posto.

14nm sono in perfetta tabella
La fabbrica aprirà
I 4 miliardi di incentivi x 40milioni di soc sono per promuovere il modem
I 7 miliardi x promuovere i soc sono un investimento
Gli Atom non temono i soc arm nemmeno con la stessa nanometria perché il vantaggio di Intel non è il PP
I 10nm sono in perfetta tabella di marcia
Intel non ha problemi con il fatturato record (12.000 licenziamenti annunciati il trimestre successivo)

Continui a dire "ho dimostrato" "ho dimostrato" quando in realtà non hai mai dimostrato nulla. Parli e ti smentisci ogni 2 commenti. Ritorni e cambi il significato di quello che hai scritto nel post precedente, uno due, tre volte, poi quando non si capisce più quello che intendevi parti con un "ho dimostrato"...al massimo finora hai dimostrato di non saper argomentare in maniera chiara e coerente attaccando alle quisquilie una volta messo all'angolo.
Il codice dichiarativo (sempre se di codice si può parlare dato che non è convertito in alcuna istruzione) si può scrivere in un solo modo a meno come detto di mischiare i caratteri, cosa inutile che non cambia la sostanza. SOSTANZA, il quid, l'interesse, l'argomento, non le pinzillacchere. Se vuoi descrivere una interfaccia lo puoi fare in uno e in solo modo.
E il copyright è stato violato, sì, ma in maniera fair appunto perché solo copiando l'interfaccia pubblica si permette la collaborazione tra moduli SW distinti, moduli il cui vero codice è stato scritto da zero da Google.
La sostanza è se l'interfaccia è copiabile o meno, non che la copia è violata tramite C&P mentre diventa buona se riscritta da zero. Rileggiti quello che hai scritto e vedi che sei tu quello che non ha capito nulla di quello che è stato discusso prima, non io.

Ahahaha
Torna a darmi del Troll quando avrai imparato a congiungere più di 2 puntini alla volta.
Messo in croce... Da te e l'altro fanboy poi... Ahahaha...

Mi hai rallegrato la giornata. Grazie. Era piuttosto noiosa fino alla lettura del tuo commento.
Grazie ancora. Ciaoooooo

Ah, e per le istruzioni FMA, funzionano esattamente come ho descritto. Visto che il succo del discorso era il calcolo dei TFLOPS tra Maxwell e Pascal che qualcuno credeva fosse la stessa architettura perché a parità di frequenza e numero di core faceva gli stessi numeri.
Però anche lì hai trovato modo di darmi torto passando per le solite pinzillacchere sulla differenza tra istruzioni e operazioni che con il discorso non c'entrava nulla ed era comunque ben specificato.

Il succo del discorso, ragazzo mio, il succo del discorso è quello che conta. E tu spesso e volentieri non sei in grado di comprenderlo.

Intanto bisogna vedere che tipo di licenza viene usata. Nel caso di WPython, ho scelto quella BSD, perché è la più libera in assoluto.

Mettendoci nelle condizioni che la licenza non sia così libera, come ad esempio quella GPL, si pone il problema della copia di parti dei sorgenti che ne sono coperti.

In questo caso il precedente commento di litocat ha chiarito che è possibile copiarne una parte se questo ricade nel cosiddetto "fair use", com'è stato giudicato per il caso oggetto della notizia.

Mettendoci, infine, nell'ipotesi che non fosse possibile applicare il fair use, la precedente dichiarazione la potresti riscrivere così, ad esempio:
[CODE]PyAPI_FUNC(PyCodeObject *)
PyCode_New(
int, int, int, int,
PyObject *, PyObject *, PyObject *, PyObject *,
PyObject *, PyObject *, PyObject *, PyObject *,
int, PyObject *
);[/CODE]
Così abbiamo preso del codice già scritto da qualcuno e lo stiamo riorganizzando in modo da renderlo diverso da quello originale, pur mantenendo esattamente la stessa identica funzionalità.

Così, però, stiamo "barando", visto che abbia preso roba già scritta, perché stiamo sfruttando il frutto del lavoro altrui.

In realtà per riscrivere l'interfaccia di un'API dovremmo fare molto diversamente, e più precisamente dovremmo partire dalla descrizione delle API, aprire il nostro editor/IDE, e iniziare a scrivere da zero il nostro codice.

Esempio pratico, usando la funzione PyCode_New che hai tirato in ballo. Dalla documentazione ufficiale degli oggetti di tipo Python Code scopriamo che l'API PyCode_New ha la seguente interfaccia:
[CODE]PyCodeObject *PyCode_New(int argcount, int nlocals, int stacksize, int flags, PyObject *code, PyObject *consts, PyObject *names, PyObject *varnames, PyObject *freevars, PyObject *cellvars, PyObject *filename, PyObject *name, int firstlineno, PyObject *lnotab);[/CODE]
Dunque possiamo prendere questa definizione e copiarla così com'è nel nostro file include (perché la licenza PSF della documentazione è molto libera. Alternativamente avresti attaccarti alla tastiera e ricopiare carattere dopo carattere quanto vedi su quella paginetta), ma visto che siamo programmatori e non caporali, il lavoro lo facciamo bene, quindi lo risistemiamo così:
[CODE]PyCodeObject *PyCode_New(
int argcount, int nlocals, int stacksize, int flags,
PyObject *code, PyObject *consts, PyObject *names, PyObject *varnames,
PyObject *freevars, PyObject *cellvars, PyObject *filename, PyObject *name,
int firstlineno, PyObject *lnotab);[/CODE]
Come vedi abbiamo riscritto la STESSA API in maniera direi MOLTO DIVERSA da quella che hai trovato in WPython (che in realtà usa pari pari i sorgenti di CPython, a cui quella dichiarazione appartiene).

Faccio notare che, ad esempio, non abbiamo assolutamente fatto uso della macro PyAPI_FUNC, che invece viene usata in W/CPython: eppure la definizione dell'API funziona esattamente nello stesso modo, perché genera un'identica definizione nella symbol table del compilatore (e "firma" per il linker, ovviamente).

Questo è bene sottolinearlo perché è un esempio di come il codice si possa riadattare in base alle proprie esigenze/visione/capacità.

Spero che l'esempio sia chiaro e mostri la differenza che passa fra la descrizione di un'API e il codice vero e proprio che la definisce in maniera fruibile da un ben preciso linguaggio di programmazione: il C.

Ma non sta scritto da nessuna parte che si debba usare il C, e infatti s.o. come il vecchio MacOS utilizzavano il Pascal per descrivere le API del s.o.. Questo a ulteriore dimostrazione della differenza fra i due concetti.

Le questioni di cui stiamo parlando sono almeno due: il tuo tifo a favore di Google, e contro Oracle, riguarda entrambe o solo una delle due?

Anche se fosse così, sarebbe assolutamente e perfettamente legittimo, visto che i soldi per acquisire Sun li ha sganciati lei e non Google.

*

L'avevo già dimostrato a parole, ma si vede che non sei riuscito a coglierlo.

Adesso leggiti la mia replica a GTKM, che dimostra con un esempio reale e inoppugnabile come stanno realmente le cose.

Anche i commenti sono coperti dal copyright, se non lo sai.

Scusami, quand'è che l'avrei detto? Quando ho parlato del fatto che non ci sarebbero conseguenze, era relativo al fatto che quello in oggetto non sarebbe stato un precedente (che, quindi, avrebbe fatto giurisprudenza).

No. Primo perché la conseguenza non dice questo. E secondo perché ho dimostrato oltre ogni ragionevole dubbio che sì, invece, è assolutamente possibile riscrivere completamente gli header (dichiarazioni di API, in generale) senza infrangere il copyright.

Vedi sopra: sì, mi sembra normalissimo poter reimplementare da zero qualunque cosa, dichiarazioni incluse.

Assolutamente d'accordo, infatti:
https://www.youtube.com/watch?v=rdkecMOT1ko

No. Primo, nello specifico ho riportato la situazione in ambito Linux / GPL. Tant'è che ho citato anche la posizione di Stallman a riguardo.

Secondo, la MIA posizione è che il codice, TUTTO, non si dovrebbe copiare.

Terzo, litocat ha riportato la situazione reale: la copia è fattibile in caso di "fair use".

Chi ha parlato dei commenti? Ma lo vedi che hai problemi a ricordare quello di cui è stato discusso in questo thread? Vatti a rivedere quand'è che sono stati citati, e perché.

Per il resto, io ho parlato della copia di 11500 righe di codice. Dunque tutto quello che c'era messo, commenti inclusi SE ci fossero stati.

Premesso che i commenti sono coperti dal copyright, Oracle ha citato Google per l'uso delle API (che è il nodo principale) e per la copia di quelle righe di codice (che si è verificata senza dubbio alcuno).

Mettiamoci anche AROS che ha reimplementato completamente le API del s.o. di Amiga.

Tutto legale, per quanto detto prima.

PER ME, sì, visto che hai COPIATO quel file.

Come già detto, dovresti rimboccarti le maniche e riscrivere completamente da zero tutto, partendo dalla documentazione (che va CONSULTATA e NON saccheggiata, sia chiaro).

Questa è la MIA, personalissima, posizione.

L'ho chiarito sopra.

Assolutamente sì: è possibilissimo. Vedi la mia replica a GTKM.

Se dicessi che a me pare che sia esattamente l'opposto non cambierebbe nulla.

Ma questo mio commento dovrebbe aver chiarito una volta per tutte le questioni.

Così parlò chi si diede sistematicamente alla fuga, dopo aver preso sonore mazzate.

Puoi minimizzare e cercare di mistificare quanto vuoi: i commenti sono lì a dimostrazione di come siano andate realmente le cose.

Visto che ripeti esattamente le stesse cose come un disco rotto, riporto il link alla mia ultima risposta in merito.

Non per te, visto che non c'è speranza di avere una risposta dopo che ho demolito tutte le balle che avevi scritto, ma per gli altri utenti, che potranno verificare come stiano realmente le cose.

Quisquilie? Ecco da qui una "quisquilia":

"TU: Mamma mia, ha quadruplicato le prestazioni x watt!! A parte che è vero solo per i calcoli floating point
IO: Falso: anche per gli interi. AVX-2, infatti, colma le lacune di AVX proprio sugli interi!!! AVX aveva introdotto il supporto sostanzialmente per i soli floating point.

Hai mai aperto un manuale delle architetture x86? Mi pare proprio di no."

Ed è soltanto una delle tante che hai proferito: basti leggere il commento per trovare altre chicche di primordine, come il famigerato "riordino" dei registri (e delle istruzioni obsolete) di x64, l'assenza di modifiche a questa nuova ISA a parte i puntatori a 64 bit, nessuna modifica a compilatori e tool di sviluppo per supportarla, ecc. ecc. ecc.

Certo, per uno che ne capisce di architetture degli elaboratori quanto io di bricolage capisco benissimo che tutto ciò sia classificabile come "quisquilie", ma quanto meno è servito a strappare delle grasse risate a chi, invece, ha conoscenze in materia.

Cos'è, una nuova definizione: la sola parte del sorgente che si può chiamare codice è quella che genera almeno un'istruzione?

Su questo ho già ampiamente risposto prima, e sono tutt'altro che quisquilie: il codice che è venuto fuori dalla descrizione di quell'API di CPython è ben diverso, anche se produce esattamente lo stesso effetto a livello di definizione dell'API.

Il codice dichiarativo dell'interfaccia pubblica si può benissimo evitare di copiarlo, riscrivendolo da zero, come ho dimostrato.

Google ha preferito una comoda scorciatoia, invece di scriversi anche quella parte di codice.

A quanto pare il giudice ha deciso per il fair use, anche a fronte di una palese copia di quelle righe di codice.

Mi era, ed è tutto perfettamente chiaro. I miei commenti sono lì a dimostrarlo.

Adesso te ne ho rallegrata un'altra. Ma forse sono gli altri utenti ad aver apprezzato di più.

Falso, visto che avevi scritto questo:

"TU: qui hai voluto fare il precisino facendo le pulci tra istruzione e operazione, senza ovviamente riportare quale sia la differenza dato che in questo caso non esiste.
IO: Sei proprio "sfortunato": proprio le FMA sono istruzioni che NON sono assolutamente equivalenti a un paio di altre, visto che hanno delle caratteristiche molto particolari."



Ancora dal link di cui sopra:

[I]"TU: Efficienza ho specificato che è il rapporto tra il valore teorico massimo di istruzioni eseguibile e quelle che effettivamente vengono eseguite (le FMA),
IO: Che non vuol dire proprio niente, perché ho già scritto che le FMA NON sono le uniche istruzioni che vengono eseguite.

Ma poi [U]hai dei dati ufficiali in proposito[/U]? Portali pure."[/I]



Per tua comodità ho riportato ambo le parti, e il link all'intera mia replica, cosicché chiunque potrà vedere se si tratti di "pinzillacchere" o di tecnostrafalcioni di chi non ha la minima idea di cosa sta parlando.

Ci vuole una bella faccia tosta, da uno che per sua stessa ammissione scrisse che non sapeva nemmeno la differenza fra core, ALU, unità d'esecuzione.

Il riassunto è che sei libero di riscrivere da zero un'API senza andare minimamente a copiare del codice già esistente (e coperto da copyright).

Mentre Google ha preferito la scorciatoia (copiare 11500 righe di codice di Java, aventi copyright di Sun/Oracle).

Mi spiace ma la tua dimostrazione è sbagliata.
Le dichiarazioni che tu hai sopra riscritto e dichiarato come MOLTO DIVERSE sono invece ASSOLUTAMENTE IDENTICHE, non crederai che basti reindentare il codice per evitare di violare il copyright.
Non puoi prendere un libro, aggiungere qualche ritorno a capo, cambiare la formattazione e magari il font e dire che non è una violazione del copyright.

Riguardo poi ai grassetti aggiunti da me, credi che tra fare copia incolla oppure ribattere tutto copiando a vista o anche reimplementare da zero (dato che il risultato finale è lo stesso) cambi qualcosa dal punto di vista delle violazioni del copyright?

Se non ne sei convinto vai a chiedere un parere all'ufficio legale della tua azienda e senti cosa ti rispondono.

Un altro modo per mostrare che la tua dimostrazione non funziona e quella di rianalizzare il caso in questione:
Se fosse vero quello che tu affermi sopra e cioè che basta riscrivere le dichiarazioni magari indentandole in maniera diversa per essere a posto allora vuol dire che Google non ha commesso una cosa così grave. Google poteva riutilizzare la API di Java, ha solo preso una scorciatoia e risparmiato un mese di lavoro, non avrebbe dovuto pagare niente a Sun/Oracle (ai tempi c'era Sun). Sotto le ipotesi suddette avrebbe commesso un illecito ed andrebbe punito, sicuramente dovrebbe sanare la cosa e pagare una multa, ma non avrebbe creato nessun danno rilevante a Java e a Sun/Oracle. A maggior ragione, una volta scoperto, Google avrebbe ammesso la colpa e sanato la situazione, perché il lavoro è poca cosa riducendo così la multa.

Invece Oracle ha chiesto 9 MILIARDI DI DOLLARI di danni, una simile cifra è giustificabile solo se Google avesse fatto qualcosa che non avrebbe potuto assolutamente fare e non sanabile se non con il pagamento di una percentuale sugli introiti/fatturato.

Anche per questo motivo la tua interpretazione del copyright non ha senso

Il problema principale, come ha fatto notare anche CrapaDiLegno, è che il codice dichiarativo non dovrebbe essere protetto da copyright per quanto avevo già riportato nel mio post precedente. Riporto nuovamente



Purtroppo la sentenza del CAFC (contestata da diversi esperti del settore) ha detto che la API di Java era soggetta a copyright.
Dato che esiste un solo modo per esprimere le dichiarazioni di una API (il metodo da te sopra usato per la dimostrazione non cambia la questione come già detto) la conseguenza è che: Non puoi reimplementare una libreria senza violare il copyright.

Quindi tutti gli esempi di reimplementazioni che ti ho fatto prima e che dicevi fossero corretti diverrebbero illegali. in certi casi ci sono state delle cause che sono state vinte dai reimplementatori in quanto le interfacce non erano soggette a copyright

Spero di essere stato chiaro

Infatti non è quello che ho fatto, visto che la dichiarazione dell'API l'ho riscritta.

Ecco l'originale, contenuta in W/CPython, riportata da GTKM:
[CODE]PyAPI_FUNC(PyCodeObject *) PyCode_New(
int, int, int, int, PyObject *, PyObject *, PyObject *, PyObject *,
PyObject *, PyObject *, PyObject *, PyObject *, int, PyObject *)[/CODE]
Ed ecco la versione riscritta da zero:
[CODE]PyCodeObject *PyCode_New(
int argcount, int nlocals, int stacksize, int flags,
PyObject *code, PyObject *consts, PyObject *names, PyObject *varnames,
PyObject *freevars, PyObject *cellvars, PyObject *filename, PyObject *name,
int firstlineno, PyObject *lnotab);[/CODE]
Direi che MOLTO DIVERSE ci sta benissimo, com'è anche evidente che sono tutt'altro che ASSOLUTAMENTE IDENTICHE.

Cosa non ti è chiaro di questo:

[INDENT][I]"Secondo, la [U]MIA posizione[/U] è che il codice, TUTTO, non si dovrebbe copiare.

Terzo, litocat ha riportato [U]la situazione reale[/U]: la copia è fattibile in caso di "fair use"."[/I][/INDENT]

?

Cosa non ti è chiaro di questo:

[I][INDENT]"Poi, replicando a te che [U]affermavi che fosse impossibile riscrivere il codice dichiarativo[/U] visto che ci sarebbe un solo modo (e l'hai di nuovo ribadito nel commento sotto), ti ho dimostrato in che modo [U]è possibile tirare fuori del codice dichiarativo DIVERSO[/U] partendo da quello originale."[/INDENT][/I]

più il terzo punto precedentemente mensionato?

Cosa che non è successo, perché la giuria ha deciso diversamente.

Concordo che la cifra sia spaventosamente elevata, ma il nodo principale di Oracle riguarda il copyright sulle API. Senza le API non c'è Java, e senza Java non ci sarebbe stato Android, per lo meno per come lo conosciamo, e magari non avrebbe avuto queste quote di mercato.

Sono whatif, ma l'adozione di Java, che è un linguaggio molto diffuso a tutti i livelli, è stato molto importante per la diffusione di Android, come prima lo era per i telefonini con JavaME.

La mia opinione sul copyright ha perfettamente senso, e riguarda la tutela del lavoro altrui.

Ma, come già detto, è la MIA posizione (vedi secondo punto).

L'avevo già scritto e lo riporto nuovamente:

[INDENT]"Terzo, litocat ha riportato la situazione reale: la copia è fattibile in caso di "fair use"."[/INDENT]

Dunque non c'era bisogno che tu lo riportassi, visto che litocat aveva già mostrato la legislazione in materia.

Che poi io, come già detto, non concordi perché ho un'opinione diversa, è legittimo o no? Vorrei capire se è lecito pensarla diversamente, giusto per essere chiari.

Su questo ho sempre avuto un'opinione non netta, e non ho preso una decisione.

Da una parte sono per la protezione delle API poiché il frutto del lavoro di qualcuno.

Dall'altra le API sono delle definizioni che servono per sviluppare altre applicazioni, su di esse basate.

E' una questione che mi trascino da tempo.

Vedi sopra l'API di W/CPython: sì, è possibile reimplementare una libreria senza violare il copyright.

Sì, ne sono cosciente.

Spero di esserlo stato anch'io.

Riguardo alla questione, c'è un altro pezzo apparso su ArsTechnica che tratta quanto avevo ipotizzato qualche giorno fa:
Op-ed: Oracle attorney says Google’s court victory might kill the GPL

Secondo me, comunque, non è una questione dai confini netti.

Da un lato, ci sarebbe da dire che le API non cascano dal cielo, e chiunque abbia mai sviluppato una libreria lo sa. Quindi a primo impatto vorrei che il mio lavoro fosse tutelato.

Dall'altro, visto che si parla di dichiarazioni di interfacce, forse non ha molto senso pretendere che ognuno se le riscriva partendo dalla documentazione, visto che, gira e rigira, comunque si dovrà arrivare allo stesso codice. Quindi si potrebbe pure permettere di copiare i file con le dichiarazioni.

Non riesco a capire come "schierarmi".

Siamo in due...

Comunque, questo è ciò che pensava la FSF a riguardo: https://www.fsf.org/blogs/licensing...oracle-v-google