JuMP.jl

Maybe a bit lower level, but JuMP.jl [1][2] is an optimization library written in Julia that's starting to see a lot of usage (it's one of those libraries that's attracting people to Julia). Docs for setting up constraints in JuMP [3] [1] https://jump.dev/JuMP.jl/stable/ [2] https://github.com/jump-dev/JuMP.jl [3] https://jump.dev/JuMP.jl/v0.21.1/constraints/

>numerical optimisation stuff Yes, far exceeding python actually. - https://github.com/jump-dev/JuMP.jl - https://github.com/JuliaNLSolvers Are just some. > graphing Excellent support. - https://github.com/JuliaPlots - https://github.com/JuliaPlots/Makie.jl >Munging xml/Json etc - https://github.com/quinnj/JSON3.jl - https://github.com/JuliaData - https://github.com/Algocircle/Cascadia.jl - https://github.com/queryverse/Query.jl >oauth2 etc - https://github.com/JuliaCloud - https://github.com/JuliaWeb/HTTP.jl for anything not available yet, you can call it from python using PyCall.jjl

One of the main reasons I started looking into Julia was because someone smarter than me in the DOE CSGF program was using it (specifically Miles Lubin, who was working on JuMP[1] at the time). I don't know if that's a good way to choose programming languages, but one way or another I'm definitely a Julia convert now. Come for the community, stay for the multiple dispatch! [1] https://github.com/JuliaOpt/JuMP.jl

JuMP (https://github.com/JuliaOpt/JuMP.jl) for optimization is really nice and I don't think there is an equivalent this good in another language.

It's not mentioned in the article, but Julia was used to solve the huge optimization problem for this project—specifically, the JuMP optimization package [1]. This SIAM article has more technical detail: https://sinews.siam.org/Details-Page/a-school-bus-trip-to-th.... This seems to be a preprint of the paper that may describe the algorithm used in Boston, although it seems to talk more about the well-known New York taxi data set: http://web.mit.edu/~jaillet/www/general/travel-time-18.pdf. [1] https://github.com/JuliaOpt/JuMP.jl [2] http://www.nyc.gov/html/tlc/html/about/trip_record_data.shtm...

I think sometimes people are distracted by Julia's performance, according to https://github.com/JuliaLang/Microbenchmarks Julia is not the fastest language/compiler (maybe LuaJIT is). Julia is not only good for its performance, but also its multiple dispatch, its type system and more. Because of those features we have https://github.com/JuliaGPU/CUDAnative.jl, more elegant package interface, like https://github.com/JuliaOpt/JuMP.jl and there is more. I still believe there is no silver bullet, if you want something Python then you get another Python. But think about this: is the full Python's dynamic feature really what we need in works like simulation, HPC, etc.? Probably no. I think Julia is kinda of balance for the related field (like for scientific computing). Just like in the old days, people start using FORTRAN, MATLAB, Lisp as the m

JuMP, in Julia: https://github.com/JuliaOpt/JuMP.jl/blob/master/examples/bas... It's rapidly displacing proprietary DSL's like AMPL and GAMS in operations research. Neither of those happen to be embedded in a host language, they're special-purpose. Though there are comparable tools out there embedded in Python or Matlab, they don't perform as well as JuMP or the special-purpose tools.

I won't comment on organizations using Julia, but some conclusions can be drawn from the presenters and sponsors at JuliaCon 2015: http://juliacon.org/2015/ Here is a brief list of some major packages that I am aware of: - https://github.com/JuliaOpt/JuMP.jl - https://github.com/JuliaOpt/Convex.jl (Stephen Boyd's current and former students) - https://github.com/ApproxFun/ApproxFun.jl (Nick Trefethen's former students) - https://github.com/dmlc/MXNet.jl - http://nemocas.org Julia has been used (and cited) in at least one Nature publication: http://www.nature.com/nature/journal/v526/n7575/full/nature1... A larger list (with associated publications): http://julialang.org/publications/ Julia is also being used for courses at a number of universities: http://julialang.org/teaching/

The JuliaOpt / JuMP (Julia for Mathematical Programming) team has been responsive and supportive. When I file a Github issue at a random hour, they respond in minutes. The quality of code and testing is outstanding, and frankly for a project started in academia that's rare. In the dynamic world of pre-1.0 Julia, they've set the standard for 3rd party libraries, accommodated deprecations from the language immediately as versions change, and overall driven the advancement of scientific computing. https://github.com/juliaopt/jump.jl Edit: Here's a great example of the JuMP team debugging somebody's particular script, running it, and benchmarking it - all because somebody filed a Github issue. https://github.com/JuliaOpt/JuMP.jl/issues/614

> My other problem is code generation. I can't generate Julia code yet. Perhaps I am misunderstanding your meaning here, but Julia has a range of metaprogramming functionality including both Lisp-like macros, as well as "generated functions" that allow custom code specialization based on input type signatures (https://medium.com/@acidflask/smoothing-data-with-julia-s-ge...). These capabilities have been used for DSLs (e.g. https://github.com/JuliaOpt/JuMP.jl) and parser generation (e.g. https://github.com/abeschneider/PEGParser.jl).

If you're interested in model generation time, have a look at JuMP (https://github.com/JuliaOpt/JuMP.jl). More discussions on the speed of modeling languages at http://arxiv.org/abs/1312.1431 and http://arxiv.org/abs/1508.01982

Not sure they are on HN, but I know a few companies at least are using the JuliaOpt[1]/ JuMP[2] stack. [1]: http://juliaopt.org [2]: https://github.com/JuliaOpt/JuMP.jl

I wrote the solver code used here as an example for the JuMP modeling package for Julia, which is available at https://github.com/JuliaOpt/JuMP.jl. The specific TSP example code is available at https://github.com/JuliaOpt/JuMP.jl/blob/master/examples/tsp..., and more general information about optimization in Julia is available at http://juliaopt.org

An alternative is JuMP [1], a package for Julia. You can model optimization problems with linear, quadratic, and general nonlinear constraints/objective and send them to a variety of open-source and commercial solvers. JuMP, these solver wrappers, and more are all part of the JuliaOpt organization [2]. Once of the great things about JuMP is that it generates the internal/computer-friendly form for LPs/MILPs/MIQCQPs/... very quickly, as good as any commercial tool. If you are solving nonlinear problems, it'll generate first and second derivatives for you using automatic differentiation (see JuliaDiff for more on that [3]) [1]: https://github.com/JuliaOpt/JuMP.jl [2]: http://juliaopt.org [3]: http://juliadiff.org

One can easily use such solvers in Julia via an excellent modeling language, JuMP [1]. You can easily specify optimization problems in human readable form and have these passed to the solvers; speed is quite good. https://github.com/JuliaOpt/JuMP.jl