Racket (linguaggio di programmazione)

Da Wikipedia, l'enciclopedia libera.
Vai alla navigazione Vai alla ricerca
Racket
linguaggio di programmazione
AutorePLT Inc.
Data di origine1994
Ultima versione8.13 (16 maggio 2024)
Utilizzo{{{utilizzo}}}
ParadigmiMulti-paradigma: funzionale, procedurale, modulare, orientata agli oggetti, logica, riflessiva, meta
Tipizzazionedinamica
Estensioni comuni.rkt, .rktl, .rktd, .scrbl, .plt, .ss, .scm
Influenzato daScheme, Eiffel[1]
Ha influenzatoScheme,[2] Rust,[3][4] Clojure[5]
Implementazione di riferimento
Sistema operativoCross-platform
LicenzaLGPL
Sito webracket-lang.org/
Modifica dati su Wikidata · Manuale

Racket (precedentemente noto come PLT Scheme) è un linguaggio di programmazione general purpose multi-paradigma della famiglia Lisp-Scheme. Uno degli obiettivi dietro alla sua progettazione è quello di servire come piattaforma per la progettazione, creazione e implementazione di nuovi linguaggi.[6][7] È usato in una varietà di contesti, come scripting, programmazione general purpose, didattica dell'informatica e ricerca.

La distribuzione fornisce un'implementazione del linguaggio (comprensiva di un sofisticato run-time system,[8] diverse librerie e compilatore JIT) insieme con un ambiente di sviluppo integrato chiamato DrRacket (precedentemente noto come DrScheme) scritto esso stesso in Racket.[9] Il linguaggio è noto per il suo versatile sistema di macro che consente di creare facilmente nuovi linguaggi e dialetti con diversi costrutti o una differente semantica.[10][11][12][13]

La distribuzione è open source, coperta da licenza GNU Lesser General Public License (LGPL),[14] ed estensioni e package realizzati dalla comunità sono disponibili attraverso un package manager centralizzato.

Storia

[modifica | modifica wikitesto]

Sviluppo

[modifica | modifica wikitesto]

Matthias Felleisen fondò PLT a metà degli anni 1990, dapprima come gruppo di ricerca, che poco dopo è divenuto un progetto orientato alla produzione di materiale didattico per programmatori. Nel gennaio 1995 il gruppo decise di creare un ambiente di programmazione didattico basato su Scheme. Matthew Flatt mise insieme MrEd, l'originale virtual machine, a partire da libscheme,[15] wxWidgets e alcuni altri sistemi liberi.[16] Negli anni successivi un team composto da Flatt, Robby Findler, Shriram Krishnamurthi, Cormac Flanagan e diversi altri realizzò DrScheme, un ambiente di sviluppo per novizi programmatori che costituiva anche un ambiente di ricerca per il soft typing.[9] Il linguaggio principale supportato da DrScheme venne quindi chiamato PLT Scheme.

In parallelo, il team iniziò a tenere workshop per insegnanti delle scuole superiori, insegnando design e programmazione funzionale. Test sul campo condotti su questi insegnanti e i loro studenti furono importanti indizi per guidare lo sviluppo.

Negli anni seguenti il gruppo PLT ha aggiunto un tool noto come algebraic stepper, per la valutazione passo-passo delle espressioni,[17] un interprete read-eval-print loop, un constructor-based printer, insieme a diversi altri strumenti. Nel 2001 i quattro sviluppatori principali del team (Felleisen, Findler, Flatt e Krishnamurthi) hanno pubblicato un libro che sintetizza la loro filosofia della didattica della programmazione, intitolato How to Design Programs.

Versioni

[modifica | modifica wikitesto]

La prima generazione di revisioni al linguaggio PLT Scheme ha introdotto costrutti per la programmazione su larga scala, con l'aggiunta di moduli e classi. La versione 42 ha introdotto le unità, un sistema di moduli first-class, complementari alle classi per lo sviluppo di programmi di grandi dimensioni.[18] Il sistema di classi ha visto l'introduzione di interfacce in stile Java e l'eliminazione di alcune caratteristiche, come l'ereditarietà multipla.[11] A partire dalla versione 53 il linguaggio ha acquisito una certa popolarità, e un rilascio principale è stato la versione 100, paragonabile alla versione 1.0 in un sistema di semantic versioning.

