Julia Summer of Code

[Viral Shah]

Folks,

The Moore Foundation is generously funding us to allow for 6-8 Julia Summer of Code projects. Details will be published soon, but if you are interested, please mark your calendars and plan your projects.

-viral

[Stefan Karpinski]

Sorry, this is so late in the game – we were caught off guard by unexpectedly being rejected as a GSoC project after such a successful GSoC summer last year. Compensation is similar to GSoC and the projects should be similar in scope and nature. If you have a project you'd like to propose, write up an description and send it to me or Viral with "JSoC proposal:" in the subject line.

[Simon Danisch]

Are there any details on how this could have happened? Seems pretty odd to me, when looking at what projects have been accepted.

[Miles Lubin]

This is both a proposal and a call for interested undergraduate and graduate students:

Automatic differentiation is a technique for computing exact numerical derivatives of user-provided code, as opposed to using finite difference approximations which introduce approximation errors. These techniques have a number of applications in statistics, machine learning, optimization, and other fields. Julia as a language is particularly suitable for implementing automatic differentiation, and the existing capabilities are already beyond those of Scipy and MATLAB. We propose a project with the following components:

1. Experiment with the new fast tuple and SIMD features of Julia 0.4 to develop a blazing fast stack-allocated implementation of DualNumbers with multiple epsilon components. Integrate with existing packages like Optim, JuMP, NLsolve, etc., and measure the performance gains over existing implementations.

2. Combine this work with the ForwardDiff package, which aims to provide a unified interface to different techniques for forward-mode automatic differentiation, including for higher-order derivatives.

3. Time permitting, take a step towards the reverse mode of automatic differentiation. Possible projects include developing a new implementation of reverse-mode AD based on the expression-graph format used by JuMP or contributing to existing packages such as ReverseDiffSource and ReverseDiffOverload.

There are quite a number of interesting projects in this area (some with avenues for publication), so we can adjust the work according to the student's interests. An ideal student should be interested in experimenting with state-of-the-art techniques to make code fast. No mathematical background beyond calculus is needed. See juliadiff.org for more info.

Co-mentors: Miles Lubin and Theodore Papamarkou

If this sounds cool and interesting to you, do get in touch!

[Viral Shah]

Also, the JSOC is open to anyone willing to commit three months to a project, although preference will be given to students.

-viral

[Tim Holy]

Worth linking
https://github.com/JuliaLang/julialang.github.com/blob/master/gsoc/2015/index.md

(both for mentors to edit and for candidates to peruse).

--Tim

[Scott Jones]

These are particular interesting to me (if I were a student, or not already more than full-time working using Julia), I'd jump on one of these two:

https://github.com/JuliaLang/julialang.github.com/blob/master/gsoc/2015/index.md#project-simple-persistent-distributed-storage

https://github.com/JuliaLang/julialang.github.com/blob/master/gsoc/2015/index.md#project-fast-bignums-in-julia

The second also ties in with my interest in have fast decimal numbers in Julia, both fixed size (32,64,128), and arbitrary like bignums.

[Oscar Blumberg]

I just added (what I think is) a cool project for anyone who would want to dive deep into the compiler. It may be on the hard end of the spectrum but we all know what happens when you tell a student something is "too hard" ;)

https://github.com/JuliaLang/julialang.github.com/blob/master/gsoc/2015/index.md#project-specialized-call-site-method-caching

[Yichao Yu]

On Sat, May 16, 2015 at 6:30 PM, Oscar Blumberg <oscar.b...@ens.fr> wrote:
> I just added (what I think is) a cool project for anyone who would want to
> dive deep into the compiler. It may be on the hard end of the spectrum but
> we all know what happens when you tell a student something is "too hard" ;)
>
> https://github.com/JuliaLang/julialang.github.com/blob/master/gsoc/2015/index.md#project-specialized-call-site-method-caching
>

Is this the same with https://github.com/JuliaLang/julia/issues/10805
and @vtjnash seems to have a partially working version in place
although disabled by default?

[Tim Holy]

+1. That seems almost certain to substantially reduce the cost of type-
instability.

For prototyping purposes, I posted a possible pure-julia hack that gets at the
same issue:
https://groups.google.com/d/msg/julia-dev/fXJznjwQMF0/tsaw2P7uNTcJ

