Installing Julia and VS Code – A Comprehensive Guide

Re-posted from: https://blog.glcs.io/install-julia-and-vscode

Julia is a relatively new,
free, and open-source programming language.
It has a syntax
similar to that of other popular programming languages
such as MATLAB and Python,
but it boasts being able to achieve C-like speeds.

One popular IDE to use with Julia
is Visual Studio Code,
or VS Code.

In this post,
we will learn how to install Julia and VS Code.
We will also learn how to configure VS Code
to get it to work with Julia.

The instructions for installing Julia and VS Code
vary by operating system.
Please use the table of contents
to jump to the instructions
that are relevant to you.
Note that the instructions for configuring VS Code
are the same for all operating systems.

Windows

Installing Julia

Go to https://julialang.org/downloads.
In the table under the heading
“Current stable release”,
go to the row labeled “Windows”
and click the “64-bit (installer)” link.
(Of course, click the 32-bit link
if you have a 32-bit machine.)

(See Installing a Specific Julia Version
for details on installing an older Julia version.)
Run the installer.
Choose where to install Julia.
(The default location works well
unless you have a specific need
to install Julia somewhere else.)
Then click “Next”.
Specify some additional options.
- “Create a Desktop shortcut”:
  Allows you to run Julia
  by clicking the shortcut
  on your Desktop.
- “Create a Start Menu entry”:
  Allows you to pin Julia to your Start Menu.
  Also allows you to easily search for Julia
  from the Start Menu.
- “Add Julia to PATH”:
  (Recommended)
  Allows you to run Julia
  from the command line
  without specifying the full path
  to the Julia executable.
  Also enables easier integration
  with VS Code.
Then click “Next”.
Installation is complete!
Click “Finish” to exit the installer.

Running Julia

There are a few different ways
to run Julia on Windows.

If you created a Desktop shortcut,
you can double-click the shortcut
to start Julia.
If you created a Start Menu entry,
you can run Julia from the Start Menu.
First search for “julia”.

And then click on the appropriate result
to start Julia.
You can also run Julia
from the command line
(Command Prompt or PowerShell).
If Julia was added to PATH,
you can run
```
C:\Users\user> julia
```
Otherwise,
you can specify the full (or relative) path.
```
C:\Users\user> .\AppData\Local\Programs\Julia-1.9.3\bin\julia.exe
```

After starting Julia
you will be greeted with
a fresh Julia prompt.

Fresh Julia prompt on Windows

Now you know how to install and run Julia on Windows!

Installing VS Code

Go to https://code.visualstudio.com.
Click “Download for Windows”.
Run the installer.
Click “I accept the agreement”
and then click “Next”.
Choose where to install VS Code.
(The default location works well
unless you have a specific need
to install VS Code somewhere else.)
Then click “Next”.
Specify the Start Menu folder for VS Code.
(The default folder is fine.)
Then click “Next”.
Specify additional options if desired.
(The defaults are fine,
but if you want a Desktop shortcut
be sure to select that option.)
Then click “Next”.
Click “Install”.
Installation is complete!
Click “Finish” to exit the installer.

Running VS Code

You can run VS Code
using any of the methods described above
for running Julia:

using the Desktop shortcut.
using the Start Menu.
using the command line.
```
C:\Users\user> code
```

Now you know how to install and run VS Code on Windows!

Jump to Configuring VS Code for Julia
to learn how to configure VS Code.

macOS

Installing Julia

Go to https://julialang.org/downloads.
In the table under the heading
“Current stable release”,
go to the rows labeled “MacOS”
and click the “64-bit (.dmg)” link for either Apple Silicon
or the Intel or Rosetta link for older machines or special scenarios.

(See Installing a Specific Julia Version
for details on installing an older Julia version.)
Open the downloads folder and double-click on the Julia Disk Image you just downloaded.
In the new window, drag Julia into the Applications folder.
Allow Julia to be copied with your credentials or Touch ID.
Eject the disk image, either with the eject button
or with right-click and selecting “Eject”.
We recommend you follow these final instructions
to make it easier to open Julia on your Mac.
Open a new terminal window and follow these instructions:
```
sudo mkdir -p /usr/local/bin
sudo rm -f /usr/local/bin/julia
sudo ln -s /Applications/Julia-1.9.app/Contents/Resources/julia/bin/julia /usr/local/bin/julia
```
Original source.

Running Julia

You can start Julia through your normal means of opening applications
or through typing julia into your terminal (if you did the last step above).
See Apple’s support if you need help.

After starting Julia
you will be greeted with
a fresh Julia prompt.

Fresh Julia prompt on macOS

Now you know how to install and run Julia on macOS!

