Riuso di codice

Questa voce o sezione sull'argomento informatica è ritenuta da controllare.

Motivo: La voce contiene diversi paragrafi di dubbio senso o di cui non si capisce il punto, probabilmente perché si tratta di traduzioni quasi letterali dall'inglese. Bisognerebbe revisionare la voce verificando la coerenza interna di quanto scritto, oltre che espandere un minimo alcune sezioni sicuramente meritevoli di essere presenti ma striminzite.

---

Partecipa alla discussione e/o correggi la voce. Segui i suggerimenti del progetto di riferimento.

In informatica con il termine riuso di codice si intende la pratica, estremamente comune nella programmazione, di richiamare o invocare parti di codice precedentemente già scritte ogni qualvolta risulta necessario, senza doverle riscrivere daccapo.

Questo essenzialmente si concretizza nella scrittura di funzioni che possono essere richiamate o invocate all'interno di uno stesso programma, o raggruppate all'interno di librerie che possono essere a loro volta "collegate" su necessità all'interno dei vari programmi oppure nelle API. Nella pratica della programmazione ad oggetti, ad essere in qualche modo "richiamate", "importate" o "ereditate" sono le classi, sempre su necessità, ed eventualmente "estese" con nuove funzioni o metodi all'interno del programma stesso.

Il riuso di codice permette dunque un risparmio notevole nei tempi di scrittura di un programma da parte del programmatore, facilitando il lavoro di programmazione e migliorando la leggibilità del codice divenuto più corto e sintetico, ed è per questo presente in quasi tutti i linguaggi di programmazione, di cui rappresenta un'evoluzione già nelle primissime tecniche di programmazione, anche se obbliga in qualche modo il programmatore alla conoscenza delle varie librerie e funzioni disponibili o delle API.

Il riuso può essere^[1]:

• Opportunistico: mentre si prepara per iniziare un progetto, il team si rende conto che esistono componenti esistenti che possono essere riutilizzati.
• Pianificato: un team progetta strategicamente i componenti in modo che siano riutilizzabili in progetti futuri.

Il riuso può essere ulteriormente classificato^[1]:

• Interno: un team riutilizza i propri componenti. Questa potrebbe essere una decisione aziendale, poiché il team potrebbe voler controllare un componente critico per il progetto.
• Esterno: un team può scegliere di concedere in licenza un componente di terze parti. La concessione in licenza di un componente di terze parti in genere costa al team dall'1 al 20 percento di quanto costerebbe sviluppare internamente. Il team deve anche considerare il tempo necessario per trovare, apprendere e integrare il componente.

Per quanto riguarda la forma o la struttura del riuso, il codice può essere:

• Riferimento: il codice client contiene un riferimento al codice riutilizzato, pertanto hanno cicli di vita distinti e possono avere versioni distinte.
• Forked: il codice client contiene una copia locale o privata del codice riutilizzato e quindi condivide un singolo ciclo di vita e un'unica versione.

Il riuso sistematico del software è una strategia per aumentare la produttività e migliorare la qualità dell'industria del software. Sebbene sia semplice nel concetto, l'implementazione di successo del riutilizzo del software è difficile nella pratica. Una ragione addotta per questo è la dipendenza del riutilizzo del software dal contesto in cui è implementato. Alcuni problemi che devono essere affrontati in relazione al riuso sistematico del software sono^[2][1]:

• una visione del prodotto chiara e ben definita è una base essenziale per una linea di prodotti software (SPL).
• una strategia di implementazione evolutiva sarebbe una strategia più pragmatica per l'azienda.
• esiste la necessità di un supporto di gestione e leadership continui per garantire il successo.
• è necessaria una struttura organizzativa adeguata per supportare l'ingegneria SPL.
• il cambiamento di mentalità da un'azienda incentrata sul progetto a un'azienda orientata al prodotto è essenziale.
• Leadership manageriale a lungo termine
• Organizzazione sistematica e incrementale e cambiamento di processo
• Progettazione per il riutilizzo architettato e specifico del dominio
• Separazione: creare/supportare/utilizzare
• Capire che gli oggetti da soli non sono sufficienti
• Avviare piccole sperimentazioni e successivamente ampliarle
• Affrontare la cultura, l'esperienza e la stabilità dell'organizzazione
• Investire in infrastrutture, supporto e formazione
• Trovare campioni di riuso dedicati

Lo stesso argomento in dettaglio: Libreria (software).

Un esempio molto comune di riutilizzo del codice è la tecnica di utilizzo di una libreria software. Di seguito un esempio di codice riusabile della libreria JQuery:

$("a").css( { color: 'red', width: '150px' } )
      .show( '1000' )
      .click( function () {
      	alert( 'clicked!' );
      } );

Lo stesso argomento in dettaglio: Design pattern.

Un "design pattern" o "modello di progettazione" è una soluzione generale a un problema ricorrente. I modelli di progettazione sono più concettuali che tangibili e possono essere modificati per soddisfare l'esatta esigenza. Tuttavia, classi e interfacce astratte possono essere riutilizzate per implementare determinati modelli. Di seguito un esempio di design pattern riusabile:

public class EagerSingleton {
	// create an instance of the class.
	private static EagerSingleton instance = new EagerSingleton();

	// private constructor, so it cannot be instantiated outside this class.
	private EagerSingleton() {  }

	// get the only instance of the object created.
	public static EagerSingleton getInstance() {
		return instance;
	}
}

Lo stesso argomento in dettaglio: Funzione di ordine superiore.