But I agree it would be far preferable to implement this in the language
itself.

--Tim

[Páll Haraldsson]

I saw an interesting project:

https://github.com/JuliaLang/julialang.github.com/blob/master/gsoc/2015/index.md#project-simple-persistent-distributed-storage

"This project proposes to implement a very simple persistent storage mechanism for Julia variables so that data can be saved to and loaded from disk with a consistent interface that is agnostic of the underlying storage layer."

["time-stamped versioning" - meaning? Schema evolution was one purported downside to:]

This SoC project may or may not be necessary. That is, be agnostic and just a wrapper/API. What about implementing (the very small system) Prevayler in Julia? I've seen it ported to some languages but since I heard about it in 2001, I can't say it has taken the world by storm (do not know anyone who uses it..). Business types and banks, etc. are very conservative and cling to SQL..

https://en.wikipedia.org/wiki/Prevayler

"Prevayler requires enough RAM to keep the entire system state."

This was perceived as a drawback at the time.. Lot's of databases fit, now (and in the future). This seems the requirement anyway in HPC. You do not want to work on virtual memory..

Is there a reason Prevayler can't be done in Julia? I do not think so. Julia has types not OO in the conventional sense and I'm not sure it's an issue. If I recall, the only requirement was that objects must be able to serialize. I only know it's not appropriate for PHP (because of "no state").

At least look at this article from the horses mouth:

http://www.advogato.org/article/398.html

"Transparent Persistence, Fault-Tolerance and Load-Balancing for Java Systems.

Orders of magnitude FASTER and SIMPLER than a traditional DBMS. No pre or post-processing required, no weird proprietary VM required, no base-class inheritance or clumsy interface definition required: just PLAIN JAVA CODE.

[..]

Question: RAM is getting cheaper every day. Researchers are announcing major breakthroughs in memory technology. Even today, servers with multi-gigabyte RAM are commonplace. For many systems, it's already feasible to keep all business objects in RAM. Why can't I simply do that and forget all the database hassle?

Answer: You can, actually.

[..]

If all my objects stay in RAM, will I be able to use SQL-based tools to query my objects' attributes?

No. You will be able to use object-based tools. The good news is you will no longer be breaking your objects' encapsulation."

I thought it might be a dead project but seems not:

https://github.com/jsampson/prevayler/tree/master

"authored on Aug 12, 2014"

There was some controversy at the time:

http://c2.com/cgi/wiki?ThePrevayler

"Orders of magnitude faster and simpler than a traditional database. Write plain java classes (albeit in accordance with a CommandPattern and a few constraints): [..] no inheritance from base-class required. Clear documentation and demo included.

 3251 times faster than MySQL.

 9983 times faster than ORACLE."

"Aren't you simply dropping all code from DBMs and stuffing it all on the application?

No. I have seen prevalent systems that were thousands of lines of code. Most DBMs are hundreds of thousands of lines of code. --KlausWuestefeld"

