Yoix

Yoix

File:Yoixlogo.png
Paradigm	Multi-paradigm; object-based, imperative, procedural
Designed by	Rich Drechsler and John Mocenigo
First appeared	2000
Stable release	2.3.1 / November 25, 2011 (2011-11-25)
Typing discipline	Dynamic, Weak
OS	Cross-platform
License	Open Source Initiative Common Public License
Website	https://github.com/att/yoix
Influenced by
C, Java, PostScript

Search Yoix on Amazon.

In computer programming, Yoix is a high-level, general-purpose, interpreted, object-based, dynamic programming language. The Yoix interpreter is implemented using standard Java technology without any add-on packages and requires only a Sun-compliant JVM to operate.

Initially developed by AT&T Labs researchers for internal use, it has been available as free and open source software since late 2000.

History

In 1998, Java technology was still emerging: the Swing toolkit was an add-on package; interruptible I/O, regular expressions, and a printf capability were not yet features; nor had Java Web Start been developed. Moreover, Java scripting languages were largely non-existent at that time: Groovy and JRuby had not yet been invented and Jython had just been created in late 1997. Browsers in 1998 had limited feature sets, were too unstable for production use in an 8-hour shift and were still fighting skirmishes in the Browser Wars. In this environment, Yoix technology was created in response to a pressing need for a reliable, easy to distribute and maintain, GUI front-end for a mission-critical application being developed within AT&T, namely its Global Fraud Management System, which to this day monitors and tracks fraud activity related to voice traffic on AT&T's expanding networks: wireline, wireless, and IP. Yoix technology was first released to the public in late 2000 under the Open Source Initiative Common Public License V1.0.

The Yoix name came about partially from the fox hunting cry of encouragement to the hounds, partially to echo another familiar four-letter name that ends in ix, and partially to avoid too many false-positives in a Google search.

Overview

Yoix technology provides a pure Java programming language implementation of a general purpose dynamic programming language developed by researchers at AT&T Labs. Its syntax and grammar should be easy to learn for those familiar with the C programming language and Java. To an end-user, a Yoix application is indistinguishable from a Java application, but to the application developer Yoix should provide a simpler coding experience than working in Java directly, much like writing Perl code can be simpler than writing C code.

Features

The Yoix language is not an object oriented language, but makes use of over 165 object types that provide access to most of the standard Java classes. Because the Yoix interpreter is built entirely using Java technology, it means that Yoix applications are cross-platform, GUI-capable and both network and thread friendly, yet Yoix developers find themselves insulated from the more complex and error-prone parts of coding the same functionality directly in Java. It does not use reflection to access Java functionality and thus adds value by not only simplifying access to that functionality, but also improving application reliability by coding through both Java glitches and complicated Java features one-time, behind-the-scenes. The Yoix language includes safe pointers, addressing, declarations, and global and local variables. In addition to supporting native user functions, users can add their own builtin functions written in Java.

Design

The two central elements in the Yoix design are borrowed from the PostScript language: dictionaries as language components and permissions-protected dictionaries as exposed system components. Homage to the Tcl language and its exposure philosophy should also be given, though it did not have a direct influence.

Another key Yoix design element involves pointers and addressing. Pointers and pointer arithmetic in the Yoix language is syntactically similar to what is found in the C language, but the Yoix implementation prevents using a pointer outside its bounds. In addition, the address operator always produces a valid, usable result.

Overall, the Yoix design attempted to make the language easy to learn by programmers experienced with the C and Java languages.

Applications

The Yoix distribution includes the Yoix Web Application Instant Template (YWAIT), a software framework for building a Yoix web application. A Yoix web application resides on a web server and is downloaded piecemeal at run-time on an as-needed basis by Yoix interpreters running on client machines. This model, analogous to the familiar model of client web browsers downloading a website piecemeal as-needed at run-time, permits simple, efficient distribution and maintenance of applications and relies only on the ubiquitous web server and the Yoix interpreter. Building a web application using the YWAIT framework requires just a few standard Unix tools available in most modern operating systems, such as Linux or Mac OS X, or under Microsoft Windows with the help of add-on packages such as U/Win. The client side of a YWAIT-based application relies only on the Yoix interpreter and is thus platform independent, running wherever Java runs. Because the Yoix software development philosophy aims to keep things simple by eschewing the popular tendency for multiple embedded specialized languages and the YWAIT framework permits easy, incremental screen development in a simple, logical source tree hierarchy, development of a Yoix web application is reduced to the basics: a command prompt and a text editor. IDE enthusiasts may be nonplussed, but this Small Is Beautiful approach to software development has been highly effective in practice at AT&T.

