I think one of the bigger barriers to Julia’s growth is the lack of modern, accessible, comprehensive tutorials that assume very little about previous knowledge. Without that, its really hard for inexperienced programmers to pick up Julia and you’re relying on converting established programmers from their language of choice where they are comfortable and established to Julia where they have to start anew. This is likely a harder task that taking in new programmers because people in general don’t like change and will suffer through all the deficiencies of Python + Numba + Numpy + Cython and then say “Look at how fast my disgusting code is. Why do I even need Julia?” and then plug their ears when you try and answer.
This sort of low barrier of entry community generated articles are practically impossible to develop in a small community without heroic effort but happens more or less naturally in big communities.
I know that when I started screwing around with Julia macros I ran into a bit of a wall because the meta programming guide in the Julia docs only went to far and there were very few other resources out there for me to use and I still am a little mystified by some facets of the macro system.
With that in mind, I think that if we want to be serious about making Julia grow, we need to start thinking about not just writing articles on high level advanced Julia functionality but more stuff on the basics and neat, low level tasks that are easily accomplished in Julia.
I know I’d like to start writing these sorts of articles but I feel like too much a beginner myself to put out that sort of article and don’t want to mislead people with crappy code.
I know I’d like to start writing these sorts of articles but I feel like too much a beginner myself to put out that sort of article and don’t want to mislead people with crappy code.
I don’t think that feeling ever goes away. One way to get around it is to focus on something that you’re interested in anyway, and write about how you do it in Julia. That way, even if your code isn’t perfect, you’re still accomplishing something that’s important to you (which is the actual goal of software after all). I like solving puzzles, so I’ve written a few blog posts about solving puzzles in Julia: Chromesthesia ← . @mprat likes computer vision, so she’s started a blog about playing with computational photography in Julia Getting started with images .
You can do this too! And plus, you’ll have more traction in getting others to do what you’re suggesting if you become part of the solution yourself.
It would be really nice if the metaprogramming section in the main Julia documentation made people abundantly aware of MacroTools.jl (I really feel that stuff should be in Base anyway).
I think one of the barriers to getting inexperienced programmers involved is that they probably have people around them (both in real life and on the internet) who are screaming at them to use Python, and since they are inexperienced, it’s harder for them to make an objective judgment. I think that’s part of why the focus of most new languages seems to be on converting disillusioned programmers from older languages. That said, I’m sure nobody objects to the idea of trying to make Julia more accessible to inexperienced programmers.
Well, I’ve never heard of macrotools.jl so I guess that proves your point! I’ll definitely look into this. It looks like exactly what I need.
I think part of why they’re screamed at to go into python is that nobody else has made as much effort to make as much beginner friendly teaching material as pythonistas. If we can start making better beginner friendly material, we can weaken that argument against starting with Julia and capture more beginners.
I am confused: you talk about inexperienced programmers, then mention macros as an example. Yet macros and metaprogramming are probably the among the last things one would learn; and one can work productively in Julia for a long time without writing any macros.
Nevertheless, promoting Julia as one’s first programming language indeed does not seem to be a priority at the moment. This may be because there has not been a stable release, or because the language does have concepts which do require some investment. That said, there is some material for newbies in Get started with Julia
I think one of @Mason’s points is that meta-programming is among the features of Julia that is a major advantage over other languages that someone would be likely to choose as an alternative, so the ability to get into it quickly might be a major selling point.
the problem with “selling” the language with a feature like macros is the Blub paradox: if someone has not seen macros, it is very hard to grasp how they are useful.
Frankly, in a tutorial for inexperienced programmers, I would omit macros completely. There are so many things to discuss about Julia which are useful that by the time they are covered, the audience will not be inexperienced any more.
Inexperienced is a fuzzy term. I am familiar with programming in Python, Matlab, Mathematica, Julia and Common Lisp but don’t have a particularly deep knowledge of any of them except perhaps Python and despite being familiar with many different programming constructs, paradigms etc. I still rely very heavily on low level beginner and introductory material.
Python has beginner friendly articles on multiprocessing, function decorators, generators / iterators, OO programming etc. none of which are ideal beginner topics but nonetheless there is still beginner level articles explaining these things and its often very helpful!
Especially in scientific programming, an inexperienced programmer often has to jump into working on an advanced programming construct to right out of the gate because their colleague or instructor told them to use said construct. Having beginner literature on these topics is indispensable for these people. Julian literature is lacking in this regard.
I won’t say you’re wrong, but personally I think macros are a fascinating and powerful concept and I’m not convinced that they can’t be taught to relatively inexperienced Julia programmers or that they can’t be made convincingly interesting to a non-expert.
So whats the solution? Not show them macros? If the problem is that they haven’t seen them and thus can’t understand why they’re useful then show them macros they can understand and use those to convince them that they’re useful!
Common Lisp has much literature thats about as beginner friendly as Common Lisp gets which explains macros and I found it very helpful.
Regardless though, this point about macros is somewhat tangential and maybe my anecdote shouldn’t have been included in my original post.
IMHO @dpsanders Invitation to Julia talks do a great job conveying macros to newbies, and at just the right level. Start with predefined and simple macros like @show and @time, use them to explain what a macro is and why you want them, then go on to show how @code_lowered, @code_llvm, @code_native do more sophisticated and very revealing code transformations. Then demonstrate how to write a simple macro of one’s own, like generate a polynomial function from coefficients.
Seems perfectly suited to an intro-level tutorial. I learned about macros from David’s talk as a total newbie on day 1 of JuliaCon 2015. I walked away convinced that Julia goes way beyond previous numeric languages, and macros were an important part of that.
EDIT: Julia Notebooks for David Sanders Invitation to Julia. Macros are talked about as a topic in themselves in notebook 3. Metaprogramming but introduced gently with @show and @time earlier.
I’m sure members of the community would be willing to give you feedback on a draft of a tutorial for beginners. You could model it after one of the Python tutorials that you found helpful.
I think my article seemed more like a complaint or demand from the community than I intended, so apologies for that. I more just wanted to share what I had been thinking lately about how literature effects a language’s growth and community. I definitely do plan on writing some articles soon as I think it’ll be a great learning experience for me and a way to contribute to the community.
I was planning on waiting a bit before starting but perhaps I should start sooner and get feedback from the community to make sure I didn’t say anything too stupid.
That wasn’t my interpretation at all. In fact, I also had difficulty when first learning Julia. Having more examples available would certainly be welcomed.
I think what could be a very useful and easy way to kickstart, and not unnecessarily delocalize tutorials/example code, would be to create a new category (with possible subcategories depending on the topic of code / github organisation used…) here on discourse with some appropriate title (code sharing || examples || tutorials || whatever).
This in my opinion would lower the threshold for users to share their code, write small examples or tutorials, by a lot. I know I would even post some of my novice level code on there, rather than trying to figure out how blogging works. I also think discourse has all the features that are needed to support something like this.
This would also allow for easy discussion/improvement of the examples, from which everybody benefits. Package creators can then easily take the best examples, and put those into their packages, making it directly accessible to less inclined users.
This is true, I agree that discourse is not the best way to bring it to new users, I think of it more as a gateway to share examples, from which the main julia people can then easily take the best ones and bundle them on the official julia site. Similar to the examples for packages I mentioned
I didn’t mean to criticize, only to encourage you. You really can help make this happen!