An experimental new type of GUI Application, inspired by emacs and IBM's Project Development Manager.

In some sense, Featureful does nothing, it is a framework which allows scripted tools to work well together. It annoys me that applications force me to work their way. Even the IDE I use (IntelliJ) has very limited customisation. (No macros, no customisation of the toolbars/docks etc.)

I use it as a TextEditor, a File Manager, a Git frontend, Gradle frontend, a Music player, as well other general-purpose tools, such as search-and-replace recursively within a folder.

None of these features are part of Featureful's core; they are scripted Components.

Components can work together, even though they know nothing about each other. For example, the music player, the file manager and the search tools don't know about each other, but when combined, they are richer than the sum of their parts.

e.g. I can search my music collection for songs containing the word "Summer", and play them. The music player has no "search" feature. The search feature has no "play" feature. The music player doesn't even have a feature to list songs/albums/artists! It doesn't need one, that's handled by the file-manager.

Prerequisites

• A unix-style shell (sh). Windows doesn't have this out-of-the-box, but you could install cygwin, or similar.
• The mimetype command line tool. I'm not sure if macOS has this by default.
• Java runtime. I use OpenJDK, but Oracle's Java should also work.

Status

The experiment is successful. I love it! I've got so many ideas for new ways to use it.

However, the API isn't stable yet.

I still haven't got out of the habit of closing the application before fixing a bug or writing a new feature. Often the bug/new feature can be written while the application is running, from within the application itself.

Build-In Components

Featureful comes with many components read to use out of the box.

They are all scripted, using the Feather scripting language, and you are encouraged to modify them (or replace them) to suit your needs.

Limitations

Feather Scripting Language

The scripting language is still a little buggy, mostly related to generic types. For the most part, it is fine, but be prepared for weird error messages!

There are other nasty gotchas, e.g. it doesn't throw a compiler error in some cases where a method from an interface/abstract class hasn't been implemented. Eek!

The scripting language doesn't support lambdas. Instead, it has a Function type. A Function is a first-class citizen, which can be passed as an argument, or held in a var/val. Functions are slightly more verbose than lambdas. You can curry a Function's argument though, which is a super-power that lambdas lack.
Functions are used extensively.

Featureful's API is still in flux. I'm still making breaking changes to the API. Scripts will break when moving to later versions of Featureful.

Start Up Time

Compiling the scripts at start-up is currently fast because there are so few components. But when more are written, the start-up may become a problem.

So I plan on compiling the scripts into jar files.

We will need separate jar files for System, Personal and Local project.

FYI, At time of writing, there are 20-30 components (depending on whether you include the basic ones). On my middle-of-the-road laptop it takes about 2-3 seconds to compile the scripts. The total start-up time is about 7 seconds.

By way of comparison, Chromium takes about 4 seconds, and IntelliJ about 10. Not very scientific, but it gives are rough idea.