[This one I didn't know..:]

"KentBeck, [..] and KlausWuestefeld paired up for a weekend in december 2002, on the island of Florianopolis, Brazil, and implemented Florypa, a minimal prevalence layer for Smalltalk (VisualWorks) based on Prevayler."

"After having testing Prevayler (and Prevayler-like IMDB's) we came to this conclusion: It is useful for prototyping, but fails miserabely in terms of a lot of OODBMS/RBMS issues.

In fact, we concluded that when all the problems with Prevayler was solved, we had an object-oriented database.

* Sounds like an OOP version of GreencoddsTenthRuleOfProgramming."

http://c2.com/cgi/wiki?GreencoddsTenthRuleOfProgramming

A database-oriented twist on GreenspunsTenthRuleOfProgramming in which, "Every sufficiently complex application/language/tool will either have to use a database or reinvent one the hard way." I don't know who originally said it, so I combined DrCodd's name with Greenspuns'. Ironically, even Lisp, the original "greenspun" language, reinvents one by having an internal complex data structure (nested list in byte-code form) that takes on database-like characteristics.

http://c2.com/cgi/wiki?GreenspunsTenthRuleOfProgramming

"Any sufficiently complicated C or Fortran program contains an ad-hoc, informally-specified, bug-ridden, slow implementation of half of CommonLisp." as Julia has Lisp-like macros, considered a "lisp" by some, I think this "rule" may not apply too well to Julia..

[Sisyphuss]

You can be a tutor I guess.

[Páll Haraldsson]

On Sunday, May 17, 2015 at 3:30:49 PM UTC, Páll Haraldsson wrote:

I saw an interesting project:

https://github.com/JuliaLang/julialang.github.com/blob/master/gsoc/2015/index.md#project-simple-persistent-distributed-storage

"This project proposes to implement a very simple persistent storage mechanism for Julia variables so that data can be saved to and loaded from disk with a consistent interface that is agnostic of the underlying storage layer."

The GSOC project is probably still useful and Prevayler maybe not be for HPC.. I would still like to see it for Julia, but thinking about this more, the CommandPattern would generate very high log activity (if say matrix multiplication would be transaction level, maybe more coarse-grained would be ok). The snapshotting part of it might be better done from outside the application (I think there are tools, and they might work better, not sure about how Prevayler would handle non-deterministic/parallel. The clustering in it is for high-availability).

Maybe Prevayler would help for debugging.. you can rerun through your transactions/log but as operations are not always symmetric (matrix multiply), you wouldn't get reversible debugging. And for debugging HPC it would be slow to do this as you would recompute every step..

-- 

Palli.

[Jeff Waller]

Is this the part where I say Julia-Spark again?  

I think this is pretty doable in time.  It will likely be more or less a port of PySpark since Julia

and Python are similar in capability.  I think I counted about 6K lines (including comments).

According to the pyspark presentation, they relied on a 3rd party to containerize  a Python

program for transmission -- I think I'm remembering this right.  That might be a problem to

overcome.

[Zenna Tavares]

Echoing Miles, I vote for working to extend automatic differentiation (especially reverse mode) to all of Julia.

The work done in the current AD packages is great, but Julia has sufficiently powerful introspection and metaprogramming capabilities that we shouldn't, in principle, be limited to small subsets of Julia.

I'm not sure I am the one to work on it though.

Zenna

[Miles Lubin]

Agreed. There's a lot to be done with reverse-mode AD, though the full scale of the work is beyond that of a summer project. 

FYI, Theodore and I will be working with Jarrett Revels on the project we proposed around DualNumbers and extensions. Hoping to share the results at the end of the summer!

[Jey Kottalam]

Hi Jeff,

> they relied on a 3rd party to containerize a Pythonprogram for transmission

That is due to the pecularities of Python's serialization module than
anything intrinsic to creating a Spark binding. (E.g. Python's pickle
format doesn't have support for serializing code and closures, so some
extra code was required.) This isn't an issue in Julia since
Base.serialize() already has the needed functionality. An initial
implementation of a Spark binding done in the same style as PySpark is
available at http://github.com/jey/Spock.jl

-Jey

[Jeff Waller]

On Thursday, May 21, 2015 at 4:55:16 PM UTC-4, Jey Kottalam wrote:

Hi Jeff,

> they relied on a 3rd party to containerize  a Pythonprogram for transmission

That is due to the pecularities of Python's serialization module than
anything intrinsic to creating a Spark binding. (E.g. Python's pickle
format doesn't have support for serializing code and closures, so some
extra code was required.) This isn't an issue in Julia since
Base.serialize() already has the needed functionality. An initial
implementation of a Spark binding done in the same style as PySpark is
available at http://github.com/jey/Spock.jl

-Jey

Hey awesome.  Initial you say, what's missing? 

[Jey Kottalam]

The core functionality is there, but there's also more to be
implemented to have a complete interface to spark-core:

- distributed I/O
- broadcast vars
- accumulator vars
- custom partitioners
- persistence (caching)
- missing transforms and actions

-Jey

[Viral Shah]

Jey - just checking if you are listing what the project needs - or if you would be able to participate to build these?

-viral

[Miles Lubin]

We've put up a blog post (http://localhost:4000/blog/2015/05/jsoc-cfp/) with some more details on Julia Summer of Code. There are still a number of unfilled slots open; submission deadline is June 1st!

On Friday, May 15, 2015 at 1:57:24 PM UTC-4, Viral Shah wrote:

[Miles Lubin]

Sorry about that, here's the real link: http://julialang.org/blog/2015/05/jsoc-cfp/

[Scott Jones]

Your link is to a local address on your machine...

On Sunday, May 24, 2015 at 12:42:27 AM UTC-4, Miles Lubin wrote:

[Marcus Appelros]

Am applying with the Equations package along with a ongoing project to develop a course and offer bounties to contributors in the developing world.

Sort of already have a mentor, the director of the information technology institute at Vietnam national university Aiviet Nguyen who invited the development of the Equations package to be part of his research, however he is not a Julia expert.

Is there someone who would like to attach to the project as a mentor in areas not covered by Dr Nguyen? If the project is accepted for JSoC all compensation will be pledged for expanding the project and you will be given power of veto over any suggested expenses.

[Rinu Boney]

I'm interested in applying. I hope to contribute to the machine learning roadmap posted here: https://github.com/JuliaStats/Roadmap.jl/issues/11. I'm looking for a mentor. To apply, am i supposed to prepare a proposal similar to GSoC?

[Ken B]

I'm willing to participate in JSoC on the reverse-mode AD.

I'm looking for a mentor. If you know someone that could oversee this, don't hesitate to get in touch!

With some experience in Julia as well as in optimization and MCMC, I believe I can move this project forward.

Cheers,
Ken Bastiaensen

[Jey Kottalam]

Viral -- Given the clear interest in it, I'll work toward fleshing it
out more fully. However, if anyone is interested in contributing I'd
gladly take the help.

[Shantanu Raj]

I am hoping to join JSOC to apply for the autoformat-tool project, it would be great to have one for Julia too. The project can eventually be extended to a Sublime Text/Atom plugin ala. GoSublime.

I am looking for a mentor, I have the time to devote to the project. Though I am a beginner in Julia programming currently, but I can learn fast. I have worked a lot in Go, and I looked up the source for gofmt, seems reasonable.

Anyone willing to mentor, please feel free to contact me, I'd be highly grateful

- Shantanu

[Seth]

I'd be interested in mentoring a project to develop a robust web stack (starting with OpenSSL, probably). I submitted via NumFocus a couple months ago but the project was not selected.

[Andrei Zh]

@Jey, I'm willing to help, but I need some initial guidance. Please, check out issues tab in Spock.jl.

[Brian Cohen]

I'm looking for a mentor, and I'd be willing to commit to any projects involving control systems, linear ODE solving, or something that involves making use of types / PL theory. Two project ideas I haven't formalized yet: adding Elm-style FRP to Jupyter notebooks (perhaps extending Reactive.jl), or porting SymPy/PyDy functionality to Julia. AD looks interesting, and I might be a potentially useful candidate having background in Haskell (so I can read from Kmett's library).