Nella programmazione funzionale le funzioni di ordine superiore possono essere utilizzate in molti casi in cui in precedenza venivano utilizzati design pattern o framework. Di seguito un esempio con Julia:

julia> function twice(f)
           function result(a)
               return f(f(a))
               end
           return result
       end
twice (generic function with 1 method)

julia> plusthree(x) = x + 3
plusthree (generic function with 1 method)

julia> g = twice(plusthree)
(::var"#result#3"{typeof(plusthree)}) (generic function with 1 method)

julia> g(7)
13

Lo stesso argomento in dettaglio: Retrocomputing.

Il retrocomputing comprende il riutilizzo del codice, semplicemente perché i programmi retrò vengono eseguiti su computer più vecchi o emulatori per essi.

Nella sicurezza informatica il riutilizzo del codice è impiegato come metodo di exploit del software^[3]. Quando un utente malintenzionato non è in grado di inserire direttamente il codice per modificare il flusso di controllo di un programma, ad esempio in presenza di difese da iniezione di codice come W ^ X, può reindirizzare il flusso di controllo a sequenze di codice esistenti in memoria.

Un componente, in una misura orientata agli oggetti, rappresenta un insieme di classi collaborative (o solo una classe) e le sue interfacce^[4]. Le interfacce sono responsabili dell'abilitazione alla sostituzione dei componenti. I componenti riutilizzabili possono anche essere isolati e sincronizzati tra i repository SCM utilizzando le tecnologie di gestione del codice sorgente dei componenti (CSCM)^[5]. Di seguito un esempio di componente riusabile:

import React da 'React'; 
import {Logo, ProfileImage, BurgerMenu, HeaderWrapper} da "component"; 

const Header = () => ( 
  <HeaderWrapper> 
    <Logo> </Logo> 
    <ProfileImage> </ProfileImage> 
    <BurgerMenu> </BurgerMenu> 
  </HeaderWrapper> 
)

L'intero concetto di "riutilizzo del codice" può comprendere anche applicazioni di ingegneria al di fuori del software. Ad esempio, la modellazione parametrica nella progettazione assistita da computer consente di creare progetti riutilizzabili.

La maggior parte del codice HTML, CSS e (se presente) JS di una pagina web può essere riusato per creare più pagine web con contenuti diversi ma aventi lo stesso layout o un layout molto simile.

Di seguito una porzione di codice riusabile HTML 5 della pagina mostrata nell'immagine.

<!DOCTYPE HTML>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
	<title>My Website</title>
</head>
<body>
	<header>
		<nav>
			<ul>
		        <li>Menu</li>
			</ul>
		</nav>
	</header>
	<section>	
	
		<article>
			<header>
				<h2>Article title</h2>
				<p>Posted on <time datetime="2020-09-04T16:31:24+02:00">September 4th 2020</time> by <a href="#">Writer</a> - <a href="#comments">6 comments</a></p>
			</header>
			<p>Pellentesque habitant morbi tristique senectus. </p>
		</article>
	</section>
	<aside>
		<h2>About section</h2>
		<p>Donec eu libero sit amet quam egestas semper.</p>
	</aside>
	<footer>
		<p>Copyright 2020 Kate Ross</p>
	</footer>
</body>
</html>

Anche nel caso di SVG e WebGL/Canvas può essere riusato parte dello stesso codice per creare progetti diversi:

Codice SVG riusato per creare il cerchio la seconda volta

 <g
     inkscape:label="Layer 1"
     inkscape:groupmode="layer"
     id="layer1">
    <circle
       id="path3699"
       cx="97.517845"
       cy="131.44643"
       r="34.773811"
       style="stroke-width:0.26458332" />
  </g>

Codice Canvas riusato per creare il cerchio la seconda volta

var SVGIcons = {
"": {
 draw: function(ctx){
ctx.save();
ctx.strokeStyle="rgba(0,0,0,0)";
ctx.miterLimit=4;
ctx.font="15px / 21.4286px ''";
ctx.font="   15px ";
ctx.font="   15px ";
ctx.beginPath();
ctx.arc(97.517845,131.44643,34.773811,0,6.283185307179586,false);
ctx.closePath();
}
}}

Pubblicazioni

• (EN) Martin Griss, Systematic Software Reuse - Objects and frameworks are not enough, in Object Magazine, febbraio 1995.
• (EN) Martin Griss e K. Wentzel, Hybrid Domain Specific Kits, in Journal of Systems and Software, dicembre 1995.
• (EN) Martin Griss e R.R. Kessler, Building Object Oriented Instrument Kits, in Object Magazine, maggio 1996.
• (EN) R. Malan e T. Dicolen, Risk Management in an HP Reuse Project, in Fusion Newsletter, aprile 1996.
• (EN) W. Frakes e S. Isoda, Systematic Reuse, in Special Issue IEEE Software, maggio 1994.

Libri

• (EN) Ivar Jacobson, Martin Griss e Patrik Jonsson, Software Reuse: Architecture, Process, and Organization for Business Success, Addison-Wesley, 1997.
• J Hooper e R Chester, Linee guida e metodi per il riutilizzo del software, Plenum, 1991.
• (EN) E.A. Karlson, Software Reuse: A holistic approach, Wiley, 1995.
• (EN) W. Schäfer, R. Prieto-díaz e M. Matsumoto, Software Reusability, Ellis Horwood, 1994.

• Programmazione (informatica)
• Regola del tre (programmazione)
• Riusabilità

Portale Informatica: accedi alle voci di Wikipedia che trattano di informatica