Thank you for your interest in Bean Sheet -- an interpretive Java spreadsheet utilizing Java spec syntax. At its core is Bean Shell, an open source Java interpreter. Because Bean Shell has full access to the Java Virtual Machine, the potential of marrying a Java interpreter with the concepts of a spreadsheet application is beyond and different from traditional spreadsheet software. Each Bean Sheet document can be a powerful application in its own right.
Please refer to the main SourceForge.net Bean Sheet site for downloads, documentation and more. Javadoc API documentation for the latest release can be found here. Don't forget to join the users' mailing list. I'd love to hear from you!
Currently, Bean Sheet comes packaged in the following options:
This package is the simplest to install. You will simply need to download the self-executing JAR file and... well, execute it. The Bean Shell library included in this package contains all Bean Shell commands.
Download file bsheet-<version>.zip.
Unzip it in the desired installation directory.
Run bsheet_bundle.jar by double clicking it (only on Windows and Mac OS X) or by invoking the following command:
java -jar bsheet_bundle.jar
You will need a working copy of Ant. You will also need to install a Bean Shell library JAR in <Bean Sheet home>/code/lib directory. Extract the contents of bsheet_src.zip into <Bean Sheet home>/code. The following Ant targets are of interest:
Executing “jar” and “bundle” targets (ant jar bundle) will result in bsheet_bundle.jar being generated. Bean Sheet can now be executed without any extension modules.
There are a number of modules that come with Bean Sheet as part of the bsheet download. Those modules, while not technically required for the application to run, are considered an integral part of it, as an end user package. The following modules will need to be downloaded and built: mod_commands, mod_help, mod_print, mod_toolbar. With the exception of mod_commands, each module will need to be compiled and configured. Extract commands.zip into <Bean Sheet home>/module directory. You've now set up mod_commands – it is the only module that does not require compilation. Now we'll move on to the other modules. It is recommended, for simplicity and ease of use, to first download and extract a pre-compiled Bean Sheet distribution in order to make sure some of the files that do not come with module source code are in place.
Each of the mod_help, mod_print, and mod_toolbar source zip files will need to be extracted into the separate module directories under <Bean Sheet home>/module/help, <Bean Sheet home>/module/print, <Bean Sheet home>/module/toolbar. Extract each module's source zip file into a corresponding module directory. Help module requires an external library jar (helpgui-1.1.jar, HelpGUI official site), which can also be obtained from a binary bsheet distribution. In each one, execute ant release command. You will also need to have a configuration properties file for each of these modules (help.properties, print.properties, toolbar.properties) placed in <Bean Sheet>/home/module directory. It is easiest to obtain these properties files from a pre-compiled distribution of bsheet package. Your final contents of <Bean Sheet home>/module should contain at least the following:
You should now be able to run Bean Sheet with each of the included modules.
With the help of Screencast-O-Matic, we're happy to offer a demo screen capture video. You will need Java 1.5 or later to play it.
Right-click on the screen shots and save to download the documents.
The first thing most of you will say is probably, "What the
heck is functional programming?" Until very recently, that
would have been my reaction as well. As luck would have it
though, I came across something that made me understand what it is
exactly that I like about spreadsheets in general. Consider for
a moment how we work with typical spreadsheets: we fill some cells
with data, and some with formulas or functions. Those formulas
and functions usually refer to other cells, which may contain data or
functions themselves. We never have to think about dependencies
or the order in which cells are evaluated. This in itself is a
simple form of functional programming. The idea is that the
user of a functional programming environment concentrates on the task
at hand from a more mathematical point of view, defining functions
and data inter-relationships rather than writing instructions for
specific variable manipulation to be executed in some specific
order. There are several functional programming languages and a
devoted to them.
As you can see, a generic spreadsheet application has some elements of a functional programming environment built into it and it is for that reason a lot of people find them to be excellent modeling tools and fairly easy to "program" in. Bean Sheet, being a spreadsheet and a Java scripting environment presents its user with the potential to make the best of both paradigms. For example, consider Bean Sheet command
condition. This command takes two parameters: an
cell range (
Point objects) and
an expression that is evaluated for each cell in the cell range.
This command returns a cell range that is a subset of the passed in
cell range, such that the expression given evaluates to
for each cell. The expression can of course do more than simply
return a boolean result. A function defined in this kind of
all-elements-such-that style is a perfect example of functional
programming. But of course Bean Sheet is not a pure functional
programming environment. It does not force its users to
completely shift their thinking into the functional programming frame
of mind. Rather it's a very interesting and powerful, though
admittedly accidental, side-effect of combining OO concepts, an
interpreter, and a spreadsheet. Welcome to functional Java!