[Alexander Frazer]

I'd love to contribute to either the ODE solvers project, one of the parallel linear algebra routines project or the GPU package. 

I'm looking for a mentor, so if anyone knows someone who could help please reach out!

[Gurshabad Grover]

Hello,

I'm a CS student interested in implementing the ODE solver mentioned in the project ideas page. There are discussions on the matter [1][2] which I have gone through and wrapped my head around. I'm confident that I can complete the project and am looking for someone to mentor the project for JSoC. I have more than necessary math background to start on this immediately, and tried making something similar as a personal project some months ago (which sparked my interest in this particular project)

Please let me know if someone is willing to mentor this project; thank you!

[Alex]

Hi Alexander and Gurshabad,

Thanks for your interest in JSoC and in particular for considering to help with dealing with ODEs in Julia. The two issues linked by Gurshabad are indeed the most relevant ones, although I think they are also a bit outdated. In ODE.jl we had some developments in the last year and in particular Mauro's PR will improve the situation with respect to (explicit) RK solvers quite a bit. So I am not sure to what extent the project ideas formulated in those two issues are still relevant. It has also been suggested to add an ODE solver to Base. Personally I am not very fond of this idea, but I know that others were in favor in the past and there might still be interest in doing so.

I hope all of that doesn't sound too discouraging! There is certainly plenty of stuff to do for ODEs in Julia, but I wanted to put the two issues into context of recent developments.

Best,

Alex.

[Dom Luna]

I'd be interested in bridging Julia and Torch. I believe this has been thought about before https://github.com/soumith/NeuralNetworks.jl. What are the challenges to starting some work on this?