Installing VS Code

Go to https://code.visualstudio.com.
Click “Download Mac Universal”.
Open the downloads folder and drag VSCode into the Applications folder.
Allow VSCode to be moved with your credentials or Touch ID.

You can start VS Code through your normal means of opening applications.

Now you know how to install and run VS Code on macOS!

Jump to Configuring VS Code for Julia
to learn how to configure VS Code.

Linux

Installing Julia

Go to https://julialang.org/downloads.
In the table under the heading
“Current stable release”,
go to the row labeled “Generic Linux on x86”
and click the “64-bit (glibc)” link.
(This link should work for most Linux systems.
If you have a different computer architecture,
you probably already know to choose a different download link.)

(See Installing a Specific Julia Version
for details on installing an older Julia version.)
Open a terminal
and navigate to the directory
where you want to install Julia.
In this post,
we will install Julia
in ~/programs/julia/.
(Note that everything up to and including the $
is the terminal prompt,
so the actual command to run
is everything after the $.)
```
~$ mkdir -p ~/programs/julia
~$ cd ~/programs/julia
```

Move the downloaded archive
to the current directory.

~/programs/julia$ mv ~/Downloads/julia-1.9.3-linux-x86_64.tar.gz .

Unarchive the file.

~/programs/julia$ tar xzf julia-1.9.3-linux-x86_64.tar.gz

Add Julia to your PATH
by adding the following
to your .bashrc or .zshrc file.
(Remember to change /home/user/programs/julia
to the directory where you installed Julia.)
```
export PATH="$PATH:/home/user/programs/julia/julia-1.9.3/bin"
```
(Restart the terminal to actually update the PATH.)

Julia is now installed!

Running Julia

You can run Julia from the command line.

$ ~/programs/julia/julia-1.9.3/bin/julia

Or, if you added Julia to your PATH:

$ julia

After starting Julia
you will be greeted with
a fresh Julia prompt.

Fresh Julia prompt on Linux

Now you know how to install and run Julia on Linux!

Installing VS Code

The following steps were tested
on a computer running Ubuntu.
They should work as written
for any Debian-based Linux distribution,
but modifications may be necessary
for other Linux distributions.
Note that you will need admin privileges
for one of the steps below.

Go to https://code.visualstudio.com.
Click ” .deb”.
(Requires admin privileges)
Either open your file manager
and double-click the downloaded file,
or install VS Code
via the command line.
(Remember to change the file path/name as needed.)
```
$ sudo dpkg -i /home/user/Downloads/code_1.81.1-1691620686_amd64.deb
```

VS Code is now installed!

Running VS Code

You can run VS Code from the command line.

$ code

Now you know how to install and run VS Code on Linux!

Jump to Configuring VS Code for Julia
to learn how to configure VS Code.

Installing a Specific Julia Version

If you need a specific version of Julia,
you can navigate to the older releases page
and find the appropriate installer
for the version you need.
For example,
to install Julia 1.0.5 on Windows,
you would find “v1.0.5” on the left column
and then click on the download link
to download the installer.

Installing Julia 1.0.5

Otherwise,
the installation instructions
should be basically the same.

Configuring VS Code for Julia

After starting VS Code
for the first time
you will be greeted with
“Get Started with VS Code”.

Get Started with VS Code

Feel free to walk through the options,
but for this post
we will ignore them
and just click “< Welcome”
on the top left of the window.
That brings us to the welcome page.

VS Code welcome page

We need to install the Julia extension for VS Code.

Click on the extensions button.
Search for “julia”.
Click “install” on the Julia extension.

Now we need to make sure
the Julia extension knows where Julia is installed.
If you added Julia to PATH,
this step can be skipped.
However,
if you get errors trying to run Julia in VS Code
or if you find the wrong Julia version is being used
(if you have multiple versions installed),
you can follow these steps.

Open the Julia extension settings
by clicking the settings icon.
Click “Extension Settings”.
Search for “executable path”.
Then type the path to the Julia executable
in the “Julia: Executable Path” extension setting.

Now VS Code is ready for Julia development!

Developing Julia Code in VS Code

Click the file icon in the top left
to open the Explorer pane.
Then click “Open Folder”.
Navigate to a folder
(or create one)
where your Julia code will be saved.
In this post,
we created a folder called Julia.
Click the “New File” button
next to the folder in the Explorer pane.
Then type a name for the file
where you will write Julia code.
It should have a .jl extension.
In this post,
we created a file called script.jl.

VS Code will now open a new tab
with a blank file
ready for us to edit.
Add the following code to your file
and then save it.
```
println("Hello, World!")
```
To run the code,
place your cursor on the line of code to execute
and then press Shift+Enter.
This command will start a Julia session
(if one has not already been started)
and then run the code.
(The very first time you run code
may take a little while
because packages need to precompile.)

Now add more lines of code.

function plus1(x)
    x + 1
end

a = 3
b = plus1(a)

b == a + 1

To run all the code in the file,
open the command palette
with Ctrl+Shift+P
and search for
“Julia: Execute active file in REPL”.
Highlight the command and press Enter.

Note that two lines of output
were added to the REPL:
the println statement
and the value of b == a + 1
(the last line that was executed).
Now that some code has run,
we can look at the Julia pane
on the left
and see the variables and function we defined
in the “Workspace” tab.
We can also use the REPL directly.

And now you know how to write and run Julia code
in VS Code!

If you would like to see more tips and tricks
for how to use Julia in VS Code,
be sure to comment below!

Summary

In this post,
we learned how to install Julia
and VS Code
on different operating systems.
We also learned how to configure VS Code
for developing Julia code.

Once you have installed Julia,
move on to the
next post to learn about variables and functions!
Or,
feel free to take a look
at our other Julia tutorial posts!

Dropping columns from a data frame

By: Blog by Bogumił Kamiński

Re-posted from: https://bkamins.github.io/julialang/2023/09/08/dropcols.html

Introduction

One of the common tasks when working with a data frame is dropping some of its columns.
There are two ways to do it. You can either specify
which columns you want to keep or which columns you want to drop.

One of the frequent questions I get is how to do these operations with
[DataFrames.jl][tables] in case the list of columns to keep or drop might not
be a subset of columns of the data frame. This is the topic I want to cover in my today’s post.

The post was tested using Julia 1.9.2 and DataFrames.jl 1.6.1.

Standard column selection

First, create an example data frame:

julia> using DataFrames

julia> df = DataFrame(a=1, b=2, c=3, d=4)
1×4 DataFrame
 Row │ a      b      c      d
     │ Int64  Int64  Int64  Int64
─────┼────────────────────────────
   1 │     1      2      3      4

Now assume I want to keep columns :a and :c from it. You can do it by writing, for example:

julia> select(df, :a, :c)
1×2 DataFrame
 Row │ a      c
     │ Int64  Int64
─────┼──────────────
   1 │     1      3

You could also pass the columns as a variable using e.g., a vector:

julia> keep1 = [:a, :c]
2-element Vector{Symbol}:
 :a
 :c

julia> select(df, keep1)
1×2 DataFrame
 Row │ a      c
     │ Int64  Int64
─────┼──────────────
   1 │     1      3

Now, let us discuss dropping columns. Assume we want to keep all columns except columns :b and :d.
We can achieve this by using the Not command:

julia> select(df, Not(:b, :d))
1×2 DataFrame
 Row │ a      c
     │ Int64  Int64
─────┼──────────────
   1 │     1      3

Also in this case we can use a helper variable:

julia> drop1 = [:b, :d]
2-element Vector{Symbol}:
 :b
 :d

julia> select(df, Not(drop1))
1×2 DataFrame
 Row │ a      c
     │ Int64  Int64
─────┼──────────────
   1 │     1      3

The problematic case: the selected column is not present in a data frame

In some scenarios, we might want to provide a list of columns of which not
all are present in the data frame. For example, assume we want to keep
columns :a and :x. We see that the :x column is not present in our
df data frame.

Before we move forward, let me comment when such a situation occurs most often.
Assume you have 100 data frames that describe your data. Each data frame is similar,
but not identical. For example, a single data frame might represent data from one country
and the list of information for the countries does not have to be identical (for some
countries we might have more information, which results in more columns in a data frame).
When processing such data we might want to write one general condition on which columns
we want to keep or drop, and some of these columns might be present in only a subset of
all data frames.

Now let us go back to our example. Let us try keeping columns :a and :x:

julia> select(df, :a, :x)
ERROR: ArgumentError: column name "x" not found in the data frame; existing most similar names are: "a", "b", "c" and "d"

julia> keep2 = [:a, :x]
2-element Vector{Symbol}:
 :a
 :x

julia> select(df, keep2)
ERROR: ArgumentError: column name "x" not found in the data frame; existing most similar names are: "a", "b", "c" and "d"

We get an error. DataFrames.jl is designed to check, by default, that the operation you want to perform
on your data frame is valid. This is a conscious design decision. The reason is that in production application
settings most often when you say that you want to keep columns :a and :x you assume that they are present in df.
Thus you want to get an error if they would not be all present in it.

The same behavior can be observed for dropping columns. Assume we want to drop columns :b and :x:

julia> select(df, Not(:b, :x))
ERROR: ArgumentError: column name "x" not found in the data frame; existing most similar names are: "a", "b", "c" and "d"

julia> drop2 = [:b, :x]
2-element Vector{Symbol}:
 :b
 :x

julia> select(df, drop2)
ERROR: ArgumentError: column name "x" not found in the data frame; existing most similar names are: "a", "b", "c" and "d"

So what we saw here is a default behavior that was designed to be safe.
In what follows let me discuss how to perform a flexible selection.

Performing column selection when some of them are not present in a data frame

There are several solutions for column selection when some of them are not present in a data frame.
Let me present the one that I find the most convenient.
For this operation I typically use the Cols selector. The reason is that you can pass
a condition function (a predicate) as an argument to Cols that will select columns
whose names meet a passed condition.

Therefore the following operation:

julia> select(df, keep1)
1×2 DataFrame
 Row │ a      c
     │ Int64  Int64
─────┼──────────────
   1 │     1      3

Is the same as:

julia> keep1s = string.(keep1)
2-element Vector{String}:
 "a"
 "c"

julia> select(df, Cols(in(keep1s)))
1×2 DataFrame
 Row │ a      c
     │ Int64  Int64
─────┼──────────────
   1 │     1      3

Note what we did here. The in(keep1s) expression produces a function that checks if a value passed to it is in the keep1s vector.
It is important to note that although column selection in DataFrames.jl accepts both Symbol (like :a) and strings (like "a")
as column names the Cols-based selector will perform the check against strings. Therefore I had to convert the keep1 vector
of symbols to a keep1s vector of strings.

So far the select(df, Cols(in(keep1s))) is more verbose than just writing select(df, keep1). However, the benefit of Cols
is that when the in(keep1s) check is done we can have in keep1s vector whatever values we like, in particular,
they do not have be valid column names of our df.

Therefore to keep columns :a and :x, if we are unsure if these columns are present in df we can write:

julia> select(df, Cols(in(["a", "x"])))
1×1 DataFrame
 Row │ a
     │ Int64
─────┼───────
   1 │     1

Note that this time the operation works without an error. And again, please keep in mind that in this selector we need to pass
column names as strings.

Now you can probably already tell how to pass a list of columns to drop, without requiring that they are present in df.
The only thing to do is to use the !in function (not-in) instead of in. Let us drop columns :b and :x from our
data frame (keeping in mind that :x is not present in it):

julia> select(df, Cols(!in(["b", "x"])))
1×3 DataFrame
 Row │ a      c      d
     │ Int64  Int64  Int64
─────┼─────────────────────
   1 │     1      3      4

All worked as expected – the :b column was dropped and the :x column was ignored in the column dropping operation.

Conclusions

I hope you find the examples I gave today useful.

In general, the whole design of DataFrames.jl is similar to
what was discussed in this post. The default behavior is picked to be safe (as in our example: by default,
select checks if the columns you pass are present in a data frame), but it is possible to switch to an unsafe
mode relatively easily (in our example: using Cols with a predicate function).

Best Frenemies: Julia and Python

By: julia on Abel Soares Siqueira

Re-posted from: https://abelsiqueira.com/blog/2023-09-05-best-frenemies-julia-and-python/

Julia and Python are often seen as competitors, but in this video I want to show the integration between them. Using the PythonCall and the JuliaCall packages we can call Julia from Python and Python from Julia.
Check the video out or check edited transcript below.

Don’t forget to like and subscribe.

Download the python-from-julia.jl Pluto notebook.

Download the julia-from-python.ipynb Jupyter notebook.

There are currently two ways to integrate Python in Julia and Julia in Python. These two main packages are PyCall and PythonCall and their corresponding Python package.
I have talked about PyCall in a series of blog posts in the past, comparing Python being improved by C++ and Python being improved by Julia up to the point that we actually made the Julia code faster than the C++ code in this specific instance.
Now I’m going to talk about the PythonCall package and the corresponding JuliaCall package which are newer.

juliabloggers.com

A Julia Language Blog Aggregator

Installing Julia and VS Code – A Comprehensive Guide

Windows

Installing Julia

Running Julia

Installing VS Code

Running VS Code

macOS

Installing Julia

Running Julia

Installing VS Code

Linux

Installing Julia

Running Julia

Installing VS Code

Running VS Code

Installing a Specific Julia Version

Configuring VS Code for Julia

Developing Julia Code in VS Code

Summary

Dropping columns from a data frame

Introduction

Standard column selection

The problematic case: the selected column is not present in a data frame

Performing column selection when some of them are not present in a data frame

Conclusions

Best Frenemies: Julia and Python