Judoscript - Judoscript

Judoscript
Paradigma procedurale , orientato agli oggetti , scripting
Progettato da James Jianbo Huang
Sviluppatore James Jianbo Huang
Apparso per la prima volta novembre 2001
Rilascio stabile
v0.9 / novembre 2005
Disciplina di digitazione dinamico , statico , forte
piattaforma JVM
Licenza LGPL
Sito web judoscript.com
Influenzato da
SQR , Perl , JavaScript , Java

Judoscript è un linguaggio di programmazione generico progettato principalmente per attività di scripting sulla piattaforma Java . È stato concepito e sviluppato da James Jianbo Huang ( cinese semplificato :黄剑波; cinese tradizionale :黃劍波; pinyin : Huáng Jiànbō ), a partire dalla fine del 2001. Judoscript è stato uno dei primi cosiddetti linguaggi di scripting Java; ma le sue caratteristiche più sorprendenti sono la sua audace filosofia e pratica di supporto multidominio.

Entro la fine del 2005, Judoscript ha completato tutte le funzionalità dell'applicazione designate. La situazione con i linguaggi di scripting Java è cambiata rapidamente quando JavaSoft ha annunciato di crearne uno proprio nel 2003. Lo sviluppo di Judoscript è stato interrotto quando il linguaggio Groovy di JavaSoft era vicino al rilascio.

Storia

Huang ha lavorato a uno scrittore di report commerciali, SQR , ampiamente utilizzato in PeopleSoft . Tecnicamente, SQR è un linguaggio di scripting arrogante e generico con SQL incorporato e direttive di reporting per la produzione di report basati sui caratteri e la manipolazione dei dati. Scritto in C, è portato su quasi tutte le versioni dei principali sistemi operativi e funziona con tutti i principali database RDBMS . Con l'avvento di Java e JDBC , Huang si rese presto conto che una singola versione di tale software avrebbe eliminato l'intera gamma di diverse porte di SQR. Questo era il seme dell'idea Judoscript .

Anche alla fine degli anni '90, l'SQL incorporato non era un'idea nuova; per esempio, Oracle 's Pro * C ha fatto proprio questo. Sorprendentemente, l'SQL incorporato è effettivamente una funzionalità specifica del dominio ( RDBMS ) integrata in un linguaggio di uso generale. L'espressione regolare in Perl è un altro buon esempio, nel dominio della gestione del testo. La visione di Judoscript ha iniziato a prendere forma, per essere un linguaggio di scripting generico con espressività dichiarativa per molti domini di programmazione popolari in modo coerente. All'inizio del millennio, Internet ha iniziato a permeare le nostre vite e un numero crescente di tecnologie chiave stava diventando ampiamente adottato, quindi la scelta di domini specifici da supportare in Judoscript non era una cosa troppo difficile. In un certo senso, questa visione è nata al momento giusto. Le funzionalità specifiche del dominio incorporate durante la vita di Judoscript includevano script JDBC, programmazione SGML e XML in stile SAX , script WSDL, script Ant, file system unificato e script di archivio, script Microsoft COM , esecuzione di eseguibili nativi del sistema operativo , invio di posta, HTTP e Script SCP e, ultimo ma non meno importante, script Java. Se Judoscript avesse continuato a crescere, avrebbe prevedibilmente contenuto un supporto sempre più specifico per il dominio man mano che le nuove tecnologie diventavano prevalenti, come NoSQL , AI , ecc.

Essendo un linguaggio di scripting basato su JVM, Judoscript ha lo scripting Java come cittadino di prima classe. Judoscript ha aperto la strada al supporto Ant nativo , consentendo agli utenti di attingere al vasto pool di utilità nell'ecosistema Ant . Grazie alle funzionalità di scripting native con Java, Ant, WSDL, HTTP e COM di Microsoft, gli utenti di Judoscript possono utilizzare facilmente risorse da fonti eterogenee. Il linguaggio di base di Judoscript è molto JavaScript più la dichiarazione di classe statica. Come tutti i linguaggi di scripting , Judoscript ha vari zuccheri sintattici , letterali stringa multilinea, letterali XML ed espressioni regolari, una printdichiarazione versatile , ecc. Tuttavia, mentre questi aspetti dominano il design della maggior parte degli altri linguaggi, la programmabilità generale è un punto di discussione meno significativo rispetto alle caratteristiche chiave e uniche della lingua.

