Grant Proposal: RPerl Test Suite Upgrade & Module::Compile Integration

22 Comments

We have received the following grant application. Please leave feedback in the comments field by March 22nd, 2014.

Project Title

RPerl Test Suite Upgrade & Module::Compile Integration

  • Name:

    Name of proposer.

    William N. Braswell, Jr.

  • Email:

    Where we can contact you!

    undisclosed

  • Amount Requested:

    How much is your project worth?

    $800

Synopsis

A short description.

Whether we want to admit it to ourselves or not, Perl is quite slow at many kinds of tasks, as shown by the popular Alioth Shootout Benchmarks: http://benchmarksgame.alioth.debian.org/u32/performance.php?test=nbody

RPerl is a compiler which converts low-magic Perl 5 source code into the equivalent Inline::C and Inline::CPP code, which is then compiled and can be linked back into high-magic Perl 5 code in place of the original slow pre-compiled pure-Perl. In other words, RPerl can help the low-magic parts of your program run up to 200x faster, WITHOUT breaking backward compatibility with existing high-magic Perl 5 and XS.

The next step of my involvement in RPerl development is to upgrade the RPerl test suite and determine if we should integrate Ingy's Module::Compile code. The RPerl test suite currently supports data type testing, and needs to be upgraded to support compilation of full Perl modules. Ingy's Module::Compile code may prove useful for RPerl, this needs to be investigated further and then implemented if found to be appropriate.

Benefits to the Perl Community

Why should the Perl Community grant this project?

The Perl Community has already put their money where their mouth is to support RPerl:

http://www.kickstarter.com/projects/wbraswell/perl-5-optimizing-compiler-rperl-v10

Not to put too fine a point on it, but the fact is that slowness and high-magic are a significant part of the reason why Perl has been in decline for the past decade:

http://developers.slashdot.org/story/11/10/27/213231/is-perl-better-than-a-randomly-generated-programming-language

https://speakerdeck.com/stevan_little/perl-is-not-dead-it-is-a-dead-end

http://developers.slashdot.org/story/13/01/29/0235220/perls-glory-days-are-behind-it-but-it-isnt-going-anywhere

Only an extremist would argue that significant performance improvements will be anything but a benefit to the Perl Community.

People like Matt Trout and Reini Urban and Daniel Dragan and BrowserUk and Ingy dotNet have been very helpful to me in the design and details of RPerl. Overall, I've had net positive support from the Perl community as a whole.

Under the guidance of TPF and Mark Keating, RPerl has now been successfully accepted into the Google Summer of Code 2014:

http://wiki.enlightenedperl.org/gsoc2014/ideas

Deliverables

Quantifiable results e.g. "Improve X modules in ways Y and Z", "Write 3 articles for X website".

1. One or more new .t test suite files, with appendent .pm and .pl files to be tested

2. Module::Compile integration, or equivalent

Project Details

A more detailed description.

[ RPerl Test Suite ]

The RPerl test suite currently consists of 7 enabled .t test files:

https://github.com/wbraswell/rperl/tree/master/t

Currently, RPerl's most advanced automated test file is built to control our manually-compiled sorting algorithm test application:

https://github.com/wbraswell/rperl/blob/master/t/08_precompiled_sort.t

We need to create one or more additional .t test files to control the soon-to-be-large number of automatically-compiled test applications. I've already started working out the test strategy in some of the files:

https://github.com/wbraswell/rperl/blob/master/bin/development/compiled_test__print_00.pl

https://github.com/wbraswell/rperl/blob/master/bin/development/compiled_test__return_00.pl

https://github.com/wbraswell/rperl/blob/master/lib/RPerl/Test/Print_00.pm

https://github.com/wbraswell/rperl/blob/master/lib/RPerl/Test/Print_00.cpp

https://github.com/wbraswell/rperl/blob/master/lib/RPerl/Test/Return_00.pm

[ Module::Compile ]

The Module::Compile software created by Ingy dotNet may be useful for RPerl's automated compilation process.

http://search.cpan.org/~ingy/Module-Compile-0.23/lib/Module/Compile.pod

Currently I plan to move much of the functionality from the bin/rperl front-end to the Compiler.pm module:

https://github.com/wbraswell/rperl/blob/master/bin/rperl

https://github.com/wbraswell/rperl/blob/master/lib/RPerl/Compiler.pm