If not I'd like to work on the JuliaWeb project. I was watching the GoSF meeting last night via live stream and in Go 1.5 (master) shared libraries are available. This got me thinking it would be cool to interface between Julia and Go. Go is known for its server capabilities so leveraging this could be very useful. I realize this sounds a bit crazy. It's an idea I've had for a little while now that just perhaps became viable. Go runs on a boatload of architectures so that shouldn't be a problem either.

[Andrei]

@Dom, you may also be interested in Mocha.jl [1] - Julia library for deep learning. 

[1]: https://github.com/pluskid/Mocha.jl

[Jiahao Chen]

I'd be happy to mentor someone working on parallel linear algebra. The simplest thing to do that will have very high impact is to implement high performance iterative (Golub-Kahan-Lanczos) SVD, similar to what is implemented in PROPACK. I'm also interested in a randomized SVD version similar to what is described in Halko, Martinsson and Tropp, doi:10.1137/090771806.

I'm sure there are plenty of ODE projects around, but I would like to see someone take up the implementation of geometric integrators in ODE.jl.

Thanks,

Jiahao Chen

Research Scientist

MIT CSAIL

[Jiahao Chen]

Reposting from a question I got offline:

IterativeSolvers.jl implements a basic GKL SVD, but it has not been tested for performance with distributed arrays. The project I have in mind will consist of benchmarking and rewriting any necessary parts for speed. Most of the work I foresee coming from improving the speed of parallel matrix-vector products, and particularly implementing linear algebra operations for sparse distributed matrices, which don't exist right now.

There are also questions of how to deal with numerical stability issues and reorthogonalization, and how to design an implementation that allows users fine-grained control of reorthogonalization for speed-accuracy tradeoffs.

Thanks,

Jiahao Chen

Research Scientist

MIT CSAIL

Thanks,

Jiahao Chen

Research Scientist

MIT CSAIL

[Viral Shah]

Please do ask everyone who is interested in participating to send their project description and mentors also to juli...@googlegroups.com

The last date is June 1, after which we can take a call on how many proposals we have received and which ones to fund.

-viral

--

-viral

[Shashi Gowda]