Data visualization

In addition to its role as a tool for building GUI applications, Yoix technology supports several modes of data visualization.

Data mining

A data visualization module called YDAT (Yoix Data Analysis Tool) has been included in the public Yoix distribution since release 2.1.2. YDAT uses a data manager component to coordinate data display and filtering among its several visualization components that include an event plot, a graph drawing pane, histogram filters and tabular detail. YDAT is able to display graphs generated by the GraphViz graph drawing and layout tool, which is another open source tool freely available from AT&T Labs. YDAT is highly configurable at the Yoix language level. The image below is a screenshot of a Yoix YDAT instantiation, which in this example is being used to analyze vehicle auction transactions.

Graph drawing

Yoix technology provides good support for graph drawing. In addition to graph display mentioned above as part of the YDAT module, data types in the Yoix language support building, manipulating and traversing graph structures. Native Yoix functions support the DOT language output and a built-in DOT language parser to facilitate interaction with the GraphViz layout engines.

Organizing cells of data

The YChart data visualization toolkit was added to the Yoix distribution with release 2.2.0. YChart allows one to organize and display cells of data. Two interactive YChart applications contained in the Yoix distribution are a Periodic Table of the Elements and a Unicode Chart. A program to demonstrate using YChart with variable width cells, as might occur with a schedule, is also available in the Yoix distribution.

Interactive 2D graphics

The Yoix distribution also includes a Yoix package, called Byzgraf, for rendering basic data plots such as line charts, histograms and statistical box plots.

Limitations and focus

As currently implemented, the Yoix language is interpreted, which means that, for example, it is probably not the right choice for computationally intensive applications unless one codes those computations in a Java module extension. Similarly, excessive looping will also display the limitations of this interpreted language. The focus of the language is interactive standalone or client/server GUI and data visualization applications.

Licensing

Yoix technology is free software licensed under the Open Source Initiative Common Public License. Yoix is a registered trademark of At&T Inc.

Examples

1. Extract all HTML directives from the AT&T home page and write them to standard output.

import yoix.*.*;

URL att = open("https://www.att.com", "r");
String text;
int cnt = 0;
while (cnt >= 0) {
    if ((cnt = fscanf(att, " <%[^>]>", &text)) > 0)
        printf("<%s>\n", text);
    else cnt = fscanf(att, " %*[^<]");  // discard
}

2. Build and display a GUI with two buttons in a titled frame (i.e., window) that also has a titled border. One button pops up a message when pressed, the other quits the example. The window is sized automatically to just fit its components, and some additional code calculates its location to put it in the center of the screen before making it visible.

import yoix.*.*;

JFrame  jf = {
  Dimension  size = NULL; // auto-size window

  FlowLayout  layoutmanager = {
    int hgap = 18; // 0.25 inch gap
  };

  String  title = "Wikipedia Yoix Example"; // window title
  String  border = "Simple Button Example"; // border title

  Array  layout = {
    new JButton {
      String  text = "Press for Message";

      actionPerformed(ActionEvent ev) {
        showMessageDialog(root, "Hello, world.", "Message Example");
      }
    },
    new JButton {
      String  text = "Press to Exit";

      actionPerformed(ev) { // ActionEvent declaration can be omitted
        exit(0);
      }
    },
  };
};

// set frame location to center of screen now that frame size is known
jf.location = new Point {
  int x = (VM.screen.width - jf.size.width) / 2;
  int y = (VM.screen.height - jf.size.height) / 2;
};

// make it visible
jf.visible = TRUE;

3. The code shown here was used to generate the Yoix logo image in PNG format that can be seen in the language description box near the top of this page. Command-line arguments allow the size of the image to be specified as well as select between PNG image output or display in an on-screen window.

import yoix.*.*;

