.. _man-workflow-tips:

***************
 Workflow Tips
***************

Here are some tips for working with Julia efficiently.

REPL-based workflow
-------------------

As already elaborated in :ref:`man-interacting-with-julia`, Julia's
REPL provides rich functionality that facilitates an efficient
interactive workflow. Here are some tips that might further enhance your
experience at the command line.

A basic editor/REPL workflow
~~~~~~~~~~~~~~~~~~~~~~~~~~~~

The most basic Julia workflows involve using a text editor in
conjunction with the ``julia`` command line. A common pattern includes
the following elements:

 - **Put code under development in a temporary module.** Create a file,
   say ``Tmp.jl``, and include within it ::

       module Tmp

       <your definitions here>

       end

 - **Put your test code in another file.** Create another file, say
   ``tst.jl``, which begins with ::

       import Tmp

   and includes tests for the contents of ``Tmp``. The value of using
   :obj:`import` versus :obj:`using` is that you can call :obj:`reload`
   ``("Tmp")`` instead of having to restart the REPL when your
   definintions change. Of course, the cost is the need to prepend
   ``Tmp.`` to uses of names defined in your module. (You can lower that
   cost by keeping your module name short.)

   Alternatively, you can wrap the contents of your test file in a
   module, as ::

       module Tst
           using Tmp

           <scratch work>

       end

   The advantage is that you can now do :obj:`using` ``Tmp`` in your
   test code and can therefore avoid prepending ``Tmp.`` everywhere.
   The disadvantage is that code can no longer be selectively copied
   to the REPL without some tweaking.

 - **Lather. Rinse. Repeat.** Explore ideas at the ``julia`` command
   prompt. Save good ideas in ``tst.jl``. Occasionally
   restart the REPL, issuing ::

       reload("Tmp")
       include("tst.jl")

Simplify initialization
~~~~~~~~~~~~~~~~~~~~~~~

To simplify restarting the REPL, put project-specific initialization
code in a file, say ``_init.jl``, which you can run on startup by
issuing the command::

    julia -L _init.jl

If you further add the following to your ``.juliarc.jl`` file ::

    isfile("_init.jl") && require("_init.jl")

then calling ``julia`` from that directory will run the initialization
code without the additional command line argument.

Browser-based workflow
----------------------

It is also possible to interact with a Julia REPL in the browser via IJulia_. See the package home for details.

.. _IJulia: https://github.com/JuliaLang/IJulia.jl