As part of this move, I should be able to determine if RPerl will benefit from Module::Compile. At that time I will either integrate Module::Compile into the RPerl compilation process, or I will choose some alternative method of achieving roughly equivalent functionality.

Inch-stones

If your grant is going to take longer than a week it's useful to break down your project into small chunks. This helps everybody track of progress, and lets you see if your project schedule is practical!

Try and think in "inch-stones" rather than "mile-stones". Breaking down your grant into many small goals makes it harder to overlook difficulties, and easier to see progress as you complete your grant.

[ RPerl Test Suite ]

https://trello.com/c/9qLlKsAJ/24-test-suite-v1-0

09_compile_print.t 10_compile_math.t 11_compile_conditionals.t 12_compile_loops.t 13_compile_sort.t TAP::Harness

[ Module::Compile ]

https://trello.com/c/zMpP3iOl/38-integrate-module-compile

Move Functionality From compiler_test.pl To Compiler.pm Create RPerl::pmc_compile() Determine If Module::Compile Will Work Integrate Module::Compile Into Compiler.pm, Or Equivalent

Project Schedule

How long will the project take? When can you begin work?

I estimate the project will take between 1 to 2 months.

RPerl development is on-going, I am available to start immediately.

Completeness Criteria

Describe how your grant can be evaluated. For instance, code will be merged in Perl tree, or a module will be released to CPAN with the specified features, etc.

Upon completion, RPerl v1.0 will be released on Github (CPAN will come a little later):

https://github.com/wbraswell/rperl

Bio

Who are you? What makes you the best person to work on this project?

I'm the President of Austin.pm:

http://austin.pm/

I'm a repeat Perl entrepreneur:

http://www.linkedin.com/in/williambraswell/

I'm the CEO of Auto-Parallel Technologies, a Perl development startup:

http://www.autoparallel.com (new website coming soon!)

I've got an honors degree in Computer Science & Mathematics from Texas Tech University.

I'm also an avid Boy Scout leader and cane juggler with Circus Texas. (Not related to Perl!)

http://www.circustexas.com

https://www.facebook.com/SeaScoutsBSA

I instigated the creation of the Perl 11 movement, along with my co-conspirators Ingy dot Net and Reini Urban.

http://perl11.org/

22 Comments

I endorse this grant. The Module::Compiler framework looks good to investigate. Inline:CPP is too hairy and fragile.

While I applaud the goals of rperl, I think the benefits described are aspirational and do not relate to the specific deliverables. Some .t files and Module::Compile integration will not change perceptions of Perl 5 or significant improve performance for the vast majority of Perl 5 users.

Given rperl's existing demonstrated ability to raise community funds and the enthusiasm of its participants, I suspect that the deliverables will happen whether or not the grant is awarded and thus I don't think it's the best use of TPF's scarce resources.

tl;dr - I believe that this grant should be postponed, given the current state of RPerl. No releases have been cut, and the code in the repository does not compile. Even when the build problems are fixed, it does not pass its own tests. Finally the promised RPerl code examples do not exist yet, so it's not possible to form a judgement of how much of speedup RPerl will give, versus how restrictive a language dialect it will be.


The RPerl project promises a lot, but lacks detail on how, meaning that it's really hard to make a judgement on whether it can deliver. The grant states that it's for "the next step of my involvement in RPerl development", which means that it should be assessed as part of a larger roadmap. However, there is no roadmap published anywhere - not in the github repository, not as part of the Kickstarter, and not in the Trello page referenced. So the proposal is not doing itself any favours by making it so hard to get the big picture.


Failing any official roadmap, I'm forced to make the following assessment how what the project is likely to deliver:

From the README

The input to the RPerl compiler is low-magic Perl 5 source code.


"low magic" is defined on http://rperl.org/the_low_magic_perl_commandments.html

Specifically, RPerl "Shall not"

21. Use Typeglobs, Code References, Weak References, Or Magic Lvalues (Builtins, Non-Variables, Non-Slices, etc)

33. Use Undefined Values (“$var = undef;”, etc) Or Definedness Test On Non-Builtins (“defined($var);”, etc)

45. Use Regular Expressions, Smart Match, q Quoting Mechanisms, Unicode/UTF-8, Or String Interpolation

