daviddoji/CalculusWithJuliaNotes.jl
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

working on bulid

Browse Source
This commit is contained in:
jverzani
2022-05-25 19:16:51 -04:00
parent d9851a154d
commit b70aa08242
10 changed files with 316 additions and 320 deletions
Download Patch File Download Diff File Expand all files Collapse all files

59
CwJ/misc/julia_interfaces.jmd
View File

@@ -8,7 +8,7 @@ nothing
```
`Julia` can be used in many different manners. This describes a few.
`Julia` can be used in many different manners. This page describes a few.
## The `REPL`
@@ -38,6 +38,14 @@ The REPL has many features for editing, for interacting with the package manager
The `Pluto` package provides a notebook interface for interacting with `Julia`, which has a few idiosyncrasies, as compared to other interfaces.
Pluto is started from the REPL terminal with these two commands:
```julia; eval=false
using Pluto
Pluto.run()
```
Primarily, the variables in the notebook are **reactive**, meaning if a variable's value is modified, all references to that variables are also modified. This reactive nature makes it very easy to see the results of slight modifications and when coupled with HTML controls, allows easy user interfaces to be developed.
As a result, a variable name may only be used once in the top-level scope. (Names can be reused inside functions, which create their own scope and in "`let`" blocks, a trick used within these notes.) In the notes, subscripting and unicode variants are used for symbols which are typically repurposed (e.g., `x` or `f`).
@@ -46,18 +54,24 @@ Pluto cells may only contain one command, the result of which is displayed *abov
Pluto has a built-in package management system that manages the installation of packages on demand.
The sections presented as `Pluto` notebooks can be easily run locally using `Pluto`.
`Pluto` notebooks can be easily run locally using `Pluto`.
`Pluto` notebooks are just `.jl` scripts, so can easily be shared.
## `IJulia`
"Project [Jupyter](https://jupyter.org/) exists to develop open-source software, open-standards, and services for interactive computing across dozens of programming languages." The `IJulia` package allows `Julia` to be one of these programming languages. This package must be installed prior to use.
The Jupyter Project provides two web-based interfaces to `Julia`: the Jupyter notebook and the newer JupyterLab. The [juliabox](https://www.juliabox.com/) project and the [binder](https://mybinder.org/) project use Juptyer notebooks for their primary interface to `Julia`.
The Jupyter Project provides two web-based interfaces to `Julia`: the Jupyter notebook and the newer JupyterLab. The the [binder](https://mybinder.org/) project use Juptyer notebooks for their primary interface to `Julia`. To use a binder notebook, follow this link:
If not installed, these interfaces are available once `IJulia` is installed. The following command should do this:
[lauch binder](https://mybinder.org/v2/gh/CalculusWithJulia/CwJScratchPad.git/master)
To run locally, these interfaces are available once `IJulia` is installed. Since version 1.7, the following commands should do this:
```julia; eval=false;
] add IJulia
using IJulia
notebook()
```
Should that not work, then this should as well:
@@ -73,14 +87,6 @@ Pkg.add("IJulia")
The notebook interface has "cells" where one or more commands can be entered.
```julia; echo=false;
#ImageFile("figures/julia-jupyter.png")
nothing
```
The notes have blocks of commands, as though they are entered in a notebook.
In `IJulia`, a block of commands is sent to the kernel (the `Julia` interpreter) by typing "shift+return" or clicking on a "run" button. The output is printed below a cell, including graphics.
@@ -100,29 +106,8 @@ If the kernal appears unresponsive, it can be restarted through a menu item of
Notebooks can be saved (as `*.ipynb` files) for sharing or for reuse. Notebooks can be printed at HTML pages, and if the proper underlying software is available, as formatted pages.
----
JupyterLab, a variant, has more features, commonly associated with an integrated development environment (IDE).
JupyterLab has more features, commonly associated with an integrated development environment (IDE).
## VSCode
```julia; echo=false
#ImageFile("figures/julia_jupyterlab.png")
nothing
```
The figure shows a notebook and a menubar in the side menu. In addition to notebooks, JupyterLab offers the change to edit source files, for example, for project development.
----
For an integrated development environment, where many features for project development are included, there are two powerful ones being developed for `Julia` that leverage various free-to-use projects.
### Juno
[Juno](https://junolab.org/) is a powerful, free environment for the Julia language. Juno is based on the cross-platform, javascript-based [Atom](https://atom.io/) editor and provides interfaces for the repl, graphics, help pages, debugging, project management, etc. Atom was developed by GitHub, since acquired by Microsoft.
### VSCode
The [VS Code](https://github.com/julia-vscode/julia-vscode) extension provides support for the julia programming language for [VS Code](https://code.visualstudio.com/). VS Code is an open-sourced code editor supported by Microsoft. Similar to `Juno`, VS Code provides a cross-platform interface to `Julia` geared towards programming within the language.
[Julia for Visual Studio Code](https://www.julia-vscode.org/) provides support for the julia programming language for [VS Code](https://code.visualstudio.com/). VS Code is an open-sourced code editor supported by Microsoft. VS Code provides a cross-platform interface to `Julia` geared towards programming within the language.