Hi, I’ve used Julia about one year and I still struggle with how to use it. First of all, as a researcher, I often change my code including code structure and Julia types. When redefining types, Julia REPL needs to be restarted and I should spend quite a long time for precompilation. In my experience, the actual development speed is fast only for almost-completed codes. For some projects on progress, I always restart and precompile the whole code, which is so annoying. What’s the best practice for often changed codes? Note: I usually create my own package and add almost every functionality in the package for each project. Also, I use Revise.jl.

Some options to deal with the problem of Revise not being able to track type changes are discussed in some threads. For example: [image] Workflow when experimenting with types New to Julia Hi all, longtime lurker and irregular Julia user here. Revise is absolutely great and I love it but I wonder if there’s a better workflow when experimenting with types. I try to get my types defined ASAP but especially in the beginning, when taking a stab at a particular problem I frequently find myself changing definitions. Currently I just restart the interactive in order to reload Revise and my type definitions but I feel like I’m doing something wrong or that there might be a better way. H…

Well, I don’t think it is a cool solution. It sounds like, I have to replace all structs to NamedTuple for often-changed codes. Of course, struct may not be changed frequently when the development becomes mature. Ironically, if the project becomes mature and huge, precompilation would take a long time when I realise that the struct should be changed. EDIT: Apart from Revise, is it impossible to enable type redefinition in Julia in principle? It would be really great if someone tells me something about this functionality :slight_smile:

Theoretically in the future, revise should be able to support this. The hard part is figuring out what to do with the old type. If you have variables that are of the old type, do you delete them? What about specialized functions?

I don’t know how to “delete” certain objects. When I’ve searched it, many people recommended to just restart REPL, but my memory might be wrong. If you don’t mind, can you describe what you meant in detail? For instance, with an example. And I really hope that Revise once supports this functionality.

Here’s the basic problem. Suppose I define struct Foo x::Float64 end bar = Foo(1.0) baz(x::Foo) = Foo(x.x -1.0) If I now redefine Foo as struct Foo y::Int end what happens when I try to call baz(bar)?

Well, I’ve tried it but encountered the redefinition error. First, run the following (by include("the_file_name.jl"). ## Type redefinition test struct Foo x::Float64 # y::Int end bar = Foo(1.0) baz(x::Foo) = Foo(x.x - 1.0) @show baz(bar) and changed the code to the following and re-run it. ## Type redefinition test struct Foo x::Float64 # y::Int end bar = Foo(1.0) baz(x::Foo) = Foo(x.x - 1.0) @show baz(bar) It gives julia> include("test/tmp.jl") ERROR: LoadError: invalid redefinition of constant Foo Stacktrace: [1] top-level scope @ ~/.julia/dev/MyPackage/test/tmp.jl:2 [2] include(fname::String) @ Base.MainInclude ./client.jl:444 [3] top-level scope @ REPL[1]:1 in expression starting at /Users/jinrae/.julia/dev/MyPackage/test/tmp.jl:2

Sorry for the confusion, my point wasn’t describing something that currently works. It was about what would happen if redefinition were supported. Basically, it’s unclear how redefinition should behave, so it currently errors.

My approach: Don’t use types for “interactive” coding unless you really have to. I’ve come to appreciate that the types provided by Base / other people’s packages are sufficient much more often than one might think. If you do have to create your own types, put them into a module MyModule and don’t do using MyModule. Instead, either introduce an abbreviation M = MyModule and type M.my_func() while prototyping, or do something like in the following MWE: julia> # Initial definition module MyModule export MyType struct MyType x::Int end end; julia> module Foo using ..MyModule @show MyType(1) end; MyType(1) = Main.MyModule.MyType(1) julia> # Redefinition module MyModule export MyType struct MyType x::Float64 end end; WARNING: replacing module MyModule. julia> module Foo using ..MyModule @show MyType(1) end; WARNING: replacing module Foo. MyType(1) = Main.MyModule.MyType(1.0) # Look ma, I changed Int to Float64!

Another option if you don’t like named tuples is to just call your struct MyStruct_1 and if you need to change it, do a find replace on your code base to Mystruct_2.

One slightly simpler version of this is to use something like MyStruct=MyStruct_1, and then you can redefine what struct MyStruct is an alias of.

What's the best practice in Julia for research (often changed codes)?

General Usage

lmiq April 9, 2021, 12:55am 2

Some options to deal with the problem of Revise not being able to track type changes are discussed in some threads. For example:

Topic		Replies	Views
Thoughts and tempering expectations on redefining structs Internals & Design struct	58	3229	July 12, 2023
Revise not updating functions Tooling revise	12	863	January 8, 2024
Redefining structs without restart? Internals & Design	53	7114	November 26, 2020
Advice for dealing with `struct` during development New to Julia	21	4490	April 11, 2021
[ANN] Higher productivity (fewer Julia restarts) with Revise.jl Community package , announcement , productivity , development	52	9116	April 30, 2018

What's the best practice in Julia for research (often changed codes)?

Related topics