49. Use Special Code Blocks (Closures, Anonymous, BEGIN, UNITCHECK, CHECK, INIT, END, etc)

51. Use Late Binding (Autoload, Run-Time Dispatch, etc) Or Lazy Evaluation (“eval”, Promises, Run-Time Compile, etc)


This defines a subset of the language that removes most of the features that make Perl useful in the first place. It's effectively turning a dynamic language back into a static language. This makes it really hard to ascertain what it will be like to actually write programs in, so to get a feel for whether the project (as a whole) is going in the right direction, it's essential to have examples of real programs in RPerl to get a feel for whether it's actually a viable approach. For this, the Alioth benchmarks which were promised by the Kickstarter for 1st February would have been perfect. But they aren't published, nor is any news on progress. How close are these to being ready?


I believe that the plan is to add back features of Perl 5, but all the evidence from analogous projects is that this will loose speed. Specifically, Flavio Glock told me that Perlito had initially been faster on loops than Perl 5. However at that time it had no support for last and next. Once he added that in, Perlito became slower than Perl 5.

The author of JRuby says much the same about premature benchmarking:

You can substitute your favorite framework or library, if you like...the bottom line is that an awesome Ruby implementation that doesn't run any Ruby applications is basically useless. Beware of crowing about your victory over Ruby performance before you can run code people actually care about.
http://blog.headius.com/2012/10/so-you-want-to-optimize-ruby.html

There is no free lunch to be had - more dynamism will take more CPU. Suggesting otherwise flies in the face of the experience of others who have re-implemented languages. It will be possible to choose a different trade-off between flexibility vs speed than Perl 5 makes, but it's not going to be possible to have all of Perl 5 and be substantially faster than it.

Hence why it's important to have a feel for what the subset language feels like right now, and what the near-term roadmap is, because it's wishful thinking to assume that it's going to be possible to do everything, and plan as if it will be.

The grant proposal states

I estimate the project will take between 1 to 2 months. RPerl development is on-going, I am available to start immediately.

At the time of writing there have been 5 commits in the past month:

https://github.com/wbraswell/rperl/pulse/monthly

and the "Alioth Shootout Performance Benchmark" goal from the Kickstarter, estimated to take 8 weeks, is now in its 14th week.

This gives me no confidence that the project estimates are reliable.


The RPerl code itself is not on CPAN. (Kickstarter timeline estimated that this would have happened by 1st January 2014)

The code is on github, at https://github.com/wbraswell/rperl/

The code, as-is, doesn't even build. That's not good.

The only way I can find to get it to build is to delete the bundled Inline (ie lib/Inline.pm and lib/Inline/C.pm, leaving lib/Inline/Files.pm)

With it built, it fails tests. I get the same results on OS X and Ubuntu. When I attempt to run the tests again, the build fails, because something has deleted the file lib/rperltypes_mode.h.swap which ExtUtils::MakeMaker has made a dependency on. That file shouldn't even be checked into the repository!

For a grant proposal specifically about tests, the existing tests should pass. Otherwise what confidence do I, the grant committee, or anyone else, have that RPerl is a project that is competent to create useful tests, and use them to avoid regressions?


The failing build and failing tests gives me no confidence in the quality of the code. I think that assessing the proposal should be postponed until such a time as the build and tests work, and sufficient of the Alioth benchmarks exist in RPerl. Right now the code is in no fit state to be evaluated, and it would be insane to approve a grant for such code prior to this being rectified.

There was a Kickstarter for RPerl:

https://www.kickstarter.com/projects/wbraswell/perl-5-optimizing-compiler-rperl-v10/

It successfully raised about $1,000. It has a number of deliverables outstanding and not yet delivered. I feel uneasy at the prospect of backing something that has already received funding but not delivered. Hopefully the Kickstarter deliverables will be delivered soon, and then this could be resubmitted on firmer footing.

I can only echo Nicholas' sentiment. I'm not convinced this is useful, if I want "low magic" for performance reasons C offers me a deal I have more faith in. On top of that, this project hasn't shown to deliver. I have a bad feeling about this project.

Reini, thank you for your well-informed vote of confidence!

Mr. Golden's sentiments are directly contradicted by past TPF grant chairman Dan Wright's comments:

"You should consider submitting a grant request to The Perl Foundation, either under the Perl 5 core grants or the traditional grant program. TPF is always looking for good grant proposals, and if people donate through TPF, it's tax-deductible."