BuildYoixLogoImage(double height, Color color, int addshadow) {
  // create the basic image, without shadow
  GenImage(double height, Color color, Font imagefont, double scale) {
    Image yoixlogo = {
      int type = TYPE_RGB_ALPHA;
      Color imgcolor = color;
      double scale = scale;
      Font imagefont = imagefont;
      Font regfont = imagefont.scalefont(0.5, 0.5);
      Graphics graphics = {
        Font font = imagefont;
        int textantialiasing = TRUE;
      };
      double ywd = stringWidth(graphics.font, "Y");
      Dimension size = {
        double height = height;
        double width = ywd * 5.25;
      };
      double owd = stringWidth(graphics.font, "o");
      double iwd = stringWidth(graphics.font, "i");
      double xwd = stringWidth(graphics.font, "x");
      ywd += iwd;
      ywd /= 2.0;
      paint(Rectangle r) {
        double alpha = 1.0;
        double alpha2 = 0.3333;
        int    limit = 12;
    
        graphics {
          gsave();
          erasedrawable(0.0); // for transparent PNG
          rectclip(r);
          setrgbcolor(imgcolor.red, imgcolor.green, imgcolor.blue);
          translate(48 * this.scale, 44 * this.scale);
          for (n=0; n<limit; n++) {
            moveto(0.0, 0.0);
            setfont(this.imagefont);
            // "handmade" kerning
            show("Y", alpha);
            if (n == 0) {
              moveto(ywd, 0.0);
              show("o", alpha);
              moveto(ywd + owd - 0.3 * iwd, 0.0);
              show("i", alpha);
              moveto(ywd + owd + 0.8 * iwd, 0.0);
              show("x", alpha);
              moveto(ywd + owd + 0.8 * iwd + xwd, -this.imagefont.height * 0.33);
              setfont(this.regfont);
              show("\xAE", alpha);
              alpha = alpha2;
            }
            alpha *= 0.75;
            rotate(30);
          } 
          grestore();
        }
      }
    };

    return(yoixlogo);
  }

  Font basefont = {
    String name = "ClearviewATT-plain-48";
  };
  double scale = height / 90.0;
  Font imagefont = basefont.scalefont(scale, scale);

  if (addshadow) {
    Image logo = GenImage(height, color, imagefont, scale);
    image = new Image {
      int type = TYPE_RGB_ALPHA;
      Image source = logo;
      Image img = logo;
      // convolve image to make a (lightened) shadow
      Image shadow = new Image {
        int type = TYPE_RGB_ALPHA;
        Image source = img;
        Array kernel = new Array[100];
        Pointer ptr;
        for (ptr in kernel) *ptr = 0.0055;
        paint() {
          convolve(kernel);
        }
      };
      // combine the image and shadow into one image
      paint(Rectangle r) {
        graphics {
          gsave();
          moveto(0, 0);
          showimage(this.img);
          moveto(this.img.size.height * 0.005, this.img.size.height * 0.02);
          showimage(this.shadow);
          grestore();
        }
      }
    };
  } else {
    image = GenImage(height, color, imagefont, scale);
  }

  return(image);
}

// rudimentary argument processing (getopt is also available)
// first argument is height of image
double sz = (argc > 1) ? atof(argv[1]) : 270;
int shdw = 1;
int print = 0;
// second argument: if 0/1 turn shadow off/on, otherwise
// assume it is a filename for printing.
if (argc > 2) {
  if (argv[2] =~ "^[01]$") {
    shdw = atoi(argv[2]);
  } else {
    print = 1;
  }
}

Image yoixlogo = BuildYoixLogoImage(sz, Color.black, (sz >= 72) && shdw);

if (print) {
  Stream output;

  if ((output = open(argv[2], "w")) != NULL) {
    encodeImage(yoixlogo, "png", output);
    close(output);
  }
} else {
  JFrame jf = {
    int visible = TRUE;
    Dimension size = NULL;
    Array layout = {
      new JPanel {
        Dimension preferredsize = {
          double width = yoixlogo.size.width;
          double height = yoixlogo.size.height;
        };
        Color background = Color.white;
        Image backgroundimage = yoixlogo;
        int backgroundhints = SCALE_NONE;
      },
    };
  };
}

External links

• Archive of original AT&T Labs-Research: Yoix Home Page
• Web Engineering Workshop Paper
• Software - Practice & Experience Paper

This article "Yoix" is from Wikipedia. The list of its authors can be seen in its historical and/or the page Edithistory:Yoix. Articles copied from Draft Namespace on Wikipedia could be seen on the Draft Namespace of Wikipedia and not main one.

---