Yet again, it sounds like the Julia website could greatly benefit from having a generic open source / free software tutorial video, which explains how to work with git and how to best interact with the rest of the julia community.
Most new users at this point will not have the necessary background, and their transition would be greatly accelerated by having this standard tutorial on the main julia homepage.
This would help eliminate some of the redundancy on the discourse and assist when introducing collaborators to julia workflow.
This 100%. Even having persistent discussions about changes to the text and results of a paper is enormously helpful. It can ensure PIs are on the same page with a change and that results arenât jumping around more than they ought to with small refinements. A selling point of Julia could be that this kind of way more effective collaboration is easy and built into the language.
Sorry if this a bit off topic, but Iâd be really interested in what your tests look like for these kinds of models. Like, I have a really good sense of how to write unit tests for packages that are mostly tooling, but I am often a little lost on what they should look like when most of the code is written for an iterative method.
The code will (of course) be public when the paper is published, but think of eg the following:
equilibrium conditions hold (in a numerically approximate sense) for the numerically obtained solution,
for value functions, you can simulate paths and get discounted present value, and compare,
transition matrices (for simulating a discretized model) sum to 1 (amazing what that uncovers ), also compare to toy 2x2 versions,
analytically calculated moments are roughly equal to simulated versions (when we have both).
a bunch of @inferred peppered through the tests (we want speed, changes should keep the compiler happy).
It is not really that different from any other kind of code. Initially, it is kind of hard to think of invariants you want to maintain and toy versions of your model to solve, but it becomes kind of a habit. Also, simplified versions of the model are super-useful for presentations.
While I agree that git or other version control is the long-term way to go for scientific research, itâs a pretty high barrier for somebody whoâs new to programming and might feel overwhelmed by having to learn programming, a new language, and git. Even if they know (some) programming, needing to learn git gives Julia a much higher learning curve than Python or Matlab (which are its main competitors if theyâre a non-CS trained engineer like me).
I also donât think learning git is strictly necessary to be able to use Julia for throwaway scripts. It shouldnât be too hard to teach people a simple Revise-based workflow in which they open a REPL, import packages needed by their script directly in the REPL session, includet their script, then just call the __main__() function from their script, edit as needed, save, call it again and repeat as necessary. It may take them 10 minutes to get used to but it will quickly feel as easy as writing a script in Python. Then, after theyâve discovered how nice Julia is, it will be easier to show them âMy actual workflow looks like this, because I use git and unit tests. Unit tests help you prove that small a piece of code does what you think it does, and git helps you keep track of changes over time.â
Then again, these are just my thoughts based on how I like to learn new things, and I actually havenât yet needed to teach anybody else to use Julia.
I think learning Julia + git (CI is kind of thrown in, itâs more of a habit ) is for someone who knows how to program already (in any language), and is somewhat computer-savvy (power user level, can install programs, interpret an error message, follow a tutorial).
I donât think anyone would suggest that someone who is learning programming as something new start with all this. But for those people, I may not recommend Julia anyway â it is possible to learn as a first programming language, but a lot of the details just wonât make sense for a while.
Julia was ranked 6th in âthe most loved languagesâ in this yearâs stack overflow developerâs survey. Just mentioning as I didnât see anyone mentioning this here or elsewhere. Julia was ranked after Rust, TypeScript, Python, Kotlin and Go.
), also compare to toy 2x2 versions,