Dan Wright Discussion Thread

I will do my best to reply to each point Mr. Clark has raised.


"tl; dr"


Why is it okay to not read my proposal, but still give a (relatively) scathing review? This seems totally illogical and unacceptable. Furthermore, Mr. Clark's rebuttal is nearly as long as my proposal, which seems to further invalidate the proposal-length-as-prohibitive-factor argument.



"the code in the repository does not compile"


Oh, it definitely compiles, but you're right, we have a serious build issue related to the weird way that Inline, Inline::CPP, and Inline::Filters handle their spaghetti of interdependency checking. I don't fully understand the problem, but I can tell you that bulk88, mst, Reini Urban, Shlomi Fish, and myself are all giving it significant thought. This is in fact the only officially filed bug for RPerl so far:

Github Issue


So far I have had success walking people through the RPerl installation and passing all tests, with a key critical step to overcome this issue being the need to use CPAN to force an install of Inline::Filters, but NOT delete the copy of Filters.pm that ships with RPerl. It is a hack, but until CPAN can be properly updated and Inline::* fixed this is the best we can do.



"there is no roadmap published anywhere"


Well it may not be in the exact format that you like, but we do have a list of all tasks that must be completed for RPerl v1.0 to be released:


Trello Card For RPerl v1.0 Development


I realize this only takes us through RPerl v1.0 and you want more details about future versions of RPerl, all I can say is that we can cross that bridge when we come to it. I've already got a group of several probable next steps in the "To Do" list:

Trello Board For RPerl Development



"This defines a subset of the language that removes most of the features that make Perl useful in the first place. It's effectively turning a dynamic language back into a static language."


Correct. Obviously, in order to gain compile-time optimizations we must utilize compile-time behaviors, which are by definition static rather than dynamic. Initially, RPerl is meant to enable compile-time optimization of static Perl code, and after compilation the optimized static Perl code can be linked back to plain old dynamic Perl code, so you get the best of both worlds and maintain full backward compatibility. This particular point of "you're taking away all the parts of Perl I love!" is hashed and re-hashed ad nauseam by RPerl numerous detractors. The bottom line is this: are you somehow better off WITHOUT the option of optimizing your static Perl code? Why would you NOT want to optimize your static Perl code, especially if it doesn't hurt your dynamic Perl code in any way??? The only answer to these questions is fear, uncertainty and doubt. We all know where FUD leads, and it is not to a place where people can make valid progress without facing undue roadblocks.



"For this, the Alioth benchmarks which were promised by the Kickstarter for 1st February would have been perfect. But they aren't published, nor is any news on progress. How close are these to being ready?"


TPF denied my last grant request. I'm not aware that it was ever even published for comments, certainly not that I was ever informed about. Living off of the $1700 raised on Kickstarter I was able to survive long enough to finish RPerl v1.0 Beta. After the Kickstarter money ran out I was forced to pursue non-RPerl programming work to make ends meet, which has made it prohibitively difficult for me to focus on RPerl as much as is needed for steady progress. Any amount of income from TPF will allow me to focus on RPerl when I otherwise would be unable to do so.


Implementation of the Alioth Shootout Benchmark n-body algorithm as an RPerl application will be relatively straightforward once we have RPerl v1.0 completed. I've faithfully kept my RPerl backers informed about the progress and situation:

RPerl Kickstarter Updates



"It will be possible to choose a different trade-off between flexibility vs speed than Perl 5 makes, but it's not going to be possible to have all of Perl 5 and be substantially faster than it."


Correct. Moving forward with the implementation of RPerl is the only way to flesh out this speed-vs-flexibility issue. We will naturally discover which parts of Perl are too dynamic to achieve any optimization using RPerl, and which parts are good to be compiled.



"For a grant proposal specifically about tests, the existing tests should pass. "


Again, the tests DO pass, if you know what you're doing. Below is a chat log between myself and one of the programmers (A. Canfora) who has been successful in running the RPerl Tests (minus some weird compiler big-integer issues):