La prospettiva iniziale di Judoscript si è cristallizzata e lo sviluppo è iniziato alla fine del 2001; la prima versione è stata rilasciata a novembre. Judoscript è diventato uno dei primi linguaggi di scripting generici progettati specificamente per l'uso con la piattaforma Java, insieme a Rhino , BeanShell , Jython e pochi altri.

Nel 2004, Judoscript si è avvicinato alla versione 0.9. Lo sviluppo è proseguito fino al 2005, quando è stata implementata la maggior parte delle funzionalità finali. Una caratteristica chiave mancante è la generazione di bytecode Java offline o in fase di runtime, che era considerata essenziale affinché un linguaggio del genere raggiungesse la versione 1.0. Per questo Huang ha inventato un linguaggio di assemblaggio di macro Java, Jamaica . Ma questo lavoro per Judoscript non è mai stato realizzato.

In JavaOne 2003, a giugno, JavaSoft ha annunciato l'intenzione di creare un linguaggio di scripting interamente di proprietà per la piattaforma Java. Questa mossa monopolistica ha soffocato la vita della maggior parte dei suoi concorrenti. Il risultato è stato il linguaggio Groovy, il cui nome è apparentemente un morphing fonetico di "jruby", con la sua prima versione rilasciata nel 2007. Il suo supporto Ant integrato è sospettosamente connesso alla funzione di scripting Ant di Judoscript , cronologicamente parlando. Quando Groovy stava per essere scatenato, Judoscript ha perso slancio per andare avanti. Alla fine del 2005, dopo soli quattro anni, lo sviluppo di Judoscript è stato interrotto.

Anche così, Judoscript è rimasto caro ai designer e agli appassionati di linguaggi e occupa un posto nella storia del linguaggio di programmazione , essendo il primo e forse l'unico linguaggio generico con così tante funzionalità native specifiche del dominio integrate. Il motivo di ciò verrà approfondito in seguito.

Progettazione del linguaggio

Il design del linguaggio Judoscript fonde due sapori distinti. Innanzitutto, è un linguaggio di scripting generico come qualsiasi linguaggio di programmazione moderno, che utilizza la digitazione dinamica e la notazione dei punti per accedere ai membri degli oggetti. Supportando paradigmi sia procedurali che orientati agli oggetti, mette in mostra la dichiarazione di classe statica e l'ereditarietà. Vari zuccheri sintattici e una printdichiarazione versatile caratterizzano la sua natura di linguaggio di scripting.

Judoscript è completamente in grado di eseguire script di risorse Java. La sua funzionalità di digitazione statica è stata introdotta principalmente per invocare metodi Java sovraccaricati.

Il secondo sapore, che allontana Judoscript dal resto della folla, è la sua incarnazione di una serie di affermazioni specifiche del dominio nativo, ognuna con un aspetto molto diverso. Alcuni restituiscono un valore, altri no. La maggior parte di queste istruzioni speciali può essere utilizzata come istruzioni regolari in qualsiasi punto del programma.

Le espressioni possono essere incorporate nelle istruzioni specifiche del dominio ove appropriato. Le espressioni possono anche essere incorporate in letterali testuali come stringhe e valori XML, rendendoli effettivamente modelli testuali.

Caratteristiche del linguaggio I: un potente linguaggio di scripting

La lingua di base

Il linguaggio di base Judoscript è quasi identico a JavaScript per le dichiarazioni di variabili e costanti, le istruzioni di controllo del flusso e la notazione dei punti per l'accesso ai membri degli oggetti. Oltre ai due commenti in stile C++, ha una terza forma, /? ?/, utile per disabilitare un pezzo di codice. I parametri della funzione possono avere valori predefiniti e la chiamata può assumere valori di parametro denominati. Come in JavaScript, anche le funzioni sono oggetti e possono essere passate come valori. La programmazione dinamica è disponibile tramite i comandi evale evalExternal.

Programmazione orientata agli oggetti

A differenza di JavaScript, le classi definite dall'utente sono dichiarate staticamente, ma i membri dati sono dinamici. L'ereditarietà multipla è supportata e i programmatori dovrebbero gestire potenziali problemi di eredità dei diamanti. Le istanze di classe possono essere trasposte in un altro tipo. 

class Node
{
  constructor {
    assert(name != null);  // mandates that 'name' must be initialized
    children = [];
  }
  function addChild child { children.add(child); }
  function toString { return name; }
}

Organizzazione del codice

Judoscript ha una !includedirettiva per includere altri scriptlet. Questo è l'unico meccanismo per condividere il codice scritto in Judoscript.

