Hi All,
until 0.6 I had a file in ~/.julia/v0.6 named REQUIRE with a list of packages I want. Pkg.update would automagically look up the list and keep stuff up to date, or, actually install stuff I had added to the list. This approach is not working for me on 0.7. How do I proceed? I just use julia in a shell.
Also, I noticed there a package manager I can call up with ] – how do I get out of it (short of ctrl-C)?
Backspace.
Are you doing Pkg.update() or are you using the PKG REPL and typing update? The later is more straightforward, but if you want to keep doing the former I think doing using Pkg before hand works.
Also, check out the juliacon video about the new package manager - it clarified a lot of things for me.
I am using Pkg.update(). I should have mentioned I created ~/.julia/v0.7 with the same REQUIRE file in it (i.e. I have ~/.julia/v0.7/REQUIRE), but using Pkg followed by Pkg.update() does not install any of the packages in the list (which might be in the wrong pace?). Thanks anyway!
Oh, I see. This might be the sort of thing that is now handled by a Manifest file, but I’m not sure. A hack you could try is to make a dummy module and put the REQUIRE file in it. Then ] dev "path/to/dummy". I think that will work?
From the manual a Manifest file would need me to specify the version of each package, so it might work, but it would defeat my goal of automagically tracking and keeping stuff to the latest version. I will look into making a module – hopefully that will sort things globally and not just make a locale that needs regeneration every time. Thanks for your suggestions!
Right, but you can do ] up and upgrade anything that’s not pinned. This also modifies the Manifest (I’m pretty sure). I think the goal is that you wouldn’t usually make the Manifest by hand, but if you do ] add MyPackage it puts the current version of MyPackage into the Manifest. That doesn’t stop you from upgrading it.
In fact, you can do:
(v0.7) pkg> activate NewEnv
[ Info: new environment will be placed at /Users/kev/julia/NewEnv
julia> using Pkg
julia> for p in readlines(expanduser("~/.julia/v0.6/REQUIRE")
Pkg.add(p)
end
And it will install all the packages in your v0.6 REQUIRE file and build a manifest.
Edit: note that the ] activate NewEnv isn’t strictly necessary, if you just leave it in the base v0.7 environment it’ll work too
Thanks, it did work, though it strikes me as a substantially more complicated way of doing stuff that I would have hoped for (I did not activate a new environment btw).
I’ve thought this about a few things, but if you think about it not from the perspective of moving from the old system, but a new user starting from scratch, I think it makes a lot of sense. I’m guessing a lot of the stuff in your REQUIRE file came from doing Pkg.add at some point. The new manifest is no different, except that it preserves exact state.
If you were using git to track your REQUIRE file and jumped back 2 months, it might not have changed even as all of the packages were updated. So if you go back and try to use code you wrote 2 months ago, there’s no way to know if it will work or why it broke.
You are giving me far too much credit in terms of how much effort and knowledge I bother to put in managing julia and packages (close to 0 if I can get away with) – I am in fact one of those people with 0 interest in development (i.e. a ‘pure user’). I just want to use the language with the least amount of effort an hassle. In fact it would be simple for me to reinstall from 0 julia and packages (provided it is straightforward and requires little effort – reinstalling julia was, the packages less so) than to have to figure out how to migrate. I do not mean this to be a rant, but as much as all this stuff gives lots of power to developers it is also a non welcome complication to me (and possibly other people with my same usage goals).
Give JuliaPro a shot: it should come fully loaded for casual use.
I did in fact look at JuliaPro a few months ago, but I just found it too much – I just want to open a terminal, type julia and be done. In 0.6.x the way to manage packages was simple, elegant and required the least amount of hassle. I do get that development breaks stuff and that developer need a fine grained control, but I am not a developer and I do not care. I do not want to develop julia, I just want to use it. Managing it is a chore I accept, but I like small chores.
I think we’re at an awkward point for that, because the update from 0.6 to 0.7 and eventually 1.0 changed a lot of thing. Package developers and maintainers are scrambling, with different levels of success, to patch and update their packages and a lot of things are not working smoothly in 0.7. So, I understand your pain, but that phase should pass and your wish to just download and use should happen. I’m also a “pure user”, although I might have more interest than you in developing, but I believe everybody wants to get to the point you want. This is, in essence, a business and the creators do want to benefit from all their work. And they realize a seamless user experience for new users is very important.
Add the packages you want with Pkg.add("..."). Support for REQUIRE as in .julia/v0.x does not exit.
It needs to be clearer somehow that people should not be modifying the Manifest file.
Do not get me wrong, if there is a different way of getting what I want I am happy to learn it – what I find a bit off-putting is that I see a highly complex, fine grained, powerful and yet complicated and incomprehensible new approach that does every thing under the sun but does not give me a simple straightforward line ‘if you do not care and just want your packages do X’. At the risk of mentioning the competition, in R I just have one version, and one straightforward way to install packages with their dependencies. Is this great for developers? I would not know. Possibly not. But it is straightforward.
It is literally what one did in 0.6 so not sure what the problem is.
You only need to add packages once. Once they are installed doing Pkg.update() will still track your packages and update all to a more recent version, if available.
If you want to use the REQUIRE file you already have just do
using Pkg
for p in readlines(homedir()*"/.julia/v0.7/REQUIRE")
Pkg.add(p)
end
But then you should just add any other package you want through the terminal, not through the REQUIRE file.
This is not what I did. As I said above, I had ~/.julia/v0.6/REQUIRE specifying what to add and keep up to date, and all I used to do was Pkg.update() which would read REQUIRE, keep stuff up to date and add stuff that I added to the REQUIRE list.
Every package that you once Pkg.added will be updated when you do Pkg.update(), the only change you have to make on your “workflow” is, instead of adding new packages to the REQUIRE list, you should now open a julia session and Pkg.add that pkg.