Building and testing Inline-Filters-0.12
cp Filters.pod blib/lib/Inline/Filters.pod
cp Filters.pm blib/lib/Inline/Filters.pm
Manifying blib/man3/Inline::Filters.3pm
PERL_DL_NONLAZY=1 /usr/bin/perl "-MExtUtils::Command::MM" "-MTest::Harness" "-e" "undef *Test::Harness::Switches; test_harness(0, 'blib/lib', 'blib/arch')" t/*.t
Can't use string ("-I"/home/acanfora/.cpanm/work/13"...) as an ARRAY ref while "strict refs" in use at /home/acanfora/.cpanm/work/1394216528.16942/Inline-Filters-0.12/blib/lib/Inline/Filters.pm line 103.
BEGIN failed--compilation aborted at t/Preprocess.t line 16.
t/Preprocess.t ......
Dubious, test returned 255 (wstat 65280, 0xff00)
Failed 1/1 subtests

I forced the installation of Inline:Filters anyway and went ahead. Then I got following errors from tests:

t/01_depend.t ............ ok
t/02_inline_c.t .......... ok
t/03_inline_cpp.t ........ ok
t/04_type_scalar.t ....... 8/? not ok 23 - TIV09 integer__stringify(-1_234_567_890_000) throws correct exceptionnot ok 34 - TIV29 integer__typetest1(-1_234_567_890_000) throws correct exceptiont/04_type_scalar.t ....... 103/? not ok 116 - TIV09 integer__stringify(-1_234_567_890_000) throws correct exceptionnot ok 127 - TIV29 integer__typetest1(-1_234_567_890_000) throws correct exceptiont/04_type_scalar.t ....... 193/? not ok 206 - TIV09 integer__stringify(-1_234_567_890_000) throws correct exceptionnot ok 217 - TIV29 integer__typetest1(-1_234_567_890_000) throws correct exceptiont/04_type_scalar.t ....... Dubious, test returned 6 (wstat 1536, 0x600)
Failed 6/273 subtests
t/05_type_array.t ........ ok
t/06_type_hash.t ......... ok
t/07_oo_inherit.t ........ skipped: [[[ OBJECT-ORIENTED TESTS DISABLED UNTIL C++ -> PERL NAMESPACE ISSUES ARE FIXED IN INLINE::CPP ]]]
t/08_precompiled_sort.t .. ok



"Right now the code is in no fit state to be evaluated, and it would be insane to approve a grant for such code prior to this being rectified."


I just showed you now to evaluate the code. If you're unable to get it to compile on your own machine, I'm happy to help. If you refuse my assistance, and are unable to get the tests to compile by yourself, then the problem is not with RPerl. What is "insane" is pre-judging such a potentially important project as RPerl without even getting it to run for yourself first.


Mr. Signes,

The outstanding deliverables are RPerl v1.0 and the Alioth n-body algorithm. As stated in my reply to Mr. Clark above, I got as far as I could on the $1700 from Kickstarter, which resulted in the release of RPerl v1.0 Beta.

How, exactly, does it make sense to deny funding to a project that you want to see produce more code? You say you want to see deliverables, but you don't want to see any funding provided to help achieve this goal?

Mr. Timmermans,

RPerl v1.0 Beta has been released, it is a significant step forward in the development of a low-magic Perl compiler, this directly contradicts your claim that RPerl "hasn't shown to deliver".

If you want to write C or XS code, that's fine, good for you. RPerl itself outputs C and XS code, which is specially designed to be linked back into high-magic Perl code. You're simply not going to achieve this in any straightforward or user-friendly way using manual C or XS coding techniques. Show me 1,000 lines of manual C & XS and I'll show you 1 line of RPerl which can be automatically compiled.

What I said was that if the Kickstarter goals were still not delivered, we should wait for them. That's based on the notion that they were still underway, since I didn't see any evidence that they weren't. The undelivered Kickstarter goals are not listed as deliverables on this grant, so it's not the case that we get *those* deliverables by funding *this* grant. The relationship between the two is unclear.

Mr. Signes,

You are correct, the relationship is unclear, thank you for pointing that out.

As with many software development projects, RPerl has encountered unforeseen complexities along the way. The deliverables on this grant proposal are additional RPerl components not conceived of during the time when the Kickstarter project was announced.

Specifically, the grant deliverables are important supporting components which will significantly aid in the progress toward a functional and polished RPerl v1.0 release. Thus, the grant deliverables can bee seen as separate from the Kickstarter goals, yet related to the Kickstarter goals, which is no surprise since it is all related to RPerl one way or another.

I humbly continue to assert the appropriate and positive nature of this RPerl grant proposal, and I hope TPF grant committee will see fit to award the grant for the good of the future of the Perl community.

Perling,

~ Will

I worked with Will to get RPerl running on Win32 so I could evaluate it myself, on what it *currently* does. But his use of many C++11 features, and deep dependence on the latest C++11 additions to libstdc, caused all of my compilers (a number of Visual Cs and GCCs, including Cygwin GCC) to fail. The code formatting style of RPerl in some files in its source code is "unique". While I conceptually agree with the high level design theory of RPerl and the principal of allowing static code without manually writing C. I can't make an opinion on something I can't personally run or effectively criticize. Therefore I don't have an opinion on this grant proposal.

Since I have no technical comments on RPerl, some social steps I suggest would make this look like a better project is if it was released on CPAN, and a number of cpantesters.org machines passed, and there were 2-3 regular committers instead of 1 that could take over if someone gets bused.

<sarcasm>If I get RPerl to compile on my machine, a make test could just print "Just another Perl hacker, its April 1" and RPerl goes down in the records book as the largest JAPH ever written</sarcasm>

Unfortunately, Mr. Dragan (bulk88) is afflicted with a compiler and OS toolchain that is not C++11 ISO standards compliant.

This is definitely not an error or flaw in RPerl.

RPerl works just fine with an ISO-compliant compiler.

> Unfortunately, Mr. Dragan (bulk88) is afflicted with a compiler and OS toolchain that is not C++11 ISO standards compliant.

> This is definitely not an error or flaw in RPerl.

Compilers are only beginning to implement C++11; and I say that as someone who was writing C++11 before it officially came out (May 2010). GCC 4.8 (the latest released version) is the first in years that I haven't accidentally crashed (yet) while using various new features. This is similar to the process C++ went through when C++98 came out AFAIK. Expecting useful implementations of it to be widespread is silly.

> RPerl works just fine with an ISO-compliant compiler.

His environments come with a ISO-compliant enough compilers, just not ISO C++11 ;-)

"Mr. Golden's sentiments are directly contradicted by past TPF grant chairman Dan Wright's comments:"

First, I am not the TPF grants chairman.

Second, I do not agree that Mr. Golden's statement is in contradiction with mine.

Using TPF over a kickstarter-style funding mechanism has three advantages: First, donors can take advantage of tax-deductibility of their contributions. Second, the community as a whole can weigh in on where to put their valuable resources. Third, TPF serves as an oversight organization to verify objectives are met before payment is received.

Therefore, I encouraged Mr. Braswell to take advantage of the existing mechanisms for funding rather than solicit individual donations. He did not heed my advice.

Since the project has already received funding elsewhere, and the opinion of the community appears to be that he has not met the objectives for that funding, I agree with RJBS and Mr. Golden. It would be folly to throw good money after bad. We should wait until all of the kickstarter objectives are accomplished before contemplation further funding.

Mr. Timmermans,

RPerl works fine on my free & open source operating system (Ubuntu) with the pre-installed free & open source compiler (GCC).

Mr. Dragan is experiencing compiler issues because he is choosing to use either outdated and/or proprietary compiler software.

I maintain that this is not in any way a flaw in RPerl. If anything, it simply means that Mr. Dragan needs to upgrade his software.

Thanks,

~ Will

Mr. Wright,

I thought you were the past TPF grants chairman, if I was mistaken then I sincerely apologize.

It is false to say that I did not heed your advice, on Nov 27th I submitted a grant proposal to both yourself and the TPF grants committee. I never heard back from anyone, and assumed I was being snubbed or somehow disrespectfully dismissed. Again, if I was mistaken, my apologies.

If you think that spending money on RPerl is tantamount to "throwing good money after bad" then I respectfully submit that attitude will only serve to hinder progress rather than promote progress.

Also, the rules at the top of this page clearly state "Please leave feedback in the comments field by March 22nd, 2014" - yet here I am several days later still defending RPerl against attacks from people who could not see fit to follow the most basic rules.

Tsk, tsk, TPF. Let's try to follow our own rules, shall we?

Perling,

~ Will the Chill

Mr. Braswell,

Your statements are blatantly false.

On November 27th you and I did have a private conversation via Facebook. At that time I did make it clear to you that I was the Treasurer for TPF and NOT the Grants Chairman. I informed you who the Grants Chairman was and suggested you contacted him.

I also gave you the URLs to the pages on the TPF web site that described the various grants and suggested you look them over.

You informed me that you did not feel qualified to apply for a Perl 5 Core grant because you had never contributed code to the Perl 5 Core. And, you informed me that you did not want to apply for a traditional grant because you had an immediate need for money and did not want to wait for the next round of grant applications.

At no point did you ever submit anything resembling a grant application to me. And, if you had, I would have (again) referred you to the Grants Chairman.

You are correct that it is now past March 22nd. But since you have seen fit to drag my name into this, I felt it was necessary to set the record straight. My original suggestion that you apply for a grant was in no way an endorsement for your grant application. It was an endorsement for the grants program.

Mr. Wright,

Again I apologize for confusing your office, obviously I was mistaken in thinking you were the Grants Chairman when you were in fact the Treasurer. My bad!

I'm surprised that you never received my grant application, I sent it on November 27th as stated, I'll paste the e-mail headers and part of the body below as proof.

Thanks,

~ Will


MIME-Version: 1.0
Date: Wed, 27 Nov 2013 18:59:12 -0600
To: tpf-proposals@ *EDITED*
Cc: "Daniel Wright" dan@ * EDITED *
Subject: Perl 5 Optimizing Compiler, RPerl Grant Request
From: "Will Braswell" wbraswell@ *EDITED*
In-Reply-To: [email protected]m
References: [email protected] [email protected]m [email protected] [email protected]m [email protected] [email protected]m
X-hush-end-of-body-position: 229
Content-Type: multipart/alternative

=head1 Project Title
RPerl

=item Name:
Name of proposer.
Will Braswell

=item Email:
Where we can contact you!
wbraswell@ *EDITED*

=item Amount Requested:
How much is your project worth?
$3,000 (or whatever is the maximum amount allowable)

=back
=head2 Synopsis
A short description.
Whether we want to admit it to ourselves or not, Perl is quite slow at
many kinds of tasks, as shown by the popular Alioth Shootout
Benchmarks:http://benchmarksgame.alioth.debian.org/u32/performance.php?test=nbody
RPerl is a compiler which converts low-magic Perl 5 source code into
the equivalent Inline::C and Inline::CPP code, which is then compiled
and can be linked back into high-magic Perl 5 code in place of the
original slow pre-compiled pure-Perl. In other words, RPerl can help
the low-magic parts of your program run up to 200x faster, WITHOUT
breaking backward compatibility with existing high-magic Perl 5 and
XS.
...
[[[ THE FULL GRANT APPLICATION GOES ON FROM HERE ]]]

Leave a comment

About TPF

The Perl Foundation - supporting the Perl community since 2000. Find out more at www.perlfoundation.org.

Recent Comments

  • Makoto Nozaki: Will, As you may know, the Grants Committee was unable read more
  • Makoto Nozaki: Will, Grants Committee representative will get in touch with you read more
  • William N. Braswell, Jr.: Mr. Wright, Again I apologize for confusing your office, obviously read more
  • Dan Wright: Mr. Braswell, Your statements are blatantly false. On November 27th read more
  • William N. Braswell, Jr.: Mr. Wright, I thought you were the past TPF grants read more
  • William N. Braswell, Jr.: Mr. Timmermans, RPerl works fine on my free & open read more
  • Dan Wright: "Mr. Golden's sentiments are directly contradicted by past TPF grant read more
  • Leon Timmermans: > Unfortunately, Mr. Dragan (bulk88) is afflicted with a compiler read more
  • William N. Braswell, Jr.: Unfortunately, Mr. Dragan (bulk88) is afflicted with a compiler and read more
  • bulk88: I worked with Will to get RPerl running on Win32 read more

About this Entry

This page contains a single entry by Makoto Nozaki published on March 15, 2014 9:00 AM.

Grant Proposal: JERL (Alien::Jerl) Perl5 running in the JVM was the previous entry in this blog.

Grant Proposal: Perl::Lint - Yet Another Static Analyzer for Perl5 is the next entry in this blog.

Find recent content on the main index or look in the archives to find all content.

OpenID accepted here Learn more about OpenID
Powered by Movable Type 4.38