How do I get started with developing features for julia?

[Traktor Toni]

Is there an article? Compiling llvm, getting the sources into qtcreator, setting up gdb to debug, What's the workflow? 

I would love to hear from core developers how new features are being made or debugged so I can get started as well.

[Yichao Yu]

As someone who joint recently, my advice is to try it and try to fix
small bugs or make small improvements. As long as you spend reasonable
amount of time on it, you will get to learn more and more about julia
naturally.

For exactly what to start, I think there's some intro-issues (label)
on the issue tracker that should be good starting points. You can also
(as in my case) try to find some yourself. As a pre-mature project,
it's not that hard to find places to improve.

As for the workflow and tools, I think everyone has their own ones.
The readme should have pretty good description of how to compile
julia. IIRC there should also be some tips about using Git and others
in the contribution doc.

[Isaiah Norton]

Welcome. There are build instructions in the README (see README.Windows for some platform specifics):

https://github.com/JuliaLang/julia/blob/master/README.md#source-download-and-compilation

See also the contributor notes:

https://github.com/JuliaLang/julia/blob/master/CONTRIBUTING.md

There are some helper files for various editors under `contrib/`, and externally in the case of vim [1]. I'm not aware of anything for QtCreator. Support files for emacs and vim are probably the most actively-maintained, but developers use a wide range of tools.

One strong recommendation: if you are not already familiar with the relevant tools, spend some time familiarizing yourself -- especially with git ("repo", "push", "squash", and "rebase" should sound at least vaguely familiar). Along the same lines: start small -- doc fixes and test improvements are usually uncontroversial and always appreciated.

[1] https://github.com/JuliaLang/julia-vim

On Sun, Jul 5, 2015 at 7:31 AM, Traktor Toni <trust...@gmail.com> wrote:

[Tim Holy]

As others have said, start small and get more ambitious once you know how the
process works. Here's a good issue for getting started:
https://github.com/JuliaLang/julia/issues/11885

--Tim

[Katie H]

As the author of that issue, we also have a Gitter (https://gitter.im/kshyatt/julia-coverage) where you're welcome to hang out and ask for feedback/advice. If you have any questions about looking for some good spots to test/fill out features, I'd be happy to try to answer them!

[Traktor Toni]

I know you all mean well but your answers didn't really help me a lot yet. I have already compiled julia but now I'm looking at the src folder and I'm asking myself "am i just supposed to change something in abi_llvm.cpp, then run the entire make step again, wait, see if that changed something and then try again?"

Surely that isn't exactly a recipe for success? 

What's the architecture of julia? I understand that julia has a dependency on llvm right? Is it a binary dependency and we just use llvm's api?

which parts of julia are llvm based?

So julia is generating llvm "modules" on the fly right, that will be our runtime code. So if I wanted to add a new feature to julia, I'd need to create a new llvm module?

Would you say that deep llvm knowledge is a must for most julia development?

What kind of debug info is currently being generated? Is it dwarf? Can I use gdb and step over c and julia at the same time or is that not an intended scenario, i.e: do we want a debugger api like the chrome remote debugging protocol or a more traditional gdb supported approach?

The rust devs say they may need special support in the dwarf standard to get "proper" debugging symbol support, is that the case for julia as well?

[Randy Zwitch]

What features you'd like to add? A great deal (a majority?) of the Julia functionality is written in Julia, or wraps APIs from other languages. So we can probably assume that you aren't going to need to write C++ code, unless you're trying to fix something that relies on one of those libraries.

The following is a trivial example of extending functionality in Julia. You can do this in any Julia environment (REPL, Jupyter Notebook, Juno, etc.)

julia> import Base.sin

julia> function sin(x::String)

           println("What a dumb modification!")

       end

sin (generic function with 12 methods)

julia> sin("randy")

What a dumb modification!

If you want to actually contribute this to the Julia distribution, then you would go to where Base.sin is defined, add your code, and submit a pull request to GitHub. Depending on the usefulness, it may/may not get merged. After merging, when people run the makefile or use a pre-compiled binary, then this method signature would be available to them.

[Traktor Toni]

I'm mostly interested in getting proper debugging support and maybe a way to get intellisense in julia

[Isaiah Norton]

Debugging is still a work in progress. Julia does emit DWARF, but the usefulness may vary somewhat by platform. At least on linux with llvm 3.3 (current default) you should get julia function names interspersed with C functions for all stack frames in gdb. Setting breakpoints in Julia files may work but can be finicky due to inlining and macro expansion. If you build julia against llvm-svn there are some improvements.

The MSVC compiler is not really supported yet. There is no Visual Studio integration whatsoever.

As far as compiler internals, here are a few links to get started:

http://docs.julialang.org/en/latest/#developer-documentation

julialang.org/publications

https://www.youtube.com/watch?v=osdeT-tWjzk

[Yee Sian Ng]

You may also want to get started with Keno's talk from JuliaCon 2014. Then have a look at the design and implementation of debugging packages in julia, e.g. toivoh/Debug.jl and maybe Keno/DIDebug.jl and Keno/REPLCompletions.jl.

[Tony Kelman]

The MSVC compiler is not really supported yet. There is no Visual Studio integration whatsoever.

On a very experimental basis there is minimal support for using MSVC to build Julia against gcc-built dependencies, see https://github.com/JuliaLang/julia/issues/12056

If the plugin architecture for the new Visual Studio Code editor has been made open yet, incorporating Julia support, highlighting, tab completion, etc into that would be a cool project.