Hi Abhishek.
Overall it looks good to me (but I'm not used to laying out GSoC proposals
so it might be good to have additional comments).
I've added a few remarks in the text (see below).
Le dim. 24 mars 2019 à 13:09, Abhishek Dhadwal <dhadwal1...@gmail.com> a écrit :
>
> Dear Sir,
>
> I’ve added skeletal draft of my GSOC proposal (as per the Apache foundation’s
> guidelines) below :
>
> GSOC-19 Application :- RNG-32: Implement More Generators
>
> Background
>
> The Commons RNG is focused on the utilization of Java-only implementations of
> various standard generators, with focus being placed on fast generators with
> strong uniformity and predictability.
You should probably insert the words "random numbers" somewhere.
Perhaps add this link
https://en.wikipedia.org/wiki/Pseudorandom_number_generator
as general information about the topic.
>
> Design / description of work
>
> - Implementation of Linear Congruential Generators
>
> - Implementation of Lagged Fibonacci Generators
>
> - Implementation of PCGs
Perhaps add web links (e.g. to the corresponding Wikipedia pages).
>
> Results for the Apache community
>
> The implementation of PRNGs will allow for the occurrence of speed and
> regularity for sequences of pseudo random numbers, easing the creation of
> applications involving data encryption, games and gambling.
I'd be wary mentioning "data encryption"; it's probably a long way from
the deterministic RNG implementations, that are the scope of this
component, to a reliable cryptographic appplication.
"Simulations" is probably worth mentioning among the potential uses.
You could also mention actual applications that use RNGs (and maybe
issues that they could encounter with using a "bad" generator).
> Deliverables
>
> Java Implementations for the following PRNGs shall be provided:
>
> 1. Linear Congruential Generators : One of the oldest and best known PRNG
> algorithms, LCGs create pseudo random sequences of numbers using
> discontinuous piecewise linear equations.
>
> 2. Lagged Fibonacci Generators : An improvement over Linear Congruential
> Generators , these PRNGs take their inspiration from the Fibonacci series,
> and utilise the following generalised formula :
> Sn = Sn-k * Sn-j (mod m) , where ‘*’ is a binary operation. (NOTE: k and j
> may not be selected randomly)
>
> 3. PCGs : Permuted Congruential Generators are RNGs which are modern, light
> and reliable in nature, and are more efficient than LCGs while utilising a
> power of 2 modulus, leading to unbiased output bits.
Reading one of the above links, I've just found out another generator that
looks quite easy to implement:
https://issues.apache.org/jira/browse/RNG-85
>
> Scheduling
>
> May 27- Beginning of coding and testing for Linear Congruential Generators
>
> June 17 - Testing for LCG commenced along with potential bug fixing
>
> June 24 18:00 UTC - Testing phase 1 - complete. Mentor evaluation of LCGs
> begin / Evaluation 1
>
> June 28 18:00 UTC - Phase 1 Evaluation deadline
>
> June 29 - Beginning of implementation for Lagged Fibonacci Generators
>
> July 15 - Student testing of implemented LFGs begins along with bug fixing
>
> July 22 18:00 UTC - Testing Phase 2 – Complete. Mentor evaluation of LFGs
> begin / Evaluation 2
>
> July 26 18:00 UTC - Phase 2 Evaluation deadline
>
> July 27 -Design and Coding for Java Implementation of PCGs begin
>
> August 12 - Student testing of PCGs begins along with the implementation of
> final fixes to code
>
> August 19 - 26 18:00 UTC - Final phase of Student Testing Complete. Mentor
> evaluation of overall code begins / Final evaluation
>
> August 26 - Sept 2 18:00 UTC - Mentors submit final student evaluations
>
> September 3- Final results of Google Summer of Code 2019 announced
Honestly, I've no idea about whether this schedule is realistic.
I mean: Assuming full-time commitment, it could probably be
finished much faster. ;-)
At this point, it looks to me that the longest part will be getting
acquainted with the framework of "Commons RNG" (and even
this will probably look fairly easy once you get the hang of it).
Then the coding of the algorithm(s) will be pretty straightforward:
It seems (sometimes much) less than 20 lines of code each.
Most time will probably be spent porting from C (with its caveat
of data type adaptation), ensuring full coverage and reproducibility
of the reference implementation's output.
That is to say that we should perhaps add additional task(s)...
An obvious one would be to mention:
- Look for more RNG algorithms, and implement them, if
time permits.
> Other commitments
> None during the period of May 27th-July 27th . College begins from July 27th,
> but shall not affect the deadlines proposed.
>
> Community engagement
> Interacted with Gilles sir in the JIRA forum, along with subscription and
> interaction with members of the developer’s mailing list. Project importing
> and building using Maven also performed.
>
> -- END OF PROPOSAL—
>
> NOTE: I had created a table for the scheduling part, which got removed when I
> copied my draft proposal from the word document to mail, along with various
> cosmetic changes which I had applied to the text.
Depending on what kind of document, you might write it in "Google Docs"
(seems appropriate for GSoC...) and share the link.
> Should I add my previous experience with Java and other qualifications, along
> with sources of information?
Sure.
> What other changes should I make to my current proposal ?
See above.
And perhaps Alex, and others, have something to add too...
> Feedback would be highly appreciated.
>
> PS :- Apologies for not replying earlier, I’ve been under the weather for the
> past few days. I shall undertake the changes you and Alex sir have advised,
> and reply as soon as possible.
Good.
Once you can build the project, you should probably ensure that you
can make pull requests.
Regards,
Gilles
>
> Thanking you,
> Yours Faithfully,
> Abhishek
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscr...@commons.apache.org
For additional commands, e-mail: dev-h...@commons.apache.org
