Ruby Bounties - rdp/ruby_bounties GitHub Wiki

Welcome to a list of open source bounties for ruby development!

This is a list of projects that want to get done, but with a cash reward. Place here any projects you wish to put a bounty on or look for one to work on (remember to advertise them as well on mailing lists et al). If there’s one you’re interested in seeing completed that’s already listed that you’d like to help, feel free to list yourself as an additional contributor with an amount (like +$amount github_user_name).

If you want to work on one of these then please file an issue for it first, to start a discussion and collaborate with others if any exist, before starting work on it to check if the money’s still there.

Note that users can also submit these ideas as Google Summer of Code projects, if they wish—the ideas are open (though I suppose the code to complete them could be placed under copyright if desired by the paying party).

Please add new projects to the top.

Currently 1.9 has a fast byte-code interpreter. This project would convert 1.9 KRI bytecode into machine code, using llvm et al. Should be pretty feature complete.

$350 rdp

Currently MRI’s GC stops the interpreter dead in its tracks. There is probably a way to run the sweep phase in parallel with the rest of the interpreter. Implement it, get it accepted into core, or at least make a reasonable attempt. Or you could implement the boehm gc with some difficulty—not actually sure if boehm would be faster than a home-brew attempt or not.

Sell off criteria: should show faster ruby benchmark times if run on a dual-core machine, implement the above, submit patch to core.

Boehm might work.

Amount:
$350 rdp threaded
$450 rdp boehm

Currently the 1.9 branch uses a slightly more “RAM friendly” heap block sizes of 2K. This project would backport that to the 1.8.x branch with binary search is_pointer_to_heap, and submit a patch to core.
Difficulty: medium
Amount:
$75 rdp

Currently you can look at the bytecode for ruby methods, but not translate it back to Ruby code that generated (or that is equivalent to it).
Amount: $100 rdp

some work has been started

see this ticket

amount: $35 rdp

It appears that the ruby core’s rdocs work great with the rdoc from 2004, but not with the latest rdoc, bundled with trunk. Update all the various classes’ rdocs so that all their rdoc’s appear when run with the latest rdoc. “ref:”http://www.ruby-forum.com/topic/196970#new

Bounty: $100 rdp

GC: test if this patch makes the tests in ruby benchmark suite faster or slower.

$25 rdp

truly fix ascii slowdown in doze

$100 rdp

make it run with jruby (if it can run wsgi why not jruby?)
$75 rdp

make passenger work with rubinius

$50 rdp

http://blog.pluron.com/2009/05/ruby-19-performance.html

$100 rdp

create an extension for the redcar editor that allows for step through ruby debugging (with local variables, stacktrace for current thread).

$125 rdp

Ten bucks for any kick-ass templates for WebMe.
See WebMe’s Bounties Page for more information.

$10

There is a very early project at http://github.com/wmeissner/jruby-cext to produce a C extension API for JRuby. Although JRuby has access to Java libraries and supports FFI, at times you simply just need a nice C API to hook into. This project needs help from C hackers interested in getting the “safe” parts of the Ruby C API functioning on JRuby. The JRuby core team will provide support and guidance.

This is now a RSoC project by Tim Felgentreff.

$50 headius
$25 rdp

see here

$45 rdp

A ruby “pre processor” which looks for unreachable statements, et al

$100 rdp

A ruby equivalent to “pyrex”.
Fully featured, of course :)

$100 rdp

Provide ability to have code like

def go a
 if a == 300
   return
 else
    go a + 1
 end
end
go 1

insta (static) convert it into duby/mirah (for def go(a: int)) or straight java— mirah might be a convenient intermediate step)

Hint: use ruby2c, which does some analysis? or perhaps use the unit tests to determine typing information.

$200 rdp

better yet: at runtime notice hot spots, auto-convert them to duby/java and compile them. Or provide for a “hot spot analysis” pass, then convert.

I guess this is just with ints/strings et al (basic shared types)

$300 rdp

Add ability to do

a = 'abc'
a.strip!
b = [1,2,3]
b.map{|d| d * 2}.sort.map!{|b| b*2}
File.read('abc').lines.each{|l| p l}

and it works (ruby-ish arrays, strings, blocks, regexes, File I/O).

$500 rdp

package “ripper” into a gem (currently it’s 1.9 only)

$50 rdp

Implement a POSIX compatible gem that allows for the standard threading API’s to be used multi process.
ex something like:

require 'multi_process_override_normal_threading' # you can assume this will be called 'early' in the program, before any threads or mutexes or condition variables are created.

It should have working mutexes and condition variables, and sharable (cross process) native, hard coded length arrays, like arrays of integers, strings, floats.
ex something like:

a = SharedArray.new(:int, 5000) # after this point, any process will 'share' that array
a[33] = 55555

You don’t have to allow for arrays of strings, but some way to transfer marshallled data using native memory, like perhaps:

a = SharedString.new(10000) # size 10000
a.set(Marshal.dump [1,2,3])

Suggestion: package the apache APR which does things like this (or boost, I suppose). Also don’t have to worry about windows here (windows can just use normal threads). ffi might work there as an easier wrapper.

$200 rdp

Your quest: something that will “port” ruby C extensions into ffi.
ex: given win32console, it can grab it, re-write it to be ffi inliner
compatible, and compile it. Oh boy!

Your quest: port win32console to jruby (et al) by making it ffi compatible.

$175 rdp

Your goal: be able to do the following:

class A
 def move(from_x, to_y)
 end
end
A.new.move(3,4)
A.new.move_from_x(3).to_y(4)

and possibly other incantations, like

class A
 def move_from_x_to_y(x, y)
 end
end
A.new.move_from(3).to(4)
A.new.move_from_x(3).to_y(4)

