From JavaWIDE

Priority and Difficulty of Projects

Priority (most pressing to least pressing) & Difficulty (easy to hard)

Security & Performance of JavaWIDE
Multi-OS Installation & Guide
Bug Fix and Feature Additions
IDE Plugins
Applet Debugger
Integration with Media Computation & Facebook libraries

JavaWIDE How-to Videos and Documentation

Since there are so many different tools out there like JavaWIDE, it is important that visitors to the site are able to quickly determine:

if JavaWIDE useful for what they want to do
how JavaWIDE is different from similar tools
how hard it is to learn to use JavaWIDE
if JavaWIDE has the desired features

This JavaWIDE website does this to some degree, but it could be much, much better. Here are some of the ways:

make videos introducing visitors to the basics of what JavaWIDE is and how it works
make videos describing some of the more advanced parts of JavaWIDE
develop a better help system that is responsive to questions from the community
create a known buglist
integrate JavaWIDE with social networking sites

Working on this project requires patience and attention to detail. The development of JavaWIDE does not wait for documentation nor does it restrict the changes. The tool changes quickly to become more user friendly and to provide desired features. Much of the work done as part of this project will need frequent editing.

In particular here are some of the activities that the skills a person who takes on this project would need to have or develop:

Ability to perform screen capture with audio
Video editing capabilities including cutting, voice overs, and the inclusion of subtitles for descriptions
Ability to convey a technical message in a concise, understandable format
Be able to adapt a message to reach different audiences of JavaWIDE (middle & high school students, teachers, professors, developers, interested community members, school administration, policy makers, grant reviewers, etc).
Patience when works needs to be redone as JavaWIDE evolves

Starting Projects

Make a screencast of the making of a HelloWorld application
Make a screencast of making a simple GridWorld application
Make a screencast of making a simple FANG Engine game

These videos should be short, about 2-3 minutes long if possible. They should be done using a variety of web browsers (IE, Chrome, Safari, Firefox) and OS (Mac, Windows, Linux). There does not need to be one of each combination - that would be 36 videos!!! Each of the videos should include the following activities:

Start from sandbox.javawide.org (or gridworld.javawide.org or sandbox.fangengine.org)
Automatically generate a program
Save the program
Run the program
Edit the program
Save and rerun
Exit the IDE
Show the history tab
Show the tooltips and linked source
Show where the program's URL is

Here are some other parts to getting started:

Suggest how the applets/applications could be easily sent/posted to social networking sites.
Create a word cloud of search terms

Integration with Media Computation & Facebook libraries

JavaWIDE is currently integrated with the FANG Engine, Ucigame, and GridWorld. These were all fairly easy to incorporate into JavaWIDE because they were written to be run as applets. The Media Computation libraries were designed to run as an application since they require file I/O. JavaWIDE already supports file input, and it can support file output when adequate security and/or structure is added. This project involves modifying the Media Computation libraries by adding a level of indirection to the file I/O. Once this is complete, the file input can be redirected to use JavaWIDE's file input. The file output can be created on JavaWIDE in a secure manner, or the data can be streamed for viewing the end product (as opposed to storing it as a file).

After completing the Media Computation addition, it will be possible to start work on integrating JavaWIDE into the Facebook Java API.

This project is restricted to an individual who has already worked on the Media Computation code base or has completed a JavaWIDE project on this page.

IDE Plugins

JavaWIDE within a web browser is intended to be a temporary environment. It is expected that programmers will eventually go to a full featured IDE such as NetBeans or Eclipse. Transition to and from JavaWIDE to these professional grade IDEs should be as simple as possible. As such, it would be great to provide a plugin in the IDE that draws the source files needed from the JavaWIDE server and writes them to the server as they are saved. Here is the basic way the service would work:

Instead of reading Java files from the file system, it reads them from the server
In addition to writing Java files to the local file system, it also writes them to the server
All class files are compiled locally and never written to the server
There is no locking or merging of files
Version histories of individual source files are available to resolve conflicts

Another part of this project can be developing plugins for educational based IDEs such as BlueJ and DrJava

Applet Debugger

Warning: this could be a large project.

A major part missing on JavaWIDE is the debugger. Like all parts of JavaWIDE, creating a debugger is difficult because of the restricted environment. It is usually not possible to use already created debuggers due to their size (bigger than an applet should be) and their security (most are designed as applications that break the applet security model). Here is a basic plan for getting started on this project:

Experiment with the most basic text-based Java debugger you can find (there are examples available as part of the Java debugging architecture)
Examine the source code of this debugger
Modify the debugger to run within a JTextField
Try making the debugger into an applet

After these are done, the project will be off to a good start. As far as I know, no one has ever created an applet debugger, so the feasibility of it needs to be explored first. While working on this project, keep in mind that the debugger must operate entirely on the client - no server processing. The only thing the server can provide is class files and source code.

Bug Fix and Feature Additions

JavaWIDE works fairly well, but it does have some rough edges and crashes occasionally. This bug fixing part of this project would include cleaning up code, documenting it, and modeling the threading done in the system to avoid/reduce deadlocking issues. Working on this project requires

Java - advanced skills
Javascript - intermediate skills
PHP - beginner to intermediate skills
XML - basic skills
Patience and attention to detail
Understanding the need for scalable efficient server code

Once the cleanup and documentation is complete, there are several feature additions desired, and many may also be discovered as part of this cleanup. In particular, here are a few feature requests:

Automated saving of backups
Auto-import while typing (not requiring save)
Prefetching used classes to provide fast code completion
Using imports to disambiguate classes with ambiguous names (such as Timer)

Multi-OS Installation & Guide

JavaWIDE has undergone rapid development since its inception in November 2007. Now that JavaWIDE has a relatively stable base, it needs installation support. JavaWIDE uses a variety of technologies including:

Apache web server
MySQL
PHP
Java
Javascript
Bash scripts
MediaWiki

All of these technologies support cross-platform use on both the server and the client. The easy part is that there is no client installation needed (in 99% of the cases since JRE 1.5+ is already installed). The hard part is that the server software must be supported on all common operating systems (Mac OS X, Windows XP/Vista/7.0, Linux varieties). There are many parts of JavaWIDE that are hard coded to the way it is installed on its current machine. This project would involve:

Parameterizing JavaWIDE to account for different ways it could be installed (retooling hard coded parts)
Writing scripts to evaluate what is already installed on a host system
Writing scripts to install the technologies JavaWIDE needs that are not currently installed
Testing install on multiple operating systems

This project will include heavy use of virtual machine emulation such as Virtual Box. In order to demonstrate the install routines work, a test suite of virtual machines will be created. The install must work correctly on all virtual machines in the test suite.

Security & Performance of JavaWIDE

The JavaWIDE server is made to run on inexpensive hardware. As a proof of concept, it has been successfully installed on a 10 year old laptop (see [sloth.javawide.org]). While this certainly demonstrates it does not need expensive hardware, it does not tell exactly how many users a modern JavaWIDE installation could support. In addition, just because the server has been up for more than 4 months does not mean it is secure. This project involves installing a clone of the current JavaWIDE site and using it to do performance and security testing. The goals are to determine:

What is typical usage of JavaWIDE (gained from collecting statistics from actual JavaWIDE server)
What is the expected peak load for a given number of users?
What is the average load for a given number of users?
How many users can be reasonably supported at the peak?
What happens during peak load?
Where are the bottlenecks (network, memory, cpu, etc.)?
Where is JavaWIDE insecure, and how do you fix it?

Currently Assigned to Tin Lam