La mancanza di supporto per pacchetti o moduli simili a Java in altri linguaggi è intenzionale, al fine di scoraggiare la creazione di librerie scritte in Judoscript. Le librerie riutilizzabili sono incoraggiate a essere scritte in Java e lasciare che Judoscript (o qualsiasi linguaggio di scripting Java) utilizzi.

Caratteristiche del linguaggio II: script Java

Lo scripting Java è un cittadino di prima classe in Judoscript. Di seguito sono elencate alcune delle funzionalità di scripting Java più importanti. Fare riferimento alla documentazione per vedere tutti gli usi e gli esempi.

Script di oggetti Java

a = new java::java.util.HashMap;
a.put('date',      Date(2001,1,1));
a.put('integer',   1);
a.put('double',    10.01);
a.put('string',    'Hello, World!');
a.put('Dimension', new java::java.awt.Dimension(10,20));
for k in a.keys() {
  println k:>10, ' = ', a.get(k);
}

props = new java::Properties(
          a.b.c.d.e.f.g = 'a thru g',
          h.i.j.k.l.m.n = 'h thru n'
        );
println props;

Aliasing di metodi statici Java

La capacità di alias metodi statici Java come funzioni Judoscritp è un meccanismo importante, responsabile di molte funzioni integrate. 

function prop for java::System.getProperty();
function now  for java::System.currentTimeMillis();
function rt   for java::Runtime.getRuntime();

println now(), nl;
println prop('java.class.path'), nl;
rt().gc();

Utilizzo delle classi Java come valori

Le classi Java sono anche valori oggetto e possono essere assegnate a variabili o costanti. 

const #Types = java::java.sql.Types;
fields = [ 'BIT', 'TINYINT', 'SMALLINT', 'INTEGER', 'BIGINT', 'FLOAT', 'REAL',
  'DOUBLE', 'NUMERIC', 'DECIMAL', 'CHAR', 'VARCHAR', 'LONGVARCHAR', 'DATE',
  'TIME', 'TIMESTAMP', 'BINARY', 'VARBINARY', 'LONGVARBINARY', 'NULL', 'OTHER',
  'JAVA_OBJECT', 'DISTINCT', 'STRUCT', 'ARRAY', 'BLOB', 'CLOB', 'REF'
];

println 'JDBC types in Java ', sysProperty('java.version'), ':';
for fld in fields {
  println fld:<13, ': ', #Types.(fld);
}

Estensione delle classi Java e implementazione delle interfacce Java

È possibile definire classi Judoscript che estendono le classi Java o implementano interfacce Java. 

class MyHashMap extends java::HashMap
{
  // Test overriding an existing method
  int hashCode() { return super.hashCode() ^ 1; }

  // A new method.
  String[] getKeys() {
    arr = [];
    for x in this { arr.add(x); }
    return arr.toStringArray();
  }

  // A new method.
  Object[] getValues() {
    arr = [];
    for x in values() { arr.add(x); }
    return arr.toObjectArray();
  }
}

È possibile creare e utilizzare adattatori di interfaccia Java anonimi. 

import java.awt.Frame;
import java.awt.event.*;

f = new java::Frame;
f.addWindowListener(
  new java::WindowListener {
    void windowClosing(WindowEvent e) { exit 0; }
  }
);
f.setVisible(true);

Funzionalità linguistiche III: supporti di domini speciali

Questa parte della lingua è ciò che rende unico Judoscript. Ogni supporto di dominio principale sarà toccato brevemente, di solito con esempi.

Script JDBC

Lo scripting JDBC è una caratteristica centrale di Judoscript, nonché una motivazione chiave per il linguaggio stesso. Rende le operazioni del database intuitive e convenienti.

Di seguito è riportato un esempio che si connette al database ed esegue alcune istruzioni SQL. 

db::connect to 'jdbc:oracle:thin:@dbsvr:1521:dbname', 'user', 'pass';
if tableExists('EMP') {
  db::sql: DROP TABLE emp;
}
db::sql {
  CREATE TABLE emp(emp_no     INTEGER PRIMARY KEY,
                   first_name VARCHAR(100),   // First Name
                   last_name  VARCHAR(100),   // Last Name
                   birth_date DATE,           -- Birth Date
                   salary     NUMBER);        -- Salary

  CREATE INDEX emp_fname ON emp(first_name);
  CREATE INDEX emp_lname ON emp(last_name);

  INSERT INTO emp(emp_no,first_name,last_name,birth_date,salary)
  VALUES( 100, 'Jim', 'Malone', to_date('1-3-1954','dd-mm-yyyy'), 86500.0);
}
println 'db::sql result: ', $_;
disconnect();