$100 rdp

Suggestions for this change have floated around on the core list. This is a request for a patch to MRI trunk that enables DIR as a precompiler directive (like FILE is now). (those should have underscores around them).

$50 rdp

A high quality replacement for irb so that you can step through multi line code blocks and not have it hurt you.
So basically the same thing as currently, except that the up arrow reveals multi line code blocks, then allows you to edit one if you so desire (multi line).

$100 rdp

Apparently this project is close: http://github.com/cldwalker/ripl
There is also pry and chitin which are related.

requirement: be as fast as eventmachine. That means that you’ll probably need to do the socket opening and closing in C. Only need TCP sockets. Should be 1.9 compatible with rb_thread_blocking_region.

$100 rdp

Some super speed-up-ifier of rails is requested.

Idea: using rails 3, create a way for you to convert the whole app to duby. It might only have to run a subset of rails (i.e. you might have to re-write rails, so probably wouldn’t want to write more than the absolute necessaries). Regardless of how it is eventually implemented, It should provide a way for running rails production at lightning speeds. It needn’t necessarily satisfy active_supports “teardown, build up” stuff. It should support active_record and normal views and controllers, et al.

A few tips: possibly convert all symbols to strings, then you can use java strings for everything. Possibly have a “build, examine” phase, where you use ruby to build the app and generate all methods, then inspect them and convert them all to duby. Static analysis like diamondback ruby might help.

Being able to run unit tests against the static stuff would also be necessary.

$750 rdp

libevent has its own (super fast) HTTP system. This is for a Rack interface into that, whatever that might mean. Extra credit if it can do both normal threaded ruby for output, as well as fibered stuff.

$150 rdp

In a bit of Python envy, Python puts each file as a separate namespace, so that it doesn’t by default add any classes to the global namespace, they’re instead associated with a filename, really. Implement something like that for ruby (active_support, for example, is a loader like this).

use(:IO) # makes available IO as  ::IO
use_singleton(:IO, :select) # select now calls into this.
import('lib/some_class', :SomeClass)
import('lib/some_class') # brings in all classes newly defined in that file.

Something similar to that.

$150 rdp

A gem to allow a web based user to upload files to the hosting server such that they may be accessed by users in a designated IP address range. This will allow users to bypass attachment restrictions on inbound emails.

- the page should allow the user to specify a list of files if need be. - The user should be able to specify multiple files from the same source directory simultaneously (from within the browse dialogue). - the user should be able to change the upload order such that high priority files are uploaded first. - Each uploaded file should be stored in a directory on the server which has a name that is derived from it’s MD5 hash. This will prevent good uploads getting clobbered and stop failed uploads from attempting a retry because of no-clobber. - The user should have the option to throttle the uploads. - email the intended recipient of the uploaded file(s) with download URL and an optional UTF8 message. Multiple email addresses per file should be permitted. - if multiple files are being uploaded, the user should be able to specify different recipients for each file. Recipient email addresses should auto populate down the remainder of the list. - a different download link is provided to the up-loader, but the link is only usable from the IP address that uploaded the file - automatic retry of uploads

And has administrative options including:

- global throttling (with schedule) - only accepting target email addresses from specified email domains. - captcha check. - automatically removes files after a specified period of no access. - retain files for longer if they have never been accessed. - remind intended recipients periodically if the file has not been accessed at least once.

Price negotiable, intended for GPL release.

See here (my posts) for the description.
I would implement it like an interceptor of queries, using some queueing system (either thread or fibered).

$150 rdp

Create some way to have a git-ified wiki that can be forked, etc. Integration with github “somehow” might be nice.

$100 rdp

Rails and ActiveRecord are known to be pretty costly. Optimize them to the hilt.

(money based on improvement and effort it required, but will be negotiable.)

currently with rails on windows, mingw 1.9, even with the faster_require gem rails is slow to load. Fix.

$100 rdp

Currently AutoHotKey is stuck with their own rather limited scripting language. But they have many useful functions within them, so it would be convenient to have Ruby bindings, like

bind 'Win+Up' do
 send 'Volume_Up' # sends the Volume_Up button
end

$200 rdp

Shooes is kind of buggy…so let’s write something with similar functionality/code layout but that’s more maintainable, like using swing or swt.

$300 rdp

$300 rdp

should allow for installation, registry associations/uninstall et al, but with descriptors in ruby.

$300 rdp

use rawr to bundle up redcar such that people can use it online some how, no install required.

$100 rdp

as described :)

$500 rdp

as described (full…)

$500 rdp

Using enumerate windows, et al, write something that’s as easy to use as watir but just allows for testing on generic windows forms. http://stackoverflow.com/questions/3344352/find-specific-button-with-rubys-win32api/3392363#3392363

ffi ruby VLC bindings, like the python ones (auto-generatable/ed ffi)

Some work has been done: https://github.com/rdp/ruby_bounties/issues/10

$100 rdp

hint: use javaFX and/or jruby. No Silverlight :)

$300 rdp

$300 rdp

Rush looks cool, but I’m looking for something that’s as easy as

>> ls
...
>> ls | grep a
...
>> {for line in `ls | grep a` do puts line} # adds ends for me
...
>> **/*.class{.each{|f| p f}} # => org/abc/def

with working history et al. It’s like erb…

$400 rdp

There is also pry and chitin which are close (the latter esp.).

See http://www.ruby-forum.com/topic/218211

Basically, the goal would be to be able to use ruby (and not .net) to edit the DOM on a web page intuitively.

https://gist.github.com/1590560 is a start to getting it working.

$150 rdp

See https://github.com/redcar/redcar/wiki/WishList new plugins list.

$100 rdp