- THIS IS A TEAM SPORT
- DOCUMENTATION AND EXAMPLE NEEDS
- APPLICATION AREAS
- ELEPHANT IN THE ROOM - PERFORMANCE
- Some OPEN QUESTIONS
See https://github.com/oodler577/p5-Sub-Genius/milestone/1 for a specific list of documentation and example needs if you wish to contribute immediately (and we hope you do). Please visit CONTRIBUTING if
All may contribute to this effort. I will help save
perl, even if this approach is deemed sub-optimal (hmm, might be a good name for a new model :-)). In any case, the most important step towards making
perl perceived as being more relevant is to see how creative we can be with it as it stands now. And the more hands on deck, the better.
FLAT was created in 2006 as a homework assignment. It wasn't until recently that any practical use for it emerged. Why? People started asking hard questions about the nature of Perl (the language) and perl (the runtime).
Sub::Genius came about by the following line of questioning:
1. can we make perl truly
[qw/threaded asynchronouse parallel ... etc/]?
A: No, nope, nada, nein! x
... years of repeated questions, drama, and soul searching
2. (recently) if perl can't be made threaded, what can be done to make it easier to expose concurrent semantics to perl programs? What does embracing the indisputible serial nature of
perl give us?
A: It let us look away from
perl and more to
Perl; the idea of planning the executions in a sequentially consistent way emerged. And this is how we are here now.
Eventually, we realized that Parallel Regular Expressions (also, directly convertible to PetriNets) could provide some step towards improved, albeit low level semantics.
Sub::Genius is not the only approach, but hopefull it'll get the cognative cogs turning.
Sub::Genius is not itself to be ambitious. It is meant to present a light Perl interface that allows for parallel thinking for the sequential execution environment that
perl presents. There is little interest in expanding the expressiveness of parallel semantics that it presents. E.g., there are no plans (nor the need) to look beyond the power of reasoning affored by the application Regular Languages.
The following areas are the main targets for future development.
This is the current focus area. Exploring application areas and open questions will naturally genertate code examples and documentation artifacts.
See https://github.com/oodler577/p5-Sub-Genius/milestone/1 for a specific list of documentation and example needs.
This certainly includes using Sub::Genius for cool things, but this focus is meant to make this model facilitate a new wave in creative uses and approaches for Perl programs.
There is one major issue that needs to be addressed for this approach to be fully accepted is that the algorithm used to convert the *parallel* regular expression into a DFA suitable for generating valid sequential strings (e.g., sequentially consistent execution plans) is not efficient. It's from 2006 and was done for correctness rather than for performance.
Since then, a number of researchers have published more efficient algorithms for directly converting PREs (REs with the shuffle operator) into DFAs. It is not even necessary for the DFA to be minimal as the documentation in FLAT implies.
This work belongs to FLAT, so the author(s) of that old module will be involved in such improvements. If not, then the module can be replaced entirely, since the only thing needed from it (really) is the ability to parse a PRE, then from the abstract syntax tree (AST) of the PRE, execute the algorithm that most efficiently produces a DFA. The DFA is simply a graph structure, so with that almost any approach to creating an iterator that enumerates paths between the initial state and an acceptance state would suffice.
Is there a better way to express a current plan for
perlprograms in a more perlish or more natural way? Can a
planbe generated at run time, rather than being done so up front?
Creating examples and documentation applying Sub::Genius to implement different memory models, which is now a little more easily possible. (e.g., SMP, futures, etc).
How can Perl libraries (modules) be composed to provide even more unobtrusive access to these memory models and concurrent programming paradigms?
How can the uniprocess
perlruntime be used even more effectively and creatively? E.g., subroutines can be given persistent state that remains between calls using the
statevariable. This presents a programming model that naturally admits the use of co-routines.
What does it look like when one introduces actual
forking to a program that is expressed in using Sub::Genius facilities?
Are there fundamental capabilities the
perlruntime can provide to make the model presented by Sub::Genius? For example, TEODESIAN @cpan has suggested a very interesting idea that
perlshould support a finite automata engine, which would serve exactly the purpose FLAT provides for Sub::Genius.
What other questions are there?