L'utilizzo delle stored procedure avviene tramite l' db:anyistruzione. 

db::any [[*
  CREATE PROCEDURE test_proc(
    param_io IN OUT NUMBER,
    param_i  IN     VARCHAR,
    param_o  OUT    VARCHAR)
  AS BEGIN
    param_o := param_i;
    IF param_io IS NOT NULL THEN
      param_io := param_io + 1;
    ELSE
      param_io := -1000;
    END IF;
  END;
*]];

L'utilizzo più interessante sono le query e gli aggiornamenti parametrizzati. Le query e gli aggiornamenti possono essere eseguiti direttamente o in modo preparato. 

db::prepare ins:
  INSERT INTO emp( emp_no, first_name, last_name, birth_date, salary  )
           VALUES( :empNo, :firstName, :lastName, :birthDate, :salary )
;

for row in rows {
  db::sql ins with @empNo:Integer  = id++,
                   @firstName      = row[0],
                   @lastName       = row[1],
                   @birthDate:Date = row[2],
                   @salary:Number  = row[3];
}

Di seguito è riportato un esempio di query. 

db::query qry:
  SELECT emp_no, first_name, last_name, birth_date, salary
  FROM emp
;

println 'ID   First-Name  Last-Name    Salary    Birth-Date', nl,
        '---  ----------  -----------  --------  ----------';
while qry.next() {
  println qry[1].int()   :<5,
          qry.first_name :<12,
          qry.last_name  :<12,
          qry.salary     :*7.1, '  ',
          qry.birth_date.fmtDate('yyyy-MM-dd');
}

Elaborazione di documenti SGML e XML

SGML è il formato ipertestuale generico che include HTML e XML. Esistono due API per l'elaborazione di documenti XML: API semplice per XML (o SAX) e Document Object Model (o DOM). L'elaborazione SAX esegue la scansione dell'intero testo come un flusso e attiva gli eventi per ogni tag o segmento di testo rilevato. Judoscript ha una piccola dichiarazione carina che fa uso di questa funzionalità in modo efficace per i dati XML e SGML.

Il prossimo esempio mostra l'essenza dello scraping HTML. Con questo, scrivere un sito web crawler non è lontano dalla realtà! 

do 'http://www.judoscript.org' as sgml {
    <a>:  if $_.href != null { println 'Found a hyperlink:', $_.href; }
    <p>:  println 'Found a paragraph tag.';
    TEXT: println 'Found some text:', $_.length();
}

L'esempio seguente elabora i dati XML aggiunti alla fine dello script. 

do $$local as xml
{
<book>:       println ($_.hardcover=='true')?"Hard":"Soft", '-cover Book ------------';
<date>TEXT:   println '  Date: ', $_, ' (', $_.type, ')';
<title>TEXT:  println ' Title: ', $_;
<author>TEXT: println 'Author: ', $_;
<isbn>TEXT:   println '  ISBN: ', $_;
}
EndScript -------------------------------------------------------
<booklist>
 <book>
  <title> UNIX in a Nutshell </title>
  <author> Daniel Gilly </author>
  <publisher> O&apos;Reilly &amp; Associates, Inc. </publisher>
  <isbn> 1-56592-001-5 </isbn>
  <date type="first edition"> 1986-12 </date>
  <date type="second edition"> 1992-06 </date>
 </book>
 <book hardcover="true">
  <title> Advanced Programming in the UNIX Environment </title>
  <author> Richard Stevens </author>
  <publisher> Addison-Wesley </publisher>
  <isbn> 0-201-56317-7 </isbn>
  <date type="copyright"> 1993 </date>
  <date type="twelfth printing"> 1996-12 </date>
 </book>
</booklist>

Judoscript supporta anche l'elaborazione DOM e XSLT di documenti XML.

Script di Apache Ant

Apache Ant è stato per lungo tempo il sistema di compilazione per Java; aziende e sviluppatori hanno creato molte estensioni chiamate Task s, in gergo Ant, e l'ecosistema Ant diventa un tesoro di tutti i tipi di utilità, sia di uso generale che proprietarie. Judoscript ha incluso un meccanismo per invocare direttamente qualsiasi attività Ant. Di seguito è riportato un esempio. 

a = 'ants';
anttask::<echo message="Hello, ${a}!"/>
anttask::<echo>Hello, more ${a}!</echo>