A possible project on the UI side of things is expanding functionality in Escher.jl (https://github.com/shashi/Escher.jl)

Escher is a work-in-progress declarative UI library which lets you make Web UIs in pure Julia. It works well with Reactive.jl to allow you to create interactive visualizations/dashboads.

There are 2 possible projects that are suitable for a 3-month period of work.

1. Testing infrastructure and tests - this should involve using something like Selenium

2. Expanding the library to include: spreadsheets, Table lens, and/or anything else you think might be good to have in a Julia UI toolkit

If you are interested, let me know, we can do a hangout at a suitable time and I will give you an overview of the package. It will be great if others can spread the word about this project if you have someone in mind who you think can help out here, especially since there is not much time left.

@Brian, I don't understand what you mean by adding Elm-style FRP to Jupyter. Currently any Reactive.jl Signal can be shown in a Jupyter notebook and it will be re-rendered on update.

[Job van der Zwan]

I'd love to see a tool like that, hope you'll get in!

[Siva Prasad Varma]

I am interested in implementing Neural Network visualization for Mocha along the lines of https://github.com/ajtulloch/dnngraph or implementing some algorithms in the IterativeSolvers.jl roadmap depending on whether I will be able to find a mentor.

Thanks,

Siva.

[Viral Shah]

You should certainly write to pluskid - Mocha's author.

--

-viral

[Chiyuan Zhang]

Hi all,

I'm happy to mentor things related to Mocha.jl (https://github.com/pluskid/Mocha.jl), deep learning library for Julia. There are several TODOs on my list but I had difficulty finding free time to do. You are also free to propose anything else that is related:

1. Visualization of the networks (e.g. produce a dot file that could be rendered by GraphViz to visualize the network nicely)

2. Provide an easy interface to do small scale experiments (e.g. define a model by giving something like [(512,:relu), (512,:relu), 10], and being able to train or predict with one function call without worrying about all the details of layer definition and solver, coffeebreaks, etc.)

3. Implement Recurrent Neural Networks, LSTM

Best,

Chiyuan

[Scott Jones]

What is this Moore Foundation?  Are you talking about the Gordon and Betty Moore Foundation? (that's all that I could find that looked like it might fund a project on Google)

Just what is required for a company to fund a Julia Summer of Code project? (I've been advocating that the startup I'm consulting for fund a student next summer... [assuming the company is going strong, which I think it will, and that Julia is going strong, ditto]).  We've been talking about what things we could make some form of open source (MIT, non-commercial only, whatever...), and how we could contribute to the Julia community.

[Jiahao Chen]

What is this Moore Foundation?  Are you talking about the Gordon and Betty Moore Foundation? (that's all that I could find that looked like it might fund a project on Google)

 

Yes.

Just what is required for a company to fund a Julia Summer of Code project? (I've been advocating that the startup I'm consulting for fund a student next summer... [assuming the company is going strong, which I think it will, and that Julia is going strong, ditto]).  We've been talking about what things we could make some form of open source (MIT, non-commercial only, whatever...), and how we could contribute to the Julia community.

Good to hear that they might be interested. Perhaps the easiest thing to do is to make a donation to Julia through NumFocus.

[Rohit Kashyap]

Sir, I am interested in working on developing the web stack, can we discuss about it. Deadline is very near

[Rohit Kashyap]

Sir, I know it's 11th hour but I just got the news about JSoC and would be very interested to work on this project.

On Saturday, 16 May 2015 09:06:03 UTC+5:30, Miles Lubin wrote:

This is both a proposal and a call for interested undergraduate and graduate students:

Automatic differentiation is a technique for computing exact numerical derivatives of user-provided code, as opposed to using finite difference approximations which introduce approximation errors. These techniques have a number of applications in statistics, machine learning, optimization, and other fields. Julia as a language is particularly suitable for implementing automatic differentiation, and the existing capabilities are already beyond those of Scipy and MATLAB. We propose a project with the following components:

1. Experiment with the new fast tuple and SIMD features of Julia 0.4 to develop a blazing fast stack-allocated implementation of DualNumbers with multiple epsilon components. Integrate with existing packages like Optim, JuMP, NLsolve, etc., and measure the performance gains over existing implementations.

2. Combine this work with the ForwardDiff package, which aims to provide a unified interface to different techniques for forward-mode automatic differentiation, including for higher-order derivatives.

3. Time permitting, take a step towards the reverse mode of automatic differentiation. Possible projects include developing a new implementation of reverse-mode AD based on the expression-graph format used by JuMP or contributing to existing packages such as ReverseDiffSource and ReverseDiffOverload.

There are quite a number of interesting projects in this area (some with avenues for publication), so we can adjust the work according to the student's interests. An ideal student should be interested in experimenting with state-of-the-art techniques to make code fast. No mathematical background beyond calculus is needed. See juliadiff.org for more info.

Co-mentors: Miles Lubin and Theodore Papamarkou

If this sounds cool and interesting to you, do get in touch!

[Jiahao Chen]

Hi Rohit,

Please read the CFP and submit a proposal by the end of 1 May. The CFP contains sample code projects.

http://julialang.org/blog/2015/05/jsoc-cfp/

[Jiahao Chen]

Sorry, that should have been June 1.

[Rohit Kashyap]

Its ok Sir. I am drafting a proposal and will be sharing with you for consideration and discussion for improvement before submission.

---

From: Jiahao Chen
Sent: ‎30-‎05-‎2015 12:13
To: julia...@googlegroups.com
Subject: Re: [julia-users] Re: Julia Summer of Code

[Gurshabad Grover]

I'd like to work on making an autoformat tool for Julia. It is a generic but experimental project but I'm sure if the tool is made, it will be welcome by the community. I'm familiar with the language  an have a structured plan in mind; writing the proposal should not take much time if I am able to find a mentor soon. (I plan to use Go's autoformat tool as a blueprint on the things the tool needs to take care of)

Please let me know soon if anyone would like to mentor this project! Looking forward to working with you.

[Rohit Kashyap]

Hi,

Greetings to all mentors, I request you to go through this Proposal draft and submit your feedback/suggestions for improvements before submission deadline.

https://docs.google.com/document/d/1SrNgmK-GUsxLzxwKwjHWzPzB9Vj53vsIqSH41MRBe34/edit?usp=sharing

[Rohit Kashyap]

I have a querry, Can we submit updations in our proposal now ? How are we supposed to mention the information about mentor ?

[Jiahao Chen]

I am pleased to announce the list of accepted participants and projects for the 2015 Julia Summer of Code:

• Ambuj Agrawal, Improving debug information generation in Julia (mentor: Keno Fischer @Keno)
• David Gold (@davidagold), Nullable arrays (mentor: John Myles White @johnmyleswhite)
• Jacob Quinn (@quinnj), Pipelines.jl: composable streams for data transfer and processing (mentor: Viral B. Shah @ViralBShah)
• Jarrett Revels (@jrevels), Automatic differentiation (mentors: Miles Lubin @mlubin and Theodore Papamarkou @scidom)
• Kenta Sato (@bicycle1885), Efficient data structures and algorithms for sequence analysis in BioJulia  (mentor: Daniel C. Jones @dcjones)
• Rohit Varkey Thankachan (@rohitvarkey), Compose3D.jl: declarative 3D graphics (mentors: Shashi Gowda @shashi and Simon Danisch @SimonDanisch)
• Simon Danisch (@SimonDanisch), GLVisualize.jl: OpenGL visualization in Julia (mentor: Keno Fischer @Keno)

Congratulations to the selected participants and a big thank you to all the mentors who agreed to donate their time toward improving Julia.

Thanks also to the other committee members Alan Edelman, Keno Fischer, Miles Lubin, Shashi Gowda, Stefan Karpinski, and Viral Shah for their efforts in evaluating the many proposals received.

[Milan Bouchet-Valat]

Le mardi 09 juin 2015 à 23:14 -0700, Jiahao Chen a écrit :
> I am pleased to announce the list of accepted participants and
> projects for the 2015 Julia Summer of Code:

> * Ambuj Agrawal, Improving debug information generation in Julia
> (mentor: Keno Fischer @Keno)
> * David Gold (@davidagold), Nullable arrays (mentor: John Myles
> White @johnmyleswhite)
> * Jacob Quinn (@quinnj), Pipelines.jl: composable streams for

> data transfer and processing (mentor: Viral B. Shah
> @ViralBShah)

> * Jarrett Revels (@jrevels), Automatic differentiation (mentors:

> Miles Lubin @mlubin and Theodore Papamarkou @scidom)

> * Kenta Sato (@bicycle1885), Efficient data structures and

> algorithms for sequence analysis in BioJulia (mentor: Daniel
> C. Jones @dcjones)

> * Rohit Varkey Thankachan (@rohitvarkey), Compose3D.jl:

> declarative 3D graphics (mentors: Shashi Gowda @shashi and
> Simon Danisch @SimonDanisch)

> * Simon Danisch (@SimonDanisch), GLVisualize.jl: OpenGL

> visualization in Julia (mentor: Keno Fischer @Keno)
> Congratulations to the selected participants and a big thank you to
> all the mentors who agreed to donate their time toward improving
> Julia.

Glad to hear that somebody is going to work on NullableArrays! (Of
course, other projects are great too. ;-)


Regards

[Stefan Karpinski]

I wanted to say thank you to everyone who applied. There were many great proposals and there were some tough choices of how to apply our limited funds, generously contributed by the Gordon and Betty Moore Foundation. Even if your project didn't get accepted, we hope to see you around the mailing lists and on GitHub.

[Rohit Kashyap]

Hi,
I am new in Julia lang community.
I came to know about it through JSoC.
Though I didn't get through with my proposal in JSoC but I am very interested in starting up to contribute in packages, modules.
Any guidance, pointers will be appreciated.
Thanks

---

From: Stefan Karpinski
Sent: ‎10-‎06-‎2015 20:40
To: Julia Users

Subject: Re: [julia-users] Re: Julia Summer of Code

[Marcus Appelros]

@Rohit: Judging from your proposal you are into ML and AI, am planning
a crowd trained music making ANN. We can collaborate, if you like.

[Rohit Kashyap]

Yes definitely :)

---

From: Marcus Appelros
Sent: ‎11-‎06-‎2015 01:06
To: julia...@googlegroups.com

[David Anthoff]

Congratulations, looks like a great list!

[Shashi Gowda]

An update:

We have 2 more accepted JSoC projects, thanks to further funding from The Moor Foundation and MIT.

Kyunghun Kim will be working on HPGPU Programming for Julia (mentored by Tim Holy)

Brian Cohen will be working on implementing a test suit for Escher.jl (mentored by me)