I don't necessarily have a large project, but there are a few tidbits I think I can share. I'm not familiar with all the things strings, so I'll let someone else take that.
2. You can always do composition instead of inheritance. For many it's a preferred coding practice anyways <https://en.wikipedia.org/wiki/Composition_over_inheritance>. In the end I find it leads to less breakage. 3. Instead of "using Module", you can just do "import Module" and the namespace will be cleaner, but you'll need to use Module.thing to reference them. If your package is mostly defining functions on your own types, then you don't need to worry about any clashes anyways (unless some package that you import has a type which is the same name, and defines a method with the same name and uses that same type). It's hard to know how Julia will fare for large projects since it's still young. For a good reference on organizing code really well using dispatch and metaprogramming, see Plots.jl's source. 4. Multiple dispatch isn't just a utility of code design, it's THE fundamental part of Julia which makes it look like a scripting language while being write strictly typed (hopefully type-stable) compiled functions every step of the way. You can think of it as a smart trick which makes what you're writing look like fluid Python, but in reality every time you call a function, it's actually calling a special-cased (and therefore well-optimized) compiled function for exactly the types you give it. Here's an analogy for multiple dispatch. Speaking to Python is like speaking to politicians: the words/syntax are nice and concise, but there's a lot of behind the scenes translations that are going on which makes it slower to "get to the point". You say "free-market", the politician hears "regulations" and after some discussion with advisers it can respond to you with what you want. Advantage: it gives you want you want with little effort. Disadvantage: it can be a slow process, and sometimes you don't know what exactly is going on behind the scenes (what is the interpreter actually doing when using a Float as an Int?). Speaking with Julia is like speaking with a professor at a coffee shop. You're talking and just say "yeah, take the derivative of that F to maximize u" which means "take the Frechet derivative <https://en.wikipedia.org/wiki/Fr%C3%A9chet_derivative> of the functional to get the u which maximizes the ____ norm in the function space ____". Everything you are saying is shorthand which, when expanded, gets right to the point. Advantage: fast. Disadvantage: it will be slow and the conversation will meander if you don't actually know what the specific statement is supposed to mean (i.e. you don't write a type-unstable function). That turned out longer than I thought it would, but I think it gets the point across: multiple dispatch is always useful for getting you good clean performance if the functions you're writing are clean and type-stable (and if that's the case, you can get close to 1x with C). Whether you'll put in the effort to strictly type things and make the functions type-stable is up to you (in which case, Julia will still be expressive, but not the most performant). In the end, some mix where you prototype with less strict types but clean it up to end up with fast performant functions is a nice way to write code, and that's not an because of Julia: it's because of multiple dispatch (... so Julia is essentially taking a design philosophy based on multiple-dispatch on top of a compiler to an extreme. We've come full circle). On Tuesday, August 23, 2016 at 5:39:26 AM UTC-7, JColn wrote: > > Hello, > > I'm looking at Julia for general purpose programming and things look good > so far. However, I want to see if I can elicit feedback from those that > have ventured deeper into larger projects before moving further. Below > are questions regarding areas of concern I've seen cited and I'm wondering > if these issues are real. If anyone can provide experience I would be much > obliged( My frame of reference is python). > > 1. Strings. Are they faster in 0.5 (python speed or better). How about > ease of use? > > 2. Inheritance- Any issues with not being able to do concrete inheritance? > > 3. Module system and dispatch- Lots of Ink has been spilled on this, and > I understand that organizing multi dispatch code is an open research > question. However, it seems there are legitimate concerns about name > clashes,ease of use etc I've also perused some open issues, but don't see a > fundamental redesign. How does Julia fare for larger general projects > compared to say python or java> > > 4. Multi dispatch. How do you find its utility for non numerical code? > > Thanks! > > >