Esistono modi per eseguire eseguibili nativi in ​​Judoscript, ma puoi anche ricorrere allo scripting Ant, come mostrato di seguito. 

src = '.';
anttask::<exec dir="${src}" executable="cmd.exe" os="Windows 2000" output="dir.txt">
  <arg line="/c dir"/>
</exec>

File system unificato e script di archivio

La manipolazione dei file è una delle attività più comuni per gli Information Worker. Judoscript si sforza di fornire un'esperienza coerente con i file sia nei file system che negli archivi come i file ZIP e le palle TAR.

I seguenti esempi esaminano i file in un archivio ZIP. 

listFiles '*' in 'awebapp.zip' dirOnly;
for x in $_ {
  // get status for each directory
  listFiles '*.java, *.jj' in x recursive size compressedSize;
  println $_[0]:>8, '  ', $_[1]:>8, '  ', x;
}

Il prossimo esempio copia i file in un archivio ZIP. Modificando leggermente le espressioni, è possibile copiare i file in un'altra posizione nel file system. 

copy '*.java, *.properties' in 'C:/temp/classes/' recursive
     into 'judo.jar' store manifest
[[*
  Manifest-Version: 1.0
  Main-Class: judo
  Created-By: James Jianbo Huang (c) 2001-(* #year *)
*]]
;

Un altro esempio per ZIP con un controllo più preciso. 

zf = createZip('~/archives/work-'+Date().fmtDate('yyyyMMdd')+'.zip');

copy '*' in 'c:/judo/src/' except '*/alfa*, */beta*, */save/*'
  recursive noHidden echo
  into zf under 'src/';

copy '*' in 'c:/judo/docs/' except '*/alfa*, */beta*, */save/*'
  recursive noHidden echo
  into zf under 'docs/';

copy '*' in 'c:/judo/examples/' except '*/alfa*, */beta*, */save/*'
  recursive noHidden echo
  into zf under 'examples/';

zf.close();

E puoi copiare le risorse Internet su file system o archivi, come mostrato di seguito. 

tar = createTar('yahoo_comp.tar.gz');
zip = createZip('yahoo_comp.zip');
urls = [
  'http://dir.yahoo.com/Computers_and_Internet/index.html',
  'http://dir.yahoo.com/Computers_and_Internet/Internet/index.html',
  'http://dir.yahoo.com/Computers_and_Internet/Internet/WAIS/index.html'
];
for u in urls {
  copy u into tar keepDirs;
  copy u into zip keepDirs;
}
tar.close();
zip.close();

Scripting del servizio web SOAP

Ai tempi di Judoscript, il servizio Web SOAP era lo standard del settore per le chiamate remote prima che emergesse l'API RESTful. Judoscript semplifica l'utilizzo dei servizi Web SOAP. 

svc = wsdl::'http://coldrooster.com/dhtmldude/mathservice.asmx?WSDL';
println '3 + 2 = ', svc.Add(3, 2);
println '3 - 2 = ', svc.Subtract(3, 2);
println '3 * 2 = ', svc.Multiply(3, 2);
println '3 / 2 = ', svc.Divide(3, 2);

Altre caratteristiche dell'applicazione

Judoscript ha tutti i tipi di gadget di programmazione per coprire la maggior parte delle attività quotidiane per gli operatori dell'informazione, come l'esecuzione di eseguibili nativi del sistema operativo, l'invio di e-mail, l'esecuzione di lavori pianificati, l'accesso alle risorse Internet tramite HTTP, SSH, SCP, l'avvio del proprio server HTTP, eccetera.

La capacità di scripting di Microsoft COM apre le porte ai documenti di Microsoft Office, utilizzando il loro DOM per accedere e manipolare i dati al loro interno e integrarsi con altri archivi e fonti di dati.

Implementazione

La grammatica del linguaggio Judoscript e il suo parser sono realizzati con lo strumento JavaCC . Molte istruzioni complesse specifiche del dominio costituiscono un sottolinguaggio a sé stante che garantisce un sub-parser incorporato. Altre affermazioni di questo tipo e alcuni zuccheri sintattici richiedono metodi nativi nel file di grammatica JavaCC . A causa di queste complessità, il parser produce direttamente la rappresentazione interna del programma, prontamente eseguibile dal motore del linguaggio.

Ci sono molte librerie di supporto incluse nel runtime del linguaggio; alcuni sono di terze parti, altri sono sviluppati internamente.

Guarda anche

Riferimenti

link esterno