La successiva release principale è stata la 200, che ha introdotto un nuovo sistema di moduli predefinito, che si integra con il sistema di macro,[18] garantendo la separazione tra valutazioni eseguite a run-time e a compile-time, permettendo quindi di creare una "torre di linguaggi".[19] A differenza delle unità, questi moduli non sono oggetti di prima classe.

La versione 300 ha introdotto il supporto Unicode, FFI, e ritocchi al sistema di classi.[18] Release successive nel ramo 300 hanno migliorato le prestazioni del runtime, con l'aggiunta di un compilatore JIT e un sistema predefinito per la generational garbage collection.

Con la nuova major release, il progetto è passato ad una numerazione delle versioni più convenzionale. La versione 4.0 ha introdotto la scorciatoia #lang per specificare il linguaggio nel quale un modulo è scritto, oltre a coppie e liste immutabili, supporto per il calcolo parallelo fine-grained, e un dialetto del linguaggio a tipizzazione statica.[20]

Ridenominazione

[modifica | modifica wikitesto]

Il 7 giugno 2010, in concomitanza con la release 5.0, PLT Scheme è stato ribattezzato Racket.[21] Nella versione 5.1 il backend dell'interfaccia grafica è stato riscritto da C++ a Racket stesso, usando un sistema di widget nativi su tutte le piattaforme.[16] La versione 5.2 ha visto l'introduzione di un sistema di analisi statica del codice, una nuova libreria di plotting, una libreria di interfaccia database, e un nuovo REPL maggiormente esteso.[22] La versione 5.3 ha introdotto, tra le varie novità, una funzionalità che permette il caricamento opzionale dei submodules,[23] nuovi strumenti di ottimizzazione, una libreria JSON.[24] Nella versione 5.3.1 sono state aggiunte alcune caratteristiche a DrRacket: il controllo sintattico è stato attivato come opzione predefinita, ed è stato aggiunto un sistema di anteprima della documentazione.[25]

Nella versione 6.0 è stato introdotto un nuovo sistema di gestione dei pacchetti, con la riorganizzazione del repository e la suddivisione della distribuzione in un insieme di pacchetti più piccoli, permettendo un'installazione minimale di Racket con i pacchetti per le sole funzionalità desiderate.[26]

Caratteristiche

[modifica | modifica wikitesto]

Il core di Racket comprende macro, moduli, chiusure lessicali, tail recursion, continuazione parziale,[27] parametri, contratti,[28] green threads e OS threads.[29][30][31] Il linguaggio include anche alcune primitive, come eventspace e custodian, che controllano la gestione delle risorse e consentono di invocare e gestire programmi esterni.[8] Il linguaggio è estensibile tramite il sistema di macro particolarmente versatile, che insieme al sistema di moduli e a parser personalizzati permette di controllare e modificare il linguaggio in tutti i suoi aspetti[32] Molti costrutti dello stesso linguaggio Racket sono implementati come macro, tra i quali un sistema di classi mixin,[11] e il meccanismo di pattern matching.

Racket è stato il primo linguaggio di programmazione di ordine superiore a introdurre un sistema di contratti.[33] I contratti racket sono ispirati al design by Contract di Eiffel, che viene esteso per comprendere valori di ordine superiore, funzioni di prima classe, oggetti, reference e altre funzionalità. Ad esempio, un oggetto soggetto ad un contratto garantisce il controllo dei contratti quando i suoi metodi vengono invocati.

Il compilatore Racket traduce il sorgente in bytecode che viene eseguito dalla Racket virtual machine. Su sistemi x86 e PowerPC il bytecode viene compilato in codice nativo a runtime da un compilatore JIT.

Nel 2004 è stato introdotto PLaneT, un package manager integrato nel sistema di moduli che consente di importare e usare librerie di terze parti in maniera trasparente. PLaneT include anche un proprio sistema di versioning per evitare situazioni di dependency hell.[34] Nel 2014 buona parte del codice Racket è stato spostato in un nuovo sistema di pacchetti separato dalla codebase principale, gestito da un client chiamato raco. Il nuovo sistema di pacchetti fornisce meno funzionalità rispetto a PLaneT.[35]

Sistema di macro

[modifica | modifica wikitesto]

Una tra le principali caratteristiche che distingue Racket dagli altri linguaggi della famiglia Lisp è la sua estensibilità intrinseca. Le funzionalità di estensibilità di Racket sono integrate nel sistema di moduli, consentendo un controllo sulla sintassi a livello dei moduli stessi.[13] Ad esempio, la forma sintattica #%app può essere riscritta per modificare la semantica della chiamata di funzione. Analogamente, la forma sintattica #%module-begin permette di eseguire un'analisi statica arbitraria dell'intero modulo.[13] Ogni modulo può essere usato come un linguaggio, grazie alla notazione #lang, e il programmatore può controllare virtualmente ogni aspetto del linguaggio stesso.

L'estensibilità fornita dai moduli viene combinata con il sistema di macro igieniche analogo a Scheme, che fornisce funzionalità aggiuntive rispetto al sistema per la manipolazione delle S-expression del Lisp,[36][37] al sistema di macro di Scheme 84 o alle regole sintattiche di R5RS. Con queste funzionalità i programmatori possono aggiungere funzionalità e creare linguaggi specifici in maniera totalmente indistinguibile dalle funzionalità built-in del linguaggio.

Il sistema di macro di Racket è stato usato per l'implementazione di dialetti, tra i quali Typed Racket, una versione del linguaggio che fornisce un sistema di tipi,[38] e Lazy Racket, un dialetto che usa un sistema di valutazione lazy.[39] Altri dialetti sono FrTime (programmazione reattiva funzionale), Scribble (un linguaggio per la produzione di documentazione),[40] Slideshow (un linguaggio per la realizzazione di slide),[41] e diversi altri.[42][43] Racket fornisce alcune librerie che facilitano l'implementazione di nuovi linguaggi.[13]

I nuovi linguaggi non sono ristretti alla sintassi basata su S-expression, permettendo la definizione di parser arbitrari, ad esempio usando la libreria di strumenti di parsing fornita da Racket stesso.[44]

Ambiente di sviluppo

[modifica | modifica wikitesto]

La distribuzione Racket fornisce un IDE[9] chiamato DrRacket, un web server basato su continuazione,[45] una graphical user interface,[16] e diversi altri strumenti. Racket è anche utilizzabile come strumento di scripting, ad esempio negli script per shell Unix. Può eseguire il parsing di parametri a riga di comando, eseguire tool esterni e includere librerie.

DrRacket

[modifica | modifica wikitesto]

DrRacket (precedentemente noto come DrScheme) è un ambiente di sviluppo disponibile per Microsoft Windows, macOS, Unix e Linux, spesso usato come strumento didattico nei corsi introduttivi alla programmazione, inizialmente sviluppato come strumento per il progetto TeachScheme! (divenuto poi ProgramByDesign), avviato dalla Northeastern University in collaborazione con alcune altre università per l'insegnamento della programmazione nelle scuole superiori.

L'editor fornisce syntax highlighting, matching delle parentesi, debugger e algebraic stepper. Permette di scegliere diversi "livelli" (principiante, intermedio, etc.) per semplificare l'ambiente agli studenti. Ha un supporto integrato per le librerie e un sistema di analisi statica utile per i programmatori esperti. Fornisce un browser per i moduli, un sistema di testing e fault coverage integrati, supporto per il refactoring, e un sistema di accesso alla documentazione.

Esempi

[modifica | modifica wikitesto]

Un esempio di hello world in Racket è il seguente: 

#lang racket/base
"Hello, World!"

che quando eseguito visualizza la scritta "Hello, World!".

Il seguente è un esempio di definizione di una funzione ricorsiva per il calcolo del fattoriale: 

#lang racket
(define (fact n)
  (cond [(zero? n) 1]
        [else (* n (fact (- n 1)))]))

Applicazioni ed utilizzi

[modifica | modifica wikitesto]

Oltre all'uso come strumento didattico e nella ricerca, Racket è stato pensato come linguaggio general purpose per l'uso su sistemi di produzione. Per tale motivo, la distribuzione fornisce estese librerie che supportano programmazione di sistema e di rete, sviluppo web,[45] un'interfaccia per accedere alle chiamate del sistema operativo, FFI,[46] varie implementazioni di regex, generatori di lexer e parser,[44] programmazione logica, ed un widget toolkit.

Tra le funzionalità di Racket utili per lo sviluppo di applicazioni commerciali vi sono la possibilità di generare eseguibili nativi in ambiente Windows, macOS e Unix/Linux, profiler e debugger inclusi nell'ambiente di sviluppo integrato e un framework di unit test.

Racket è usato in progetti commerciali e applicazioni web. Tra gli esempi, il sito web Hacker News impiega Arc, che è sviluppato in Racket. Naughty Dog ha usato Racket come linguaggio di scripting per diversi videogame.[47]

Racket è usato per l'insegnamento dell'algebra tramite game design nel programma bootstrap curriculum.[48]

Note

[modifica | modifica wikitesto]
  1. ^ T.S. Strickland e Matthias Fellesisen, DLS 2010: Contracts for First-Class Classes (PDF), su ccs.neu.edu, 2010.
  2. ^ Michael Sperber, R. Kent Dybvig, Matthew Flatt e Anton Van Straaten, Revised6 Report on the Algorithmic Language Scheme (R6RS), su r6rs.org, Scheme Steering Committee, August 2007. URL consultato il 13 settembre 2011.
  3. ^ Planet2 questions, su mail.mozilla.org. URL consultato il 10 gennaio 2017 (archiviato dall'url originale il 25 giugno 2021).
  4. ^ Rust Bibliography, su github.com.
  5. ^ Ambrose Bonnaire-Sergeant, A Practical Optional Type System for Clojure, The University of Western Australia, 2012.
  6. ^ Welcome to Racket, su docs.racket-lang.org. URL consultato il 15 agosto 2011.
  7. ^ Dialects of Racket and Scheme, su docs.racket-lang.org. URL consultato il 15 agosto 2011.
  8. ^ a b Flatt, Findler, Krishnamurthi e Felleisen, Programming Languages as Operating Systems (or, Revenge of the Son of the Lisp Machine), International Conference on Functional Programming, 1999.
  9. ^ a b c Findler, Clements, Flanagan, Flatt, Krishnamurthi, Steckler e Felleisen, DrScheme: A Programming Environment for Scheme (PDF), in Journal of Functional Programming, 2001.
  10. ^ Macros Matter, su blog.racket-lang.org, 3 maggio 2007. URL consultato l'8 agosto 2011.
  11. ^ a b c M. Flatt, R. B. Findler e M. Felleisen, Scheme with Classes, Mixins, and Traits (PDF), in Asian Symposium on Programming Languages and Systems, 2006.
  12. ^ M. Flatt e M. Felleisen, Units: Cool Modules for Hot Languages, in Programming Language Design and Implementation, 1998.
  13. ^ a b c d S. Tobin-Hochstadt, V. St-Amour, R. Culpepper, M. Flatt e M. Felleisen, Languages as Libraries (PDF), in Programming Language Design and Implementation, 2011.
  14. ^ Racket: Software License, su download.racket-lang.org. URL consultato il 20 ottobre 2015.
  15. ^ Brent W. Jr. Benson, libscheme: Scheme as a C Library, in Proceedings of the USENIX Symposium on Very High Level Languages, Santa Fe, NM, USENIX Association, October 26–28, 1994, pp. 7–19, ISBN 978-1-880446-65-2. URL consultato il 7 luglio 2013.
  16. ^ a b c Rebuilding Racket's Graphics Layer, su blog.racket-lang.org, 8 dicembre 2010. URL consultato il 23 agosto 2011 (archiviato dall'url originale il 23 maggio 2013).
  17. ^ J. Clements, M. Flatt e M. Felleisen, Modeling an Algebraic Stepper (PDF), in European Symposium on Programming Languages, 2001.
  18. ^ a b c Racket Core Release Notes (TXT), su docs.racket-lang.org. URL consultato il 15 aprile 2012 (archiviato dall'url originale il 23 maggio 2013).
  19. ^ M. Flatt, Composable and Compilable Macros, in International Conference on Functional Programming, 2002.
  20. ^ PLT Scheme version 4.0, su blog.racket-lang.org, 12 giugno 2008. URL consultato il 7 agosto 2012 (archiviato dall'url originale il 23 maggio 2013).
  21. ^ From PLT Scheme to Racket, su racket-lang.org. URL consultato il 17 agosto 2011.
  22. ^ Racket 5.2, su blog.racket-lang.org, PLT, Inc, 9 novembre 2011. URL consultato il 16 giugno 2012.
  23. ^ Submodules, su blog.racket-lang.org, 3 giugno 2012. URL consultato il 7 agosto 2012.
  24. ^ Racket 5.3, su blog.racket-lang.org, PLT, Inc, 7 agosto 2012. URL consultato il 7 agosto 2012.
  25. ^ Racket 5.3.1, su blog.racket-lang.org, PLT, Inc, 7 novembre 2012. URL consultato il 7 novembre 2012.
  26. ^ Racket 6.0, su blog.racket-lang.org, PLT, Inc, 26 febbraio 2014. URL consultato il 23 febbraio 2016.
  27. ^ M. Flatt, G. Yu, R. B. Findler e M. Felleisen, Adding Delimited and Composable Control to a Production Programming Environment (PDF), in International Conference on Functional Programming, 2007.
  28. ^ Contracts, su docs.racket-lang.org.
  29. ^ Threads, su docs.racket-lang.org.
  30. ^ Futures, su docs.racket-lang.org.
  31. ^ Places, su docs.racket-lang.org.
  32. ^ Matthew Flatt, Creating Languages in Racket, in Communications of the ACM, 2012. URL consultato l'8 aprile 2012.
  33. ^ R. B. Findler e M. Felleisen, Contracts for Higher-Order Functions (PDF), in International Conference on Functional Programming, 2002.
  34. ^ J. Matthews, Component Deployment with PLaneT: You Want it Where?, in Scheme and Functional Programming Workshop, 2006.
  35. ^ The Racket package system and Planet, su blog.racket-lang.org.
  36. ^ Matthew Flatt, Composable and Compilable Macros, You Want it When? (PDF), in International Conference on Functional Programming, 2002.
  37. ^ Flatt, Culpepper, Darais, Findler, Macros that Work Together; Compile-Time Bindings, Partial Expansion, and Definition Contexts
  38. ^ S. Tobin-Hochstadt e M. Felleisen, The Design and Implementation of Typed Scheme, in Principles of Programming Languages, 2008.
  39. ^ E. Barzilay e J. Clements, Laziness Without All the Hard Work: Combining Lazy and Strict Languages for Teaching, in Functional and Declarative Programming in Education, 2005.
  40. ^ M. Flatt, E. Barzilay e R. B. Findler, Scribble: Closing the Book on Ad Hoc Documentation Tools, in International Conference on Functional Programming, 2009.
  41. ^ R. B. Findler e M. Flatt, Slideshow: Functional Presentations, in International Conference on Functional Programming, 2004.
  42. ^ M. Felleisen, R. B. Findler, M. Flatt e S. Krishnamurthi, A Functional I/O System (or Fun for Freshman Kids) (PDF), in International Conference on Functional Programming, 2009.
  43. ^ M. Felleisen, R. B. Findler, M. Flatt e S. Krishnamurthi, The Structure and Interpretation of the Computer Science Curriculum (PDF), in Journal of Functional Programming, 2004.
  44. ^ a b Parser Tools: lex and yacc-style Parsing, su docs.racket-lang.org. URL consultato il 16 agosto 2011.
  45. ^ a b Krishnamurthi, Hopkins, McCarthy, Graunke, Pettyjohn e Felleisen, Implementation and Use of the PLT Scheme Web Server (PDF), in Journal of Higher-Order and Symbolic Programming, 2007.
  46. ^ E. Barzilay e D. Orlovsky, Foreign Interface for PLT Scheme (PDF), in Scheme and Functional Programming, 2004.
  47. ^ Functional mzScheme DSLs in Game Development, su cufp.org. URL consultato l'8 maggio 2012.
  48. ^ Bootstrap, su bootstrapworld.org. URL consultato l'11 agosto 2015.

Bibliografia

[modifica | modifica wikitesto]

Collegamenti esterni

[modifica | modifica wikitesto]
Controllo di autoritàLCCN (EN) sh2013000901 · GND (DE) 1050209265 · J9U (EN, HE) 987007568232505171
  Portale Informatica: accedi alle voci di Wikipedia che trattano di informatica
Estratto da "https://it.wikipedia.org/w/index.php?title=Racket_(linguaggio_di_programmazione)&oldid=139085466"