I'll also take a stab at this. For context, I've been programming in Julia full time for the last 13 months, as well as mentoring a couple of my colleagues using Julia, and have contributed to various parts of Julia (string conversions, unit tests, documentation, among other things).
* I use Emacs (mostly because I haven't had time to move my customizations / key bindings I've had for years over to Atom, which the rest of my colleagues are using for Julia development) * For debugging, I tend to try things out first in v0.5 (even though many things don't work the same as v0.4.5), because of the much better backtrace information, and also because I've been trying out Gallium.jl, but it still doesn't work tracing through my code, although I'm confident that the remaining issues are soon dealt fixed. It still seems rather primitive though compared to the debugging environment I used to have for C/C++ with MS Visual Studio, or using XCode. Because of that, I end up decorating a lot of my code with print statements, using a macro that can either be compiled completely away, or based in bits I set on a per module basis, that prints out a string. I found the @printf macros and the $ string interpolation rather cumbersome, so I made my own string utility package https://github.com/ScottPJones/StringUtils.jl, that combines C and Python style formatting with Swift style string interpolation (building off of Dahua Lin's, Tom Breloff's (& others') work in https://github.com/JuliaLang/Formatting.jl) Being able to set defaults for how different types are formatted (thanks, Tom!) saves a LOT of time typing when adding a bunch of debugging output statements * The code I write is mostly low level, performance critical stuff (sparse data support, serialization/deserialization, string handling, database access), so I use `@timev`, `@profile` and https://github.com/johnmyleswhite/Benchmarks.jl, as well as all of the other macros, i.e. `@which`, `@time`, `@profile`, and `@code_*` that Jacob already mentioned, to make sure I avoid things like type instability, excessive allocations, unnecessary conversions, etc. * Make sure you write unit tests and use code coverage tools. * Document everything! We always put things in modules, and add a docstring to describe each module at the top of each file. We even make sure to document "private" functions (i.e. not exported), it makes life much easier when you can simply type `?<name>` or `?<module>.<name>` to get some helpful info while in the REPL. * Some very useful packages: JSON.jl (reading and writing configuration data), CSV.jl (loading lots of tabular data - again, thanks Jacob!), SQLite.jl (quick storage, easy to access from different languages), ODBC.jl (for more complex database access needs, esp. useful to me now that decimal floating point values and different Unicode encodings are now handled correctly), DecFP.jl (ability to deal with decimal floating point arithmetic, which can be important when dealing with certain types of financial data, not stuff quants look at, but simple stuff like doing correct calculations with currency amounts, such as getting the sales tax amount correct, simply try `round(.70*.05,2)` to see what I mean) * I've also started using Tom Breloff's https://github.com/tbreloff/Plots.jl (first used it to help my son with his science fair project, realized it's useful to me to visualize some of my benchmarking results, instead of eyeballing screens and screens of text output). * I also found https://github.com/weijianzhang/MatrixDepot.jl useful, to get a number of different types of matrices to help test & benchmark some sparse matrix construction code I had implemented (because of performance issues I'd run into with sparse matrices in Base) Finally, there's a theme to many of my previous points, i.e. build on top of what a lot of other smart people have created. A great resource to help find those is Svaksha's http://svaksha.github.io/Julia.jl/ Hope that helps! Scott P.S. If you are concerned about the efficiency of the code you write, in addition to how efficiently you are developing your code, I'd recommend getting Avik Sengupta's new book: https://www.packtpub.com/application-development/julia-high-performance On Thursday, May 12, 2016 at 1:01:04 PM UTC-4, David Parks wrote: > > I'm a few weeks into Julia and excited and motivated to learn and be as > efficient as possible. I'm sure I'm not alone. I know my way around now, > but am I as efficient as I can be? > > What haven't I tried? What haven't I seen? What haven't I asked? > > For those of you who have been around longer, could you share your advice > on efficient day-to-day development style? > > For example: > > - What IDE do you use? Are you using Atom? A combination of Atom and > the REPL? Something else? > - How do you debug complex code efficiently? How do you debug other > peoples code efficiently? > - Do you have a favorite way of visualizing your work? > - Are there must have tools? packages? utilities? > - Any simple day-to-day efficiency/advice you could share with others > who didn't yet know to ask. > > >
