- Expanding Expression Tool Manual Online
- Expanding Expression Tool Manual 2016
- Expanding Expression Tool Manual Software
For the past year, I kept hearing about this fabulous therapy tool that folks kept referring to as the EET. What in the world? I did some research and found out that the EET, or Expanding Expression Tool, is a tool to use as a multi-sensory approach to language therapy, specifically targeting oral and written language.
The Expanding Expression Tool Kit (EET) is a multi-sensory program designed to improve oral and written language. Ideal for speech-language pathology sessions to expand word choice, keep students on topic, reduce the need for prompting, and improve organization and comprehension. Sand flies are the vectors of Leishmania parasites. To develop in the sand fly midgut, Leishmania multiplies and undergoes various stage differentiations giving rise to the infective form, the metacyclic promastigotes. To determine the changes in sand fly midgut gene expression caused by the presence of Leishmania, we performed RNA-Seq of uninfected and Leishmania infantum-infected Lutzomyia.
Julia enables package developers and users to document functions, types and other objects easily via a built-in documentation system since Julia 0.4.
- Tool/Output Please submit outreach, education, and translation materials that your program has created to the PEPH Resource Center at. If you need account access to the PEPH Resource Center, or have questions about the Resource Center, please contact Sara Amolegbe ( [email protected] ) 919-213-4906.
- Using the Expanding Expressions Tool (EET) in Speech Therapy In this video, speech-language pathologist Carrie Clark discusses the EET tool (expanding expressions tool) and how it can be used in speech therapy.
The basic syntax is simple: any string appearing at the toplevel right before an object (function, macro, type or instance) will be interpreted as documenting it (these are called docstrings). Note that no blank lines or comments may intervene between a docstring and the documented object. Here is a basic example:
Documentation is interpreted as Markdown, so you can use indentation and code fences to delimit code examples from text. Technically, any object can be associated with any other as metadata; Markdown happens to be the default, but one can construct other string macros and pass them to the
@doc
macro just as well.Markdown support is implemented in the
Markdown
standard library and for a full list of supported syntax see the documentation.Here is a more complex example, still using Markdown:
As in the example above, we recommend following some simple conventions when writing documentation:
- Always show the signature of a function at the top of the documentation, with a four-space indent so that it is printed as Julia code.This can be identical to the signature present in the Julia code (like
mean(x::AbstractArray)
), or a simplified form. Optional arguments should be represented with their default values (i.e.f(x, y=1)
) when possible, following the actual Julia syntax. Optional arguments which do not have a default value should be put in brackets (i.e.f(x[, y])
andf(x[, y[, z]])
). An alternative solution is to use several lines: one without optional arguments, the other(s) with them. This solution can also be used to document several related methods of a given function. When a function accepts many keyword arguments, only include a<keyword arguments>
placeholder in the signature (i.e.f(x; <keyword arguments>)
), and give the complete list under an# Arguments
section (see point 4 below). - Include a single one-line sentence describing what the function does or what the object represents after the simplified signature block. If needed, provide more details in a second paragraph, after a blank line.The one-line sentence should use the imperative form ('Do this', 'Return that') instead of the third person (do not write 'Returns the length...') when documenting functions. It should end with a period. If the meaning of a function cannot be summarized easily, splitting it into separate composable parts could be beneficial (this should not be taken as an absolute requirement for every single case though).
- Do not repeat yourself.Since the function name is given by the signature, there is no need to start the documentation with 'The function
bar
...': go straight to the point. Similarly, if the signature specifies the types of the arguments, mentioning them in the description is redundant. - Only provide an argument list when really necessary.For simple functions, it is often clearer to mention the role of the arguments directly in the description of the function's purpose. An argument list would only repeat information already provided elsewhere. However, providing an argument list can be a good idea for complex functions with many arguments (in particular keyword arguments). In that case, insert it after the general description of the function, under an
# Arguments
header, with one-
bullet for each argument. The list should mention the types and default values (if any) of the arguments: - Provide hints to related functions.Sometimes there are functions of related functionality. To increase discoverability please provide a short list of these in a
See also:
paragraph. - Include any code examples in an
# Examples
section.Examples should, whenever possible, be written as doctests. A doctest is a fenced code block (see Code blocks) starting with```jldoctest
and contains any number ofjulia>
prompts together with inputs and expected outputs that mimic the Julia REPL.Note Doctests are enabled byDocumenter.jl
. For more detailed documentation see Documenter's manual.For example in the following docstring a variablea
is defined and the expected result, as printed in a Julia REPL, appears afterwards:Callingrand
and other RNG-related functions should be avoided in doctests since they will not produce consistent outputs during different Julia sessions. If you would like to show some random number generation related functionality, one option is to explicitly construct and seed your ownMersenneTwister
(or other pseudorandom number generator) and pass it to the functions you are doctesting.Operating system word size (Int32
orInt64
) as well as path separator differences (/
or) will also affect the reproducibility of some doctests.
Note that whitespace in your doctest is significant! The doctest will fail if you misalign the output of pretty-printing an array, for example.You can then runmake -C doc doctest=true
to run all the doctests in the Julia Manual and API documentation, which will ensure that your example works.To indicate that the output result is truncated, you may write[...]
at the line where checking should stop. This is useful to hide a stacktrace (which contains non-permanent references to lines of julia code) when the doctest shows that an exception is thrown, for example:Examples that are untestable should be written within fenced code blocks starting with```julia
so that they are highlighted correctly in the generated documentation.Tip Wherever possible examples should be self-contained and runnable so that readers are able to try them out without having to include any dependencies. - Use backticks to identify code and equations.Julia identifiers and code excerpts should always appear between backticks
`
to enable highlighting. Equations in the LaTeX syntax can be inserted between double backticks``
. Use Unicode characters rather than their LaTeX escape sequence, i.e.``α = 1``
rather than``alpha = 1``
. - Place the starting and ending
''
characters on lines by themselves.That is, write:rather than:This makes it clearer where docstrings start and end. - Respect the line length limit used in the surrounding code.Docstrings are edited using the same tools as code. Therefore, the same conventions should apply. It is recommended that lines are at most 92 characters wide.
- Provide information allowing custom types to implement the function in an
# Implementation
section. These implementation details are intended for developers rather than users, explaining e.g. which functions should be overridden and which functions automatically use appropriate fallbacks. Such details are best kept separate from the main description of the function's behavior. - For long docstrings, consider splitting the documentation with an
# Extended help
header. The typical help-mode will show only the material above the header; you can access the full help by adding a '?' at the beginning of the expression (i.e., '??foo' rather than '?foo').
Documentation can be accessed at the REPL or in IJulia by typing
?
followed by the name of a function or macro, and pressing Enter
. For example,will show documentation for the relevant function, macro or string macro respectively. In Juno using
Ctrl-J, Ctrl-D
will show the documentation for the object under the cursor.Functions in Julia may have multiple implementations, known as methods. While it's good practice for generic functions to have a single purpose, Julia allows methods to be documented individually if necessary. In general, only the most generic method should be documented, or even the function itself (i.e. the object created without any methods by
function bar end
). Specific methods should only be documented if their behaviour differs from the more generic ones. In any case, they should not repeat the information provided elsewhere. For example:When retrieving documentation for a generic function, the metadata for each method is concatenated with the
catdoc
function, which can of course be overridden for custom types.The
@doc
macro associates its first argument with its second in a per-module dictionary called META
.To make it easier to write documentation, the parser treats the macro name
@doc
specially: if a call to @doc
has one argument, but another expression appears after a single line break, then that additional expression is added as an argument to the macro. Therefore the following syntax is parsed as a 2-argument call to @doc
:This makes it possible to use expressions other than normal string literals (such as the
raw'
string macro) as a docstring.Expanding Expression Tool Manual Online
When used for retrieving documentation, the
@doc
macro (or equally, the doc
function) will search all META
dictionaries for metadata relevant to the given object and return it. The returned object (some Markdown content, for example) will by default display itself intelligently. This design also makes it easy to use the doc system in a programmatic way; for example, to re-use documentation between different versions of a function:Or for use with Julia's metaprogramming functionality:
Documentation written in non-toplevel blocks, such as
begin
, if
, for
, and let
, is added to the documentation system as blocks are evaluated. For example:will add documentation to
f(x)
when condition()
is true
. Note that even if f(x)
goes out of scope at the end of the block, its documentation will remain.It is possible to make use of metaprogramming to assist in the creation of documentation. When using string-interpolation within the docstring you will need to use an extra
$
as shown with $($name)
:Sometimes the appropriate documentation for an instance of a type depends on the field values of that instance, rather than just on the type itself. In these cases, you can add a method to
Docs.getdoc
for your custom type that returns the documentation on a per-instance basis. For instance,?x
will display 'Documentation for MyType with value x' while ?y
will display 'Documentation for MyType with value y'.This guide provides a comprehensive overview of how to attach documentation to all Julia syntax constructs for which providing documentation is possible.
In the following examples
'...'
is used to illustrate an arbitrary docstring.The
$
and
characters are still parsed as string interpolation or start of an escape sequence in docstrings too. The raw'
string macro together with the @doc
macro can be used to avoid having to escape them. This is handy when the docstrings include LaTeX or Julia source code examples containing interpolation:Adds docstring
'...'
to the function f
. The first version is the preferred syntax, however both are equivalent.Adds docstring
'...'
to the method f(::Any)
.Adds docstring
'...'
to two Method
s, namely f(::Any)
and f(::Any, ::Any)
.Adds docstring
'...'
to the @m(::Any)
macro definition.Adds docstring
'...'
to the macro named @m
.Adds the docstring
'...'
to types T1
, T2
, and T3
.Adds docstring
'...'
to type T
, 'x'
to field T.x
and 'y'
to field T.y
. Also applicable to mutable struct
types.Adds docstring
'...'
to the Module
M
. Adding the docstring above the Module
is the preferred syntax, however both are equivalent.Documenting a
baremodule
by placing a docstring above the expression automatically imports @doc
into the module. These imports must be done manually when the module expression is not documented. Empty baremodule
s cannot be documented.Adds docstring
'...'
to the Binding
s a
, b
, and c
.Binding
s are used to store a reference to a particular Symbol
in a Module
without storing the referenced value itself.When a
const
definition is only used to define an alias of another definition, such as is the case with the function div
and its alias ÷
in Base
, do not document the alias and instead document the actual function.If the alias is documented and not the real definition then the docsystem (
?
mode) will not return the docstring attached to the alias when the real definition is searched for.For example you should write
rather than
Adds docstring
'...'
to the value associated with sym
. However, it is preferred that sym
is documented where it is defined.Adds docstring
'...'
to a
and b
each of which should be a documentable expression. This syntax is equivalent toAny number of expressions many be documented together in this way. This syntax can be useful when two functions are related, such as non-mutating and mutating versions
f
and f!
.Adds docstring
'...'
to the expression generated by expanding @m expression
. This allows for expressions decorated with @inline
, @noinline
, @generated
, or any other macro to be documented in the same way as undecorated expressions.Macro authors should take note that only macros that generate a single expression will automatically support docstrings. If a macro returns a block containing multiple subexpressions then the subexpression that should be documented must be marked using the
@__doc__
macro.The
@enum
macro makes use of @__doc__
to allow for documenting Enum
s. Examining its definition should serve as an example of how to use @__doc__
correctly.Core.@__doc__
— MacroLow-level macro used to mark expressions returned by a macro that should be documented. If more than one expression is marked then the same docstring is applied to each expression.
@__doc__
has no effect when a macro that uses it is not documented.This multisensory tool is an extremely versatile item that can be used to target the following skills (to name just a few):
- written expression
- defining and describing
- stating functions of objects
- stating similarities and differences
How it works:
Well, first of all, the kit comes with the following items:
Expanding Expression Tool Manual 2016
- kit manual
- stickers for writing
- dice game
(Graphic Courtesy of Expanding Expression Tool)
Since students with language disabilities often have difficulties describing, this tool is absolutely awesome because it breaks down the tasks listed above into smaller pieces. The kit is designed with designated colors and repetitive materials. Each color stands for a specific attribute of an item (e.g. green group, blue do, pink parts, white where, etc). Students methodically move through each color to describe objects, define, make associations, etc. (I use this tool most often with describing, so that is my frame of reference, but as you can see, it can be used to target so many other skills too!)
Here is a specific example of how to use the item for describe. Take a banana for example. Typically, if I asked a student to describe a banana, he or she might say, 'you eat it' or 'it's yellow'. (Or if I'm really lucky, maybe 'You eat it AND it's yellow.') By using the EET, look at all of the ways that this item could be described...
- Green Group: This item belongs to the fruit group.
- Blue Do: You can peel the item and you can eat it.
- White Eye: This item is yellow and it is shaped like a crescent.
- Pink Parts: This item has a peel and a short stem at the top.
![Expanding expression tool manual software Expanding expression tool manual software](https://giantimagemanagement.com/yahoo_site_admin/assets/images/SERBIAN_BULLET_THROUGH_TARGET_SHEET.265195123_std.jpeg)
- White Where: This item grows on trees, but you find it most often in a grocery store, typically in the produce section.
- Orange Extras: This item is often eaten by monkeys and the peel can be slippery.Here's a closer look at the visual tool.
These EETCHY Steppers are an add-on that can be used to get your students up and moving throughout a therapy session.
Expanding Expression Tool Manual Software
What I love about this item:
- The string/ball visual tool is a step-by-step way to describe that is hands on and really grabs a student's attention. My students get excited every time I pull 'him' out. (Each group has their own name for him and they all remember his name.)
- This tool can be used for SO many skills. It is ridiculously versatile!
- The manual comes with a large variety of materials that support the program and the hands-on materials that come with the kit.
The kit is $229.00 and can be found here but there are also tons of extra add-ons to enhance your kit that can also be found at the same site.
To find out more about the Expanding Expression Tool, you can go to their website and read all about it.
Disclaimer: This item was given to me for review. No other compensation was provided. The opinions expressed here are solely my own.