help parallel also see: miparallel -------------------------------------------------------------------------------------------------------------------------------------------------
Title
parallel -- Stata module for Parallel computing
Index
Sections
1. Syntax Command syntax. 2. Description Command description. 3. Details How does parallel works. 4. Parallel Append Using -parallel append- syntax. 5. Caveats Things to consider before using parallel. 6. Technical note Some details under the hood. 7. Examples Some examples using parallel 8. Saved results A list of parallel's save results 9. Citation How cite parallel. 10. Development Up-to-date version and bug reporting 11. Source code parallel's (MATA) source code 12. Authors Authors behind parallel 13. Contributors Notable contributors 14. Also see Other modules related to parallel 15. FAQs Frequently Asked Questions
Available commands
1. parallel initialize Setting the number of child processes. 2. parallel numprocessors Getting the number of processors on the system. 3. parallel do Parallelizing a do-file. 4. parallel : (prefix) Parallelizing a Stata command (parallel prefix). 5. parallel bs Parallel bootstrapping. 6. parallel sim Parallel simulate. 7. parallel append Multiple file processing and appending. 8. parallel clean Removing auxiliary files. 9. parallel printlog Checking out child processes' log files. 10. parallel version Query parallel current version. 11. parallel citation How to cite parallel.
1. Syntax
--------------------------------------------------------------------------------------------------------------------------------------------- Setting the number of child processes (threads/processors)
parallel initialize [ # , force statapath(stata_path) includefile(filename) hostnames(string) ssh(string) procexec(int)]
--------------------------------------------------------------------------------------------------------------------------------------------- Getting the number of processors on the system
parallel numprocessors
--------------------------------------------------------------------------------------------------------------------------------------------- Parallelizing a do-file
parallel do filename [, by(varlist) force nodata setparallelid(pll_id) execution_options]
--------------------------------------------------------------------------------------------------------------------------------------------- Parallelizing a Stata command (parallel prefix)
parallel [, by(varlist) force keep nodata setparallelid(pll_id) execution_options]: command
--------------------------------------------------------------------------------------------------------------------------------------------- Parallel bootstrapping
parallel bs [, expression(exp_list) execution_options bs_options ] [: command]
--------------------------------------------------------------------------------------------------------------------------------------------- Parallel simulate
parallel sim [ , expression(exp_list) execution_options sim_options ] [: command]
--------------------------------------------------------------------------------------------------------------------------------------------- Multiple file processing and appending
parallel append [file(s)] , do(cmd|dofile) [in(in) if(if) expression(expand expression (see details)) execution_options ]
--------------------------------------------------------------------------------------------------------------------------------------------- Removing auxiliary files
parallel clean [, event(pll_id) all force]
--------------------------------------------------------------------------------------------------------------------------------------------- Checking out child processes' logfiles by printing the output.
parallel printlog [#] [, event(pll_id)]
Checking out child processes' logfiles by showing the output in a view window.
parallel viewlog [#] [, event(pll_id)]
--------------------------------------------------------------------------------------------------------------------------------------------- Query parallel current version
parallel version
parallel citation
options Description ------------------------------------------------------------------------------------------------------------------------------------------- Setting the number of child processes # The number of child processes. If omitted the default is max(floor(num_processors*0.75),1) force Overrides the restriction on using more child processes than processors on your machine (see the WARNING in description). This option is assumed when specifying hostnames. statapath File path. parallel tries to automatically identify Stata's exe path. By using this option you will override this and force parallel to use a specific path to stata.exe. includefile File path. This file will be included before parallel commands are executed. The target purpose for this is to allow one to copy over preferences that parallel does not copy automatically. hostnames a space delimited list of hostnames. For the local machine, use localhost. Work will be assigned in the order of the list and the list elements will be re-used if num child processes is longer than the list. An example would be localhost node2 node3. If no option is provided, then localhost is assumed. Leave blank for local execution. ssh The command used to connect to remote machines. If none is provided, this will be ssh. This option is not needed for local execution. procexec On Windows, controls how child processes are spawned. The default value 2 will launch them in a hidden desktop (they can still be seen in the task manager) so that the child applications don't briefly steal the window focus (which is annoying). With value 1 the child processes will be launched in the user's desktop, will be launch auto-minimized, but will still briefly steal the focus. and will steal focus and perhaps briefly show the windows of the child processes.
execution_options keep Keeps auxiliary files generated by parallel. Use this and the next option with care as there can be many file that take up space. keeplast Keeps auxiliary files and remove those last time saved during the current session. programs A list of programs to be passed to each child process. To do this, parallel needs to echo the contents of those programs to the output window. If parallel is being run from inside an ado (say my_cmd.ado) and you need to access local subroutines (other programs defined in the ado beside the primary my_cmd), then you must pass their names in this option as my_cmd.local_subroutine_name for them to be accessible. mata If the algorithm needs to use mata objects, this option allows to pass to each child process every mata object loaded in the current session (including functions). Note that when mata objects are loaded into the child processes they will have different locations and therefore pointers may no longer be accurate. noglobal Avoid passing current session's globals to the child processes. seeds Numlist. With this option the user can pass an specific seed to be used within each child process. randtype String. Tells parallel whether to use the current seed (-current-), the current datetime (-datetime-) or random.org API (-random.org-) to generate the seeds for each child processes (please read the Description section). processors Integer. If running on StataMP, sets the number of processors each child process should use. Default value is 0 (do nothing). timeout Integer. If a child process hasn't started, how much time in seconds does parallel has to wait until assume that there was a connection error and thus the child process won't start. Default value is 60. outputopts A list of option names that are aggregating output options. parallel automtically aggregates main data from child processes. Often, though, a program will aggregate more than one type of data. outputopts allows generic file-based aggregation (appending). A sequential call such as my_prog, output1(outputfile.dta) can be converted to parallel, outputopts(output1): my_prog, output1(outputfile.dta). parallel will execute each child process with its own file passed to output1 and at the end, append them all and save it to outputfile.dta. deterministicoutput will eliminates displayed output that would vary depending on the machine (e.g. timers, seeds, and number of parallel child processes) so that log files can be easily compared across runs. Errors are still printed.
Byable parallelization by Varlist. Tells the command through which observations the current dataset can be divided, avoiding stories (panel) splitting over two or more child processes. The semantics for by are not the same as for Stata. When Stata implements by, the command that is run will only see a section of the data where the by-variables are the same. parallel's semantics are that no observations with the same by-values will be in different child processes. It pools together combinations when there are fewer child processes than by-var combinations. If you need Stata-style semantics, the solution is to add by in the subcommand. For example, parallel, by(byvar): by byvar: egen x_max = max(x). force When using by, parallel checks whether if the dataset is properly sorted. By using force the command skips this check.
Parallel bootstrap expression An exp_list to be passed to the bootstrap command. bs_options Further options to be passed to the bootstrap command, including the optional reps() parameter.
Parallel simulate expression An exp_list to be passed to the simulate command. sim_options Further options to be passed to the simulate command, including the required reps() parameter.
Multiple file processing and appending do Stata cmd or dofile. Note that parallel do does not support passing options to the do-file. If you need arguments then use the prefix style. files Explicit list of files to process. expression String. Expression representing file names in the form of "%fmts, numlist1 [, numlist2 [, ...]]"
Removing auxiliary files event String. Specifies which executed (and stored) event's files should be removed. all Tells parallel to remove every remnant auxiliary files generated by it in the current directory. force Forces the command to remove (apparently) in-use auxiliary files. Otherwise these will not get deleted.
Other options event String. With printlog and viewlog this specifies which event's log files should be displayed. setparallelid Programmers' option. Forces parallel to use an specific id (pll_id) (see Technical Notes). nodata Tells parallel not to use loaded data and thus not to try splitting or appending anything.
2. Description
-parallel- allows to implement parallel computing, without having StataMP, substantially reducing computing time. Specially suitable for bootstrapping and simulations, parallel includes out-of-the-box tools for implementing such algorithms.
In order to use -parallel- it is necessary to set the number of desired child processes with which the user wants to work with. To do this the user should use -parallel initialize- syntaxes, replacing # with the desired number of child processes. Setting more child processes than physical cores the user's computer has it is not recommended (see the WARNING in description).
-parallel do- is the equivalent (wrapper) to -do-. When using this syntax parallel runs the dofile in as many child processes as there where specified by the user, this is, start $PLL_CHILDREN Stata instances in batch mode. By default the loaded dataset will be split into the number of child processes specified by -parallel initialize- and the do-file will be executed independently over each and every one of the data chunks, so once after all the parallel-instances stops, the datasets will be appended. In order to avoid loading the current dataset in the child processes, the user should specify the -nodata- option.
-parallel :- (as a prefix) allows to, after splitting the loaded dataset, execute a stata_cmd over the specified number of data chunks in order to speed up computations. Like -parallel do-, after all the parallel-instances stops, the datasets will be appended.
-parallel bs- and -parallel sim- are parallel wrappers for the commands -bootstrap- and -simulate-. Specially suited for these algorithms, -parallel- allows conducting embarrassingly parallel computing. In terms of syntax, besides cmd names, the only difference that these two commands have with their serial versions is how are expressions passed (please refer to the examples section for this).
Every time that -parallel- runs several auxiliary files are generated which, after finishing, are automatically deleted. In the case that the user sets -keep- or -keeplast- the auxiliary files are kept, thus the syntax -parallel clean- becomes handy. With -parallel clean- the user can remove the last generated auxiliary files (default option), an specific parallel instance files (using #pll_id number), or every stored auxiliary file (with -all-). For security reasons, in-use auxiliary files will not be deleted unless the user specifies it through the option force, which will override not deleting in-use auxiliary files (see the Technical note section for more information about this). Log files from the runs are stored in c(tmpdir) so that they can be inspected by the user. The user will likely want to delete these periodically with parallel clean, all.
In the case of handling multiple files (because it is, for example, a big dataset divided into multiple dta files), -parallel append- becomes handy as it allows the user to process them simultaneously. By providing a list of files and a Stata cmd or dofile, -parallel append- opens and executes the cmd/dofile within each file, stores each file results and appends them into a single file. Also, if the files to be processed have a pattern base name, the user can provide -parallel append- with an expression representing the list of files to be processed; for information on how to use this feature, see the section Parallel Append.
Given N child processes, within each child process -parallel- creates the macros pll_id (equal for all the child processes) and pll_instance (ranging 1 up to N, equaling 1 inside the first child process and N inside the last child process), both as globals and locals macros. This allows the user setting different tasks/actions depending on the child process. Also the global macro PLL_CHILDREN (equal to N) is available within each child process. For an example using this macros, please refer to the Examples section.
As by now, -parallel- by default automatically identifies Stata's executable file path. This is necessary as it is used to run Stata in batch mode (the mainstream of the module). Either way, after some reports, that file path is not always correctly identified; where the option -statadir- in -parallel initialize- can be used to manually set it.
In the case of pseudo-random-numbers, the module allows to pass different seed for each child process. Moreover, if the user does not provide a numlist of seeds, -parallel- generates its own numlist of seeds using three different options: (1) based on the current seed; (2) using the current datetime and user as a seed to generate each seed, restoring the original seed afterwards; or (3) using random.org API (requires internet connection) to directly generate each seed (also restoring the original seed afterwards). -parallel- saves a macro with the used seeds in the r(pll_seeds) macro.
WARNINGS For each child process -parallel- starts a new Stata instance (thus running as many processes as child processes), this way, should the user set more child processes than cores the computer has, it is possible that the computer freezes.
3. Details
Inspired by the R library ``snow'' and to be used in multicore CPUs , -parallel- implements parallel computing methods through an OS's shell scripting (using Stata in batch mode) to speedup computations by splitting the dataset into a determined number of child processes in such a way to implement a data parallelism algorithm.
The number of efficient computing child processes depends upon the number of physical cores (CPUs) with which your computer is built, e.g. if you have a quad-core computer, the correct child process setting should be four. In the case of simultaneous multithreading, such as that from Intel's hyper-threading technology (HTT), setting -parallel- following the number of processors threads, as it was expected, hardly results into a perfect speedup scaling. In spite of it, after several tests on HTT capable architectures, the results of implementing -parallel- according to the machines physical cores versus its logical cores shows small though significant differences.
-parallel- is especially handy when it comes to implementing loop-based simulation models (or simply loops), Stata commands such as reshape , or any job that (a) can be repeated through data-blocks, and (b) routines that processes big datasets (see the append section). Furthermore, the commands -parallel bs- and -parallel sim- are specially designed to easily implement bootstrapping and (monte carlo) simulations in parallel fashion.
At this time -parallel- has been successfully tested in Windows, Unix and MacOS for Stata versions 11 to 14.
-parallel- does not change the RNG state (even if subcommands invoke randomization functions).
After several tests, it has been proven that--thanks to how -parallel- has been written--it is possible to use the algorithm in such a way that other techniques of parallel computing can be implemented; such as Monte Carlo Simulations, simultaneously running models, etc.. An extensive example through Monte Carlo Simulations is provided here.
To distribute work across different machines in a computer cluster, the machines need to be Linux/MacOS, share a global file-system (e.g. NFS), and have a non-interactive way to remotely execute commands. The most common way to remotely execute commands is to use ssh with keyfiles so that no password is needed. This is still a new feature, and synchronizing across machines in child processes can have odd corner cases, so users may encounter some trouble getting this to work.
4. Parallel Append
Imagine we have several dta files named -income.dta- stored in a set of folders ranging 2008_01 up to 2012_12, this is, a total of 60 files (12 times 5) monthly ordered which may look something like this:
2008_01/income.dta 2008_02/income.dta 2008_03/income.dta
...more files...
2010_01/income.dta 2010_02/income.dta 2010_03/income.dta
...more files...
2012_10/income.dta 2012_11/income.dta 2012_12/income.dta
Now, imagine that for each and every one of those files we would like to execute the following program:
program def myprogram gen female = (gender == "female") collapse (mean) income, by(female) fast end
Instead of writing a forval/foreach loop (which would be the natural solution for this situation), -parallel append- allows us to smoothly solve this with the following command.
. parallel append, do(myprogram) prog(myprogram) /// e("%g_%02.0f/income.dta, 2008/2012, 1/12")
Where element by element, we are telling parallel: (1) do(myprogram): execute the command -myprogram-, (2) prog(myprogram): -myprogram- is a user written program, and (3) e("%g_%02.0f/income.dta, 2008/2012, 1/12"): this should process files 2008_01/income.dta up to 2012_12/income.dta.
Besides of the simplicity of its syntax, the advantage of using -parallel append- lies in doing so in a parallel fashion, this is, instead of processing one file at a time, -parallel- manages to process these files in groups of as many files as child processes are set. Step-by-step, what this command does is:
1. Distribute groups of files across child processes
Once each child process starts, for each dta file
2. Opens the file using [if] [in] accordingly to in and if options. 3. Executes the command/dofile specified by the user. 3. Stores the results in a temp dta file.
Finally, once all the files have been processed
4. Appends all the resulting files into a single one.
5. Caveats
When the -stata_cmd- or -do-file- saves results, as -parallel- runs Stata in batch mode, none of the results will be kept. This is also true for matrices, scalars, mata objects, returns, or whatever other object different from data.
Although -parallel- passes-through programs, macros and mata objects, in the current version it is not capable of doing the same with matrices or scalars. The tempname internal state is copied to childre, but the parent does not receive any of this state from the children. That is, -parallel- advances the tempname (tempvar) sequence in the children to not overlap with any produced by the parent. If the number of tasks to be done is less than the number of child processes, parallel will temporarily reduce the number of child processes. This is reported in the global $LAST_PLL_N. Expressions run in the child-processes that contain _n or _N will be evaluated locally to the child not the parent dataset. These expressions may therefore be different if run in parallel than without parallel. When executing Stata on separate machines via ssh, no environment variables except PWD and STATATMP are copied over.
6. Technical note
In order to protect a pll_id code (and thus ancillary files), once -parallel- is called it creates a new file called __pll[pll_id]sandbox (stored at c(tmpdir), in your case: C:\Users\Brian\AppData\Local\Temp/). This forbids -parallel clean- from deleting any auxiliary file used by that process and reserves the pll_id so that no other call of -parallel- can use this pll_id. Once every child process has finished, the sandbox file is removed, freeing the pll_id.
If for any reason the algorithm breaks due to a flaw or crush of the system, the sandbox file and the rest of auxiliary files will not be deleted. In order to clean up this, the user will be able to do so manually (moving the file(s) to the OS recycle bin) or using parallel clean, all force syntax. This way all sandbox files in the c(tmpdir) folder and auxiliary files stored at the current directory will be deleted.
In earlier versions of -parallel-, tempfiles generation was not safe as while running multiple Stata instances simultaneously these could overwrite each other's tempfiles. Starting version 1.14, this is no longer a problem as each Stata instance starts with a different c(tmpdir) location. This way, instances' tempfile management will not interfere with each other, allowing to safely use commands or algorithms depending on tempfile generation (such as preserve and restore).
The option -setparallelid- is designed to let programmers recycle a parallel id (pll_id). Intended to be used with -parallel_sandbox- (undocumented, please refer to the source code of -parallel_sandbox()-), this option allows calling parallel several times using the same pll_id, which makes auxiliary files management far simpler. Take the following example
program def mypllwrapper // Reserving a pll_id m: parallel_sandbox(5) // Using the generated pll_id save __pll`parallelid'_mypllwrapper, replace // Recycling the pll_id forval i=1/10 { parallel, setparallelid(`parallelid') keep: some_other_cmd } // Cleanning up and freeing the pll_id. This will remove all files // and folders named with prefix '__pll[parallelid]' parallel clean, e(`parallelid') m: parallel_sandbox(2,"`parallelid'") end
For a real example of this, please see -parallel.bs- and -parallel_sim.ado-.
Windows-shell: Spawning child processes with shell command on Windows (Deprecated)
Originally child processes on Windows were spawned as they were on other platforms using Stata's shell methods (e.g. winexec). This had a number of problems (spawned processes stole the UI focus, failure to recover from killed child processes, difficulty in batch-mode), so now Windows uses a plugin that launches the child processes directly using Win32 system calls. The original functionality is retained, but deprecated. To enable it you must specified the procexec(0) option.
Since shell commmands are ignored by Stata in batch-mode on Windows, a work around is needed. The method is to have Stata write out the commands to be executed to a file (called the gateway) and have a separate process read new inputs to this file and execute the commands. This latter part requires the user to install Cygwin and run a few commands prior to starting Stata. In a Cygwin terminal, navigate to the appropriate directory and do the following:
$ rm pll_gateway.sh $ touch pll_gateway.sh $ tail -f pll_gateway.sh | bash
Then you can execute your Stata script in batch-mode on Windows. The Cygwin tail process can stay running through multiple uses.
The default gateway file assumed is pll_gateway.sh. If you would like a different file modify the Cygwin script above and pass a new value for gateway(gateway_path) to parallel initialize.
Since Cygwin is going to execute the commands to start the parallel Stata instances it needs a Cygwin-like Stata path. If the user does not specify the Stata path then -parallel- will take the generated windows path and convert it to "/cygdrive/<drive letter>/...". If this does not work you will need to specify the statapath explicitly.
In this mode, there is no automatic way for the parent process to stop the child processes in case the user has requested a break in execution. The original (but now deprecated) parallel break can still be used (and mata equivalents parallel_break() and _parallel_break()). This is a call that is you write into the code that executes in the children that queries if the mother process has requested to break. If this is not used appropriately, and a child process is executing for a long period (e.g. an endless loop) the user must kill the child processes manually.
Example 1: using prefix syntax
In this example we'll generate a variable containing the maximum blood-pressure measurement (bp) by patient.
Setup for a quad-core computer . sysuse bplong.dta . sort patient . parallel initialize 4
Computes the maximum of bp for each patient. We add the option by(patient) to tell parallel not to split stories. . parallel, by(patient): by patient: egen max_bp = max(bp) Which is the ``parallel way'' to do:
. by patient: egen max_bp = max(bp) Giving you the same result.
Example 2: using -parallel do- syntax
Another usage that may get big benefits from it is implementing loop-base simulations. Imagine that we have a model that requires looping over each and every record of a panel-data dataset.
Using -parallel-, the proper way to do this would be using the ``parallel do'' syntax
. use mybigpanel.dta, clear
. parallel initialize 4 . parallel do mymodel.do . collapse ...
where mymodel.do would look something like this ----------------------------------- begin of do-file ------------ local maxiter = _N forval i = 1/`maxiter' { ...some routine... } ----------------------------------- end of the do-file ----------
Or, in the case of using mata, this would look something like this
----------------------------------- begin of do-file ------------ mata: N=c("N") for(i = 1;i<=N;i++) { ...some routine... } ----------------------------------- end of the do-file ----------
Example 3: setting the right path
In the case of -parallel- setting the stata.exe's path wrongly, using -setstatapath- will correct the situation. So, if "C:\Archivos de programa\Stata12/stata.exe" is the right path we only have to write:
. parallel initialize 2, s("C:\Archivos de programa\Stata12/stata.exe")
Example 4: Using -parallel bs-
In this example we'll evaluate a regression model using bootstrapping
Setup for a quad-core computer . sysuse auto, clear . parallel initialize 4
Running parallel bs. . parallel bs: reg price c.weig##c.weigh foreign rep Which is the ``parallel way'' to do:
. bs: reg price c.weig##c.weigh foreign rep
Example 5: Using -parallel sim-
Example from simulate
Setup for a quad-core computer . parallel initialize 4
Experiment that will be performed program define lnsim, rclass version 14 syntax [, obs(integer 1) mu(real 0) sigma(real 1) ] drop _all set obs `obs' tempvar z gen `z' = exp(rnormal(`mu',`sigma')) summarize `z' return scalar mean = r(mean) return scalar Var = r(Var) end
Running parallel sim. . parallel sim, expr(mean=r(mean) var=r(Var)) reps(10000): lnsim, obs(100) Which is the ``parallel way'' to do:
. simulate mean=r(mean) var=r(Var), reps(10000): lnsim, obs(100)
Example 6: Using -pll_instance- and -PLL_CHILDREN- macros
By using -pll_instance- and -PLL_CHILDREN- global macros the user can run -parallel- in such a way that each child process performs a different task. Take the following example:
Setup for a quad-core computer . parallel initialize 4 . sysuse auto, clear
program def myprog gen x = $pll_instance gen y = $PLL_CHILDREN // For the first child process if ($pll_instance == 1) gen z = exp(2) // For the second child process else if ($pll_instance == 2) { summ price gen z = r(mean) } // For the third and fourth child processes else gen z = 0 end
Running the program . parallel, prog(myprog): myprog
Here, running with 4 cores, the program -myprog- performs different actions depending on the value (number) of -pll_instance-. For those observation in the first child process, -parallel- will generate -z- equal to exp(2), for those in the second child process it will compute -z- equal to the average price and for the rest of the child processes it will generate -z- equal to zero.
8. Saved results
-parallel- saves the following in r():
Scalars r(pll_n) Number of parallel child processes last used r(pll_t_fini) Time took to appending and cleaning r(pll_t_calc) Time took to complete the parallel job r(pll_t_setu) Time took to setup (before the parallelization) and to finish the job (after the parallelization) r(pll_errs) Number of child processes which stopped with an error.
Macros r(pll_id) Id of the last parallel instance executed (needed to use parallel clean) r(pll_dir) Directory where parallel ran and stored the auxiliary files. r(pll_seeds) Seeds used within each child process.
-parallel bs- and -parallel sim- save the following in e():
Scalars e(pll) 1.
-parallel version- saves the following in r():
Macros r(pll_vers) Current version of the module.
-parallel numprocessors- saves the following in r():
Scalars r(numprocessors) Number of logical processors on the system.
-parallel- saves the following global macros:
$LAST_PLL_DIR A copy of r(pll_dir). $LAST_PLL_N A copy of r(pll_n). $LAST_PLL_ID A copy of r(pll_id). $PLL_LASTRNG Number of times that -parallel_randomid()- has been executed. $PLL_STATA_PATH, $PLL_CLUSTERS (deprecated), $PLL_CHILDREN, $USE_PROCEXEC, $PLL_HOSTNAMES, $PLL_SSH Internal usage.
9. Citation When using parallel, please include the following:
Vega Yon GG, Quistorff B. parallel: A command for parallel computing. The Stata Journal. 2019;19(3):667-684. doi:10.1177/1536867X19874242
For a bibentry, checkout the parallel citation command.
10. Development
You can always have access to the latest version of -parallel-. One option is from its github repo (on-development source code):
https://github.com/gvegayon/parallel
Or from the project's website:
. net install parallel, from(https://raw.github.com/gvegayon/parallel/master/) replace . mata mata mlib index
You can track new releases on GitHub or by following the RSS feed https://github.com/gvegayon/parallel/releases.atom
In the case of bug reporting, you can submit issues here:
https://github.com/gvegayon/parallel/issues
Please try the latest version to see if your problem has been solved. Include the steps to reproduce the issue and the output of the Stata command -creturn list-.
11. mata source code
Most of -parallel- has been programmed in mata. This means that, as a difference from typical ado files, -parallel- is distributed with lparallel mata library (compiled code) and thus source code can not be reached directly by users. Given this, the help file parallel_source.sthlp is included in the package, help file which contains the source code in a fancy way.
In order to get access to different sections of the source code you can follow these links:
Stops a child process after the user pressed break parallel_break.mata Remove auxiliary files parallel_clean.mata Distributes observations across child processes parallel_divide_index.mata Export global macros parallel_export_globals.mata Export programs parallel_export_programs.mata Wait until a child process finishes parallel_finito.mata (on development) parallel_for.mata Normalize a filepath parallel_normalizepath.mata Generate random alphanum parallel_randomid.mata Lunch simultaneous Stata instances in batch mode parallel_run.mata Set of tools to protect parallel aux files parallel_sandbox.mata Set the number of child processes parallel_initialize.mata Set the Stata EXE directory parallel_setstatapath.mata Write a ``diagnosis'' parallel_write_diagnosis.mata Write a dofile to be paralellized parallel_write_do.mata
12. References
Luke Tierney, A. J. Rossini, Na Li and H. Sevcikova (2012). snow: Simple Network of Workstations. R package version 0.3-9. http://CRAN.R-project.org/package=snow R Core Team (2012). R: A language and environment for statistical computing. R Foundation for Statistical Computing, Vienna, Austria. ISBN 3-900051-07-0, URL http://www.R-project.org/. George Vega Y (2012). Introducing PARALLEL: Stata Module for Parallel Computing. Chilean Pension Supervisor, Santiago de Chile, URL http://fmwww.bc.edu/repec/bocode/p/parallel.pdf. George Vega Y (2013). Introducing PARALLEL: Stata Module for Parallel Computing. Stata Conference 2013, New Orleans (USA), URL http://ideas.repec.org/p/boc/norl13/4.html. Haahr, M. (2006). Random.org: True random number service. Random.org. http://www.random.org/clients/http/.
13. Authors
George Vega Yon [cre,aut], University of Southern California<EMAIL_ADDRESS>http://ggvy.cl/
Brian Quistorff [aut], Bureau of Economic Analysis<EMAIL_ADDRESS>http://quistorff.com
14. Contributors
Special Thanks to: Elan P. Kugelmass (aka as epkugelmass at github) [ctb], Timothy Mak (University of Hong Kong) (author of miparallel)
Damian C. Clarke (Oxford University, England), Felix Villatoro (Superintendencia de Pensiones, Chile), Eduardo Fajnzylber (Universidad Adolfo Ibáñez, Chile), Eric Melse (CAREM, Netherlands), Tomás Rau (Universidad Católica, Chile), Research Division (Superindentendia de Pensiones, Chile), attendees to the Stata conference 2013 (New Orleans), Philippe Ruh (University of Zurich), Michael Lacy (Colorado State).
15. Also see
Manual: [GSM] Advanced Stata usage (Mac), [GSU] Advanced Stata usage (Unix), [GSW] Advanced Stata usage (Windows)
Online: Running Stata batch-mode in Mac, Unix and Windows
Project's wiki page of other examples.
16. FAQs
Here follows a list of Frequently Asked Questions:
1. I am getting error (608) file is read-only; cannot be modified or erased. What can I do to solve it?
As Stata suggests, you are trying to either run parallel in a read-only directory, or your program/dofile is trying to write (save a dta file for example) in a read-only directory. Try running parallel (or making your program to write files) in a directory where you have writing priviledges (where you can save files).
1. How can I create reproducible results between sequential and parallel excecution when randomness is involved?
See our utility command seeding.


ZANDA DESIGN
DESIGNER
CONTACT
CV
ABOUT
ILLUSTRATION
COMMERCIAL
WORK
PHOTOGRAPHY
I am a graphic designer based in Auckland/ New Zealand. At the moment I am working with B2B and marketing projects for a software company. My way to become who I am has been very colourful and adventures. I started as a textile designer with a Bachelor in my home land Latvia. The individual way of drawing, I discovered while studying Illustration at a very creative studio of ASP in Warsaw/ Poland. However, the conceptual thinking I developed while doing Master of Graphic design in Netherlands. I love travelling, I love rain in hot days and smell of lilac. I love to work with hands, I love qulity. I love to be honest and natural. I am a firm believer to make this world a better place.


Guide Pages
Overview
An Order integration scenario allows you to retrieve Orders created in Endless Aisle.
An Order is created after a Customer presses “Checkout”, as shown below.
Figure 1: Checking Out in Endless Aisle
Getting Orders
Orders created in Endless Aisle have the following specifications:
- Each Product in the cart corresponds to an OrderItem on the Order
- Order
Status
is set toPending
- A Customer is created and associated with the Order
Orders can be synced to an external system using Getting Pending Orders by Location.
Syncing Orders might be used to:
- Transfer the contents of a cart to a POS to complete a transaction
- Modify an Order in an eCommerce solution
- Keep a record of an Order in an Inventory Management System
Example Request
GET https://orderdemo.iqmetrix.net/v1/Companies(14146)/Orders?$filter=State eq 'Pending' and EntityId eq 14202
Authorization: Bearer (Access Token)
Accept: application/json
Example Response
HTTP 200 Content-Type: application/json
[
{
"Id": "65bb1c32-3e6b-4d3f-80b5-2e7c861ce5af",
"OrderTypeId": 1,
"OrderType": "Sales",
"State": "Pending",
"PrintableId": "24T8E9T",
"Name": "XQ-Shelf Cart f71cc25c-cda5-43ed-9288-77c12903968d",
"TenderId": null,
"TenderOrigin": null,
"SourceId": null,
"SourceName": null,
"EntityId": 14192,
"ShippingEntityId": 0,
"CustomerId": "3d778021-2745-4f13-8397-2eca3058a808",
"BillingCustomerId": "3d778021-2745-4f13-8397-2eca3058a808",
"ShippingCustomerId": "3d778021-2745-4f13-8397-2eca3058a808",
"ShippingAddressId": "c253b1bf-3b26-4340-b219-3fe3b6aa1af5",
"BillingAddressId": "c253b1bf-3b26-4340-b219-3fe3b6aa1af5",
"EmployeeId": 0,
"DiscountCode": null,
"DiscountDescription": null,
"DiscountAmount": 0,
"CreatedDateUtc": "2016-03-03T14:22:53.687",
"OrderExpiryHours": 12,
"OrderExpiryDate": "2016-03-04T02:22:53.687"
},
...
]
Getting Items on the Order
To get the Items for each Order, Getting All Items on an Order can be used.
Example Request
GET https://orderdemo.iqmetrix.net/v1/Companies(14146)/Orders(65bb1c32-3e6b-4d3f-80b5-2e7c861ce5af)/Items
Authorization: Bearer (Access Token)
Accept: application/json
Example Response
HTTP 200 Content-Type: application/json
[
{
"Id": "753620e8-589c-4767-be9f-1727f528cb63",
"OrderId": "65bb1c32-3e6b-4d3f-80b5-2e7c861ce5af",
"ItemTypeId": 2,
"ItemType": "InStock",
"ItemStatusId": 9,
"ItemStatus": "New",
"ProductId": "92841bed-454b-42f8-9fb0-4bb29c299c82",
"SupplierEntityId": 0,
"Quantity": 1,
"Cost": 0,
"ListPrice": 0,
"SellingPrice": 10,
"Index": 0,
"Description": "Alexa Mary Jane Flat - Youth",
"SKU": null,
"Notes": null,
"SerialNumbers": [],
"SupplierReference": null,
"TrackingInformation": [],
"ShippingOptionId": null
},
...
]


28 March, 2017
Explore these python blogs on how to code in python 3 and how to make various applications in python from scratch. We have covered python 3, Tkinter and many more things.
28 March, 2017
Explore these python blogs on how to code in python 3 and how to make various applications in python from scratch. We have covered python 3, Tkinter and many more things.
28 March, 2017
Explore these python blogs on how to code in python 3 and how to make various applications in python from scratch. We have covered python 3, Tkinter and many more things.


3/16 email by Kristen Lindvedt
Faculty Center Info Hub (CSI): Welcome to the Faculty Center Information Hub!
Dear Hub Participants,
Welcome to the Faculty Center Information Hub!
Due to the unprecedented events before us due to the COVID-19 virus, it has become imperative for instructors to switch from their current instructional modality to a fully online format. Over the last few days it has become abundantly clear there is a lot of competing and confusing information being circulated that is further muddying the implementation waters. Therefore, in order to assist all faculty with the monumental task of moving courses completely online The Faculty Center for Professional Development have put together a team of emergency personnel, consisting of Academic Technology Manager and CSI Blackboard Administrator Michael Castelli, Academic Technology Specialist Fausto Canella, and former CSI Blackboard Administrator Kristen Lindtvedt to assist you all with the tasks needed to complete the curriculum transfer process by the March 19th deadline set by CUNY.
To better assist you, the Faculty Center has put in place a new interactive online training center called the Faculty Center Information Hub. The Information Hub will be available to all teaching faculty and staff, as well as those designated by Department Heads and Deans as being vital to the instructional process. The Information Hub will contain complete access to Blackboard training materials and workshops, emergency request and general help discussion boards, real-time chat options, and full access to Center team in place to assist you. It will also include a full schedule of virtual training workshops, all of which will be manned by Faculty Center staff members from 9am to 8pm until Friday, March 20.
We are here to help you! The Information Hub is your direct connection to us and we will be giving full access to our dedicated team to assist each and every one of you in any way we possibly can. It is our goal to help your faculty be successful during the remainder of this semester and beyond, and as the days and weeks progress we will be uploading every bit of pertinent information needed for folks to successfully run their classes for the remainder of the semester fully online within Blackboard.
Please be assured that during this quickly changing and confusing time the Faculty Center is fully prepared to assist you. Their newly created “Information Hub” is a direct connection to the assistance needed to complete the curriculum format transition. It provides full access to the dedicated team in place all of whom are able to assist you with your online course needs during the remainder of this semester and beyond.


Come right up and play...
The Guessing Game!
Go ahead: Try guessing a number between 1-100
Go!


Combine multiple data files from a common directory. The data files will be read into R and bound together, creating a single large data.frame. A general function is provided along with a specific function for data that was collected using the open-source experiment builder 'OpenSesame' <http://osdoc.cogsci.nl/>.
| Version: | 1.1.0 |
| Depends: | R (≥ 3.1.0) |
| Imports: | utils, plyr |
| Published: | 2016-10-25 |
| Author: | Pascal J. Kieslich [aut, cre], Felix Henninger [aut] |
| Maintainer: | Pascal J. Kieslich <kieslich at psychologie.uni-mannheim.de> |
| BugReports: | https://github.com/pascalkieslich/readbulk/issues |
| License: | GPL-3 |
| URL: | https://github.com/pascalkieslich/readbulk |
| NeedsCompilation: | no |
| Materials: | README NEWS |
| CRAN checks: | readbulk results |
| Reference manual: | readbulk.pdf |
| Package source: | readbulk_1.1.0.tar.gz |
| Windows binaries: | r-devel: readbulk_1.1.0.zip, r-release: readbulk_1.1.0.zip, r-oldrel: readbulk_1.1.0.zip |
| OS X binaries: | r-release: readbulk_1.1.0.tgz, r-oldrel: readbulk_1.1.0.tgz |
| Old sources: | readbulk archive |
| Reverse suggests: | mousetrap |
Please use the canonical form https://CRAN.R-project.org/package=readbulk to link to this page.


You have 3 Notification
Security 1234 missed the path
Security 2345 not-traced
Security 4567 missed a region
You have 0 Mails
Path checked successfully
There is a problem in logistics area
Path is cleared
Problem in the parking area


Protesters retake part of bridge in central Baghdad
BAGHDAD (Reuters) - Iraqi protesters occupied part of a main bridge in Baghdad on Saturday that security forces had pushed them away from a week before, a Reuters photographer said.
Demonstrators also occupied a tall building overlooking the bridge, taking new ground in the center of the Iraqi capital after protests had appeared to lose momentum.
A bomb blast at a nearby square during the night killed at least three people, police and medics said, but it was not immediately clear who was responsible or whether it was linked to demonstrations.
More than 300 people have been killed during weeks of mass unrest in Baghdad and southern Iraq.
Protests that began in October over lack of jobs and public services have swelled. Demonstrators are now demanding the departure of Iraq’s ruling class and an overhaul of the governance system that has fueled corruption since the toppling of Saddam Hussein in a U.S.-led invasion in 2003.
Security forces have used live ammunition, tear gas and stun grenades against mostly unarmed demonstrators, killing an average of nearly 50 people a week since Oct. 1, according to a Reuters count based on police and medical sources.
More than a dozen members of the security forces have died.
Prime Minister Adel Abdul Mahdi’s government has warned against any violent protest. It is under pressure from powerful religious authorities to ensure violence does not escalate and to enact real reform to improve the lives of Iraqis.
Shi’ite-majority Iraq has suffered decades of war, sanctions and sectarian strife, most recently the brutal rule of Sunni Muslim extremist Islamic State over vast swathes of the north from 2014 to 2017.
But despite a rare period of calm since IS was defeat, many people in the region’s second-largest oil producing country suffer poverty, unemployment and poor healthcare. They accuse lawmakers and senior officials of pocketing public money and doling out jobs and wealth to their own kin or parties.
Demonstrators also decry what they see as foreign interference in the running of the country, including from the United States but especially from Iran whose allies have dominated Iraqi state institutions since 2003.
Iraq closed a southern border crossing with Iran to travelers on Saturday over unrest in both countries, a security official said.


--- layout: post title: "Ironing Master Class" external-url: http://www.youtube.com/watch?v=IeA9gH_iWXY ---
Perfect. On so many levels.


WITNESS LIST Finance Committee (Subcommittee on Crime Victims Fund) April 16, 2002 -10:00A Crime Victim's Fund ON: Baldwin, Howard First Assistant-Attorney General (Office of the Attorney General Office of the Attorney General), Austin, TX Cook, Karen Director of Accounting & Finance (Haris County District Clerk Criminal), Houston, TX Dietz, Rod Account Examiner (State Comptroller's Office - Revenue Acct.), Austin, TX Hawkins, Mary Auditor (State Comptroller's Office), Austin, TX Henry, Rene Collections Project Manager (Office of Court Admin.), Austin, TX Lehman, Jim Collections Project Specialist (Office of Court Admin.), Austin, TX Porter, Quentin Municipal Court Director (Texas Municipal League), San Antonio, TX Sturzl, Frank Executive Director (Texas Municipal League), Austin, TX Wessels, Bob Court Manager (County Courts), Houston, TX


RSpec is a great tool in the behavior-driven development (BDD) process of writing human readable specifications that direct and validate the development of your application.
On the web there are many resources that give complete overview of _what_ you can do with RSpec. But there are fewer resources devoted to how to create a great RSpec test suite.
Better Specs tries to fill this gap by collecting most of the "best practices" that other developers learn through years of experience.
How to describe your methods
Be clear about what method you are describing. For instance, use the Ruby documentation convention of
.
(or ::
) when referring to a class method's name and #
when
referring to an instance method's name.
bad
describe 'the authenticate method for User' do
describe 'if the user is an admin' do
good
describe '.authenticate' do
describe '#admin?' do
Use contexts
Contexts are a powerful method to make your tests clear and well organized. In the long term this practice will keep tests easy to read.
bad
it 'has 200 status code if logged in' do
expect(response).to respond_with 200
end
it 'has 401 status code if not logged in' do
expect(response).to respond_with 401
end
good
context 'when logged in' do
it { is_expected.to respond_with 200 }
end
context 'when logged out' do
it { is_expected.to respond_with 401 }
end
When describing a context, start its description with "when", "with" or "without".
<%= render "partials/share", text: "betterspecs.org | use contexts", url: "http://betterspecs.org/#contexts" %>Keep your description short
A spec description should never be longer than 40 characters. If this happens you should split it using a context.
bad
it 'has 422 status code if an unexpected params will be added' do
good
context 'when not valid' do
it { is_expected.to respond_with 422 }
end
In the example we removed the description related to the status code,
which has been replaced by the expectation it { is_expected.to respond_with 422 }
.
If you run this test typing rspec filename
you will obtain a readable output.
Formatted Output
when not valid
it should respond with 422
Single expectation test
The 'one expectation' tip is more broadly expressed as 'each test should make only one assertion'. This helps you on finding possible errors, going directly to the failing test, and to make your code readable.
In isolated unit specs, you want each example to specify one (and only one) behavior. Multiple expectations in the same example are a signal that you may be specifying multiple behaviors.
Anyway, in tests that are not isolated (e.g. ones that integrate with a DB, an external webservice, or end-to-end-tests), you take a massive performance hit to do the same setup over and over again, just to set a different expectation in each test. In these sorts of slower tests, I think it's fine to specify more than one isolated behavior.
good (isolated)
it { is_expected.to respond_with_content_type(:json) }
it { is_expected.to assign_to(:resource) }
Good (not isolated)
it 'creates a resource' do
expect(response).to respond_with_content_type(:json)
expect(response).to assign_to(:resource)
end
Test all possible cases
Testing is a good practice, but if you do not test the edge cases, it will not be useful. Test valid, edge and invalid case. For example, consider the following action.
Destroy action
before_filter :find_owned_resources
before_filter :find_resource
def destroy
render 'show'
@consumption.destroy
end
The error I usually see lies in testing only whether the resource has been removed. But there are at least two edge cases: when the resource is not found and when it's not owned. As a rule of thumb think of all the possible inputs and test them.
bad
it 'shows the resource'
good
describe '#destroy' do
context 'when resource is found' do
it 'responds with 200'
it 'shows the resource'
end
context 'when resource is not found' do
it 'responds with 404'
end
context 'when resource is not owned' do
it 'responds with 404'
end
end
Expect vs Should syntax
On new projects always use the expect
syntax.
bad
it 'creates a resource' do
response.should respond_with_content_type(:json)
end
good
it 'creates a resource' do
expect(response).to respond_with_content_type(:json)
end
Configure the RSpec to only accept the new syntax on new projects, to avoid having the 2 syntax all over the place.
good
# spec_helper.rb
RSpec.configure do |config|
# ...
config.expect_with :rspec do |c|
c.syntax = :expect
end
end
On one line expectations or with implicit subject we should use is_expected.to
.
bad
context 'when not valid' do
it { should respond_with 422 }
end
good
context 'when not valid' do
it { is_expected.to respond_with 422 }
end
On old projects you can use the transpec to convert them to the new syntax.
More about the new RSpec expectation syntax can be found here and here.
<%= render "partials/share", text: "betterspecs.org | Expect vs Should syntax", url: "http://betterspecs.org/#expect" %>Use subject
If you have several tests related to the same subject use
subject{}
to DRY them up.
bad
it { expect(assigns('message')).to match /it was born in Belville/ }
good
subject { assigns('message') }
it { is_expected.to match /it was born in Billville/ }
RSpec has also the ability to use a named subject.
Good
subject(:hero) { Hero.first }
it "carries a sword" do
expect(hero.equipment).to include "sword"
end
Learn more about rspec subject.
<%= render "partials/share", text: "betterspecs.org | use subject", url: "http://betterspecs.org/#subject" %>Use let and let!
When you have to assign a variable instead of using a before
block to create
an instance variable, use let
. Using let
the variable lazy loads
only when it is used the first time in the test and get cached until that specific test is
finished. A really good and deep description of what let
does can be found in this
stackoverflow answer.
bad
describe '#type_id' do
before { @resource = FactoryGirl.create :device }
before { @type = Type.find @resource.type_id }
it 'sets the type_id field' do
expect(@resource.type_id).to<EMAIL_ADDRESS>end
end
good
describe '#type_id' do
let(:resource) { FactoryGirl.create :device }
let(:type) { Type.find resource.type_id }
it 'sets the type_id field' do
expect(resource.type_id).to equal(type.id)
end
end
Use let
to initialize actions that are lazy loaded to test your specs.
good
context 'when updates a not existing property value' do
let(:properties) { { id: Settings.resource_id, value: 'on'} }
def update
resource.properties = properties
end
it 'raises a not found error' do
expect { update }.to raise_error Mongoid::Errors::DocumentNotFound
end
end
Use let!
if you want to define the variable when the block is defined.
This can be useful to populate your database to test queries or scopes.
Here an example of what let actually is.
good
# this:
let(:foo) { Foo.new }
# is very nearly equivalent to this:
def foo
@foo ||= Foo.new
end
Learn more about rspec let.
<%= render "partials/share", text: "betterspecs.org | use let and let!", url: "http://betterspecs.org/#let" %>Mock or not to mock
There's a debate going on. Do not (over)use mocks and test real behavior when possible. Testing real cases are useful when updating your application flow.
good
# simulate a not found resource
context "when not found" do
before do
allow(Resource).to receive(:where).with(created_from: params[:id])
.and_return(false)
end
it { is_expected.to respond_with 404 }
end
Mocking makes your specs faster but they are difficult to use. You need to understand them well to use them well. Read more about.
<%= render "partials/share", text: "betterspecs.org | mock or not to mock", url: "http://betterspecs.org/#mock" %>Create only the data you need
If you have ever worked in a medium size project (but also in small ones), test suites can be heavy to run. To solve this problem, it's important not to load more data than needed. Also, if you think you need dozens of records, you are probably wrong.
good
describe "User" do
describe ".top" do
before { FactoryGirl.create_list(:user, 3) }
it { expect(User.top(2)).to have(2).item }
end
end
Use factories and not fixtures
This is an old topic, but it's still good to remember it. Do not use fixtures because they are difficult to control, use factories instead. Use them to reduce the verbosity on creating new data.
bad
user = User.create(
name: 'Genoveffa',
surname: 'Piccolina',
city: 'Billyville',
birth: '17 Agoust 1982',
active: true
)
good
user = FactoryGirl.create :user
One important note. When talking about unit tests the best practice would be to use neither fixtures or factories. Put as much of your domain logic in libraries that can be tested without needing complex, time consuming setup with either factories or fixtures. Read more in this article
Learn more about Factory Girl.
<%= render "partials/share", text: "betterspecs.org | use factories and not fixtures", url: "http://betterspecs.org/#factories" %>Easy to read matcher
Use readable matchers and double check the available rspec matchers.
bad
lambda { model.save! }.to raise_error Mongoid::Errors::DocumentNotFound
good
expect { model.save! }.to raise_error Mongoid::Errors::DocumentNotFound
Shared Examples
Making tests is great and you get more confident day after day. But in the end you will start to see code duplication coming up everywhere. Use shared examples to DRY your test suite up.
bad
describe 'GET /devices' do
let!(:resource) { FactoryGirl.create :device, created_from: user.id }
let(:uri) { '/devices' }
context 'when shows all resources' do
let!(:not_owned) { FactoryGirl.create factory }
it 'shows all owned resources' do
page.driver.get uri
expect(page.status_code).to be(200)
contains_owned_resource resource
does_not_contain_resource not_owned
end
end
describe '?start=:uri' do
it 'shows the next page' do
page.driver.get uri, start: resource.uri
expect(page.status_code).to be(200)
contains_resource resources.first
expect(page).to_not have_content resource.id.to_s
end
end
end
good
describe 'GET /devices' do
let!(:resource) { FactoryGirl.create :device, created_from: user.id }
let(:uri) { '/devices' }
it_behaves_like 'a listable resource'
it_behaves_like 'a paginable resource'
it_behaves_like 'a searchable resource'
it_behaves_like 'a filterable list'
end
In our experience, shared examples are used mainly for controllers. Since models are pretty different from each other, they (usually) do not share much logic.
Learn more about rspec shared examples.
<%= render "partials/share", text: "betterspecs.org | shared examples", url: "http://betterspecs.org/#sharedexamples" %>Test what you see
Deeply test your models and your application behaviour (integration tests). Do not add useless complexity testing controllers.
When I first started testing my apps I was testing controllers, now I don't. Now I only create integration tests using RSpec and Capybara. Why? Because I truly believe that you should test what you see and because testing controllers is an extra step you don't need. You'll find out that most of your tests go into the models and that integration tests can be easily grouped into shared examples, building a clear and readable test suite.
This is an open debate in the Ruby community and both sides have good arguments supporting their idea. People supporting the need of testing controllers will tell you that your integration tests don't cover all use cases and that they are slow.
Both are wrong. You can easily cover all use cases (why shouldn't you?) and you can run single file specs using automated tools like Guard. In this way you will run only the specs you need to test blazing fast without stopping your flow.
<%= render "partials/share", text: "betterspecs.org | test what you see", url: "http://betterspecs.org/#integration" %>Don't use should
Do not use should when describing your tests. Use the third person in the present tense. Even better start using the new expectation syntax.
bad
it 'should not change timings' do
consumption.occur_at.should == valid.occur_at
end
good
it 'does not change timings' do
expect(consumption.occur_at).to equal(valid.occur_at)
end
See the should_not gem for a way to enforce this in RSpec and the should_clean gem for a way to clean up existing RSpec examples that begin with "should."
<%= render "partials/share", text: "betterspecs.org | don't use should", url: "http://betterspecs.org/#should" %>Automatic tests with guard
Running all the test suite every time you change your app can be cumbersome. It takes a lot of time and it can break your flow. With Guard you can automate your test suite running only the tests related to the updated spec, model, controller or file you are working at.
good
bundle exec guard
good
guard 'rspec', cli: '--drb --format Fuubar --color', version: 2 do
# run every updated spec file
watch(%r{^spec/.+_spec\.rb$})
# run the lib specs when a file in lib/ changes
watch(%r{^lib/(.+)\.rb$}) { |m| "spec/lib/#{m[1]}_spec.rb" }
# run the model specs related to the changed model
watch(%r{^app/(.+)\.rb$}) { |m| "spec/#{m[1]}_spec.rb" }
# run the view specs related to the changed view
watch(%r{^app/(.*)(\.erb|\.haml)$}) { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
# run the integration specs related to the changed controller
watch(%r{^app/controllers/(.+)\.rb}) { |m| "spec/requests/#{m[1]}_spec.rb" }
# run all integration tests when application controller change
watch('app/controllers/application_controller.rb') { "spec/requests" }
end
Guard is a fine tool but as usual it doesn't fit all of your needs. Sometimes your TDD workflow works best with a keybinding that makes it easy to run just the examples you want when you want to. Then, you can use a rake task to run the entire suite before pushing code. Find an example vim keybinding here.
Learn more about guard-rspec.
<%= render "partials/share", text: "betterspecs.org | automatic tests with guard", url: "http://betterspecs.org/#guard" %>Faster tests (preloading Rails)
When running a test on Rails the whole Rails app is loaded. This can take time and it can break your development flow. To solve this problem use solutions like Zeus, Spin or Spork. Those solutions will preload all libraries you (usually) do not change and reload controllers, models, view, factories and all the files you change most often.
Here you can find a spec helper and a Guardfile configuration based on Spork. With this configuration you will reload the whole app if a preloaded file (like initializers) change and you will run the single tests really, really fast.
The drawback of using Spork is that it aggressively monkey-patches your code and you could lose some hours trying to understand why a file is not reloaded. If you have some code examples using Spin or any other solution let us know.
Here you can find a Guardfile configuration for using Zeus. The spec_helper does not need to be modified, however, you will have to run `zeus start` in a console to start the zeus server before running your tests.
Although Zeus takes a less aggressive approach than Spork, one major drawback is the fairly strict usage requirements; Ruby 1.9.3+ (recommended using backported GC from Ruby 2.0) as well as an operating system that supports FSEvents or inotify is required.
Many criticisms are moved to those solutions. Those libraries are a band aid on a problem that is better solved through better design, and being intentional about only loading the dependencies that you need. Learn more reading the related discussion.
<%= render "partials/share", text: "betterspecs.org | faster tests with spork", url: "http://betterspecs.org/#spork" %>Stubbing HTTP requests
Sometimes you need to access external services. In these cases you can't rely on the real service but you should stub it with solutions like webmock.
good
context "with unauthorized access" do
let(:uri) { 'http://api.lelylan.com/types' }
before { stub_request(:get, uri).to_return(status: 401, body: fixture('401.json')) }
it "gets a not authorized notification" do
page.driver.get uri
expect(page).to have_content 'Access denied'
end
end
Learn more about webmock and VCR. Here a nice presentation explaining how to mix them together.
<%= render "partials/share", text: "betterspecs.org | mocking http requests", url: "http://betterspecs.org/#http" %>Useful formatter
Use a formatter that can give you useful information about the test suite. I personally find fuubar really nice. To make it work add the gem and set fuubar as default formatter in your Guardfile.
good
# Gemfile
group :development, :test do
gem 'fuubar'
good
# .rspec
--drb
--format Fuubar
--color
Learn more about fuubar.
<%= render "partials/share", text: "betterspecs.org | useful formatter", url: "http://betterspecs.org/#formatter" %>Books
<%= render "partials/books" %>Presentations
Resources on the web
<%= render "partials/links" %>Screencasts
<%= render "partials/screencasts" %>Libraries (documentation)
<%= render "partials/libraries" %>Styleguide
We are seeking for the best guidelines to write "nice to read" specs. Right now a good starting point is for sure the Mongoid test suite. It uses a clean style and easy-to-read specs, following most of the guidelines described here.
Improving Better Specs
This is an open source project. If something is missing or incorrect just file an issue to discuss the topic. Also check the following issues:
- Multilanguage (file an issue if you want to translate this guide)
Credits
This project was created by and released as open-source thanks to Lelylan, a new platform to monitor and control your devices through a simple, open and robust REST API.
If you like what I'm doing offer me a coffe


@Documented @Retention(value=RUNTIME) @Target(value=FIELD) public @interface Delegate
All public instance methods present in the type of the annotated field and not present in the owner class will be added to owner class at compile time. The implementation of such automatically added methods is code which calls through to the delegate as per the normal delegate pattern.
As an example, consider this code:
class Event {
@Delegate
Date when
String title, url
}
def gr8conf = new Event(title: "GR8 Conference",
url: "http://www.gr8conf.org",
when: Date.parse("yyyy/MM/dd", "2009/05/18"))
def javaOne = new Event(title: "JavaOne",
url: "http://java.sun.com/javaone/",
when: Date.parse("yyyy/MM/dd", "2009/06/02"))
assert gr8conf.before(javaOne.when)
In this example, the Event
class will have a method called
before(Date otherDate)
as well as other public methods of the
Date
class.
The implementation of the before()
method will look like this:
public boolean before(Date otherDate) { return when.before(otherDate); }By default, the owner class will also be modified to implement any interfaces implemented by the field. So, in the example above, because
Date
implements Cloneable
the following will be true:
assert gr8conf instanceof CloneableThis behavior can be disabled by setting the annotation's
interfaces
element to false,
i.e. @Delegate(interfaces = false)
, e.g. in the above
example, the delegate definition would become:
@Delegate
(interfaces = false) Date when
and the following would be true:
assert !(gr8conf instanceof Cloneable)If multiple delegate fields are used and the same method signature occurs in more than one of the respective field types, then the delegate will be made to the first defined field having that signature. If this does occur, it might be regarded as a smell (or at least poor style) and it might be clearer to do the delegation by long hand.
By default, methods of the delegate type marked as @Deprecated
are
not automatically added to the owner class (but see the technical note
about interfaces below). You can force these methods to
be added by setting the annotation's deprecated
element to true,
i.e. @Delegate(deprecated = true)
.
For example, in the example above if we change the delegate definition to:
@Delegate
(deprecated = true) Date when
then the following additional lines will execute successfully (during 2009):
assert gr8conf.year + 1900 == 2009 assert gr8conf.toGMTString().contains(" 2009 ")Otherwise these lines produce a groovy.lang.MissingPropertyException or groovy.lang.MissingMethodException respectively as those two methods are
@Deprecated
in Date
.
Technical notes:
GroovyObject
interface
are not candidates for delegation@Delegate
field@Delegate
field@Delegate
with default method arguments is known not to work in some cases.
We recommend not using these features together.deprecated
attribute will be
ignored if the owner class implements that interface (i.e. you must set interfaces=false
if you want the deprecated
attribute to be used). Otherwise, the resulting class would
not compile anyway without manually adding in any deprecated methods in the interface.| Modifier and Type | Optional Element and Description |
|---|---|
boolean |
deprecated
Whether to apply the delegate pattern to deprecated methods; to avoid compilation
errors, this is ignored if the type of the delegate field is an interface and
interfaces=true . |
String[] |
excludes
List of method and/or property names to exclude when delegating.
|
Class[] |
excludeTypes
List of interfaces containing method signatures to exclude when delegating.
|
String[] |
includes
List of method and/or property names to include when delegating.
|
Class[] |
includeTypes
List of interfaces containing method signatures to exclude when delegating.
|
boolean |
interfaces |
boolean |
methodAnnotations
Whether to carry over annotations from the methods of the delegate
to your delegating method.
|
boolean |
parameterAnnotations
Whether to carry over annotations from the parameters of delegate
methods to your delegating method.
|
public abstract boolean interfaces
public abstract boolean deprecated
interfaces=true
.public abstract boolean methodAnnotations
public abstract boolean parameterAnnotations
public abstract String[] excludes
public abstract Class[] excludeTypes
public abstract String[] includes
public abstract Class[] includeTypes


See the Container Elements page for a basic explanation
of layout directives.
To make your layout change depending upon the device screen size, there are
other layout
directives available:
| API | Activates when device |
|---|---|
| layout | Sets default layout direction unless overridden by another breakpoint. |
| layout-xs | width < 600px |
| layout-gt-xs | width >= 600px |
| layout-sm | 600px <= width < 960px |
| layout-gt-sm | width >= 960px |
| layout-md | 960px <= width < 1280px |
| layout-gt-md | width >= 1280px |
| layout-lg | 1280px <= width < 1920px |
| layout-gt-lg | width >= 1920px |
| layout-xl | width >= 1920px |
layout-margin
adds margin around each flex
child. It also adds a margin to the layout
container itself.
layout-padding
adds padding inside each flex
child. It also adds padding to the layout
container itself.
layout-fill
forces the layout element to fill its parent container.
Here is a non-trivial group of flex
elements using layout-wrap
layout-wrap
allows flex
children to wrap within the container if the elements use more
than 100%.
Use the show
hide
APIs to responsively show or hide elements. While these work similar
to ng-show
and ng-hide
, these AngularJS Material Layout directives are mediaQuery-aware.
| hide (display: none) | show (negates hide) | Activates when: |
|---|---|---|
| hide-xs | show-xs | width < 600px |
| hide-gt-xs | show-gt-xs | width >= 600px |
| hide-sm | show-sm | 600px <= width < 960px |
| hide-gt-sm | show-gt-sm | width >= 960px |
| hide-md | show-md | 960px <= width < 1280px |
| hide-gt-md | show-gt-md | width >= 1280px |
| hide-lg | show-lg | 1280px <= width < 1920px |
| hide-gt-lg | show-gt-lg | width >= 1920px |
| hide-xl | show-xl | width >= 1920px |


Hello,
I'm Tibor Z. Petényi, stamp artist, illustrator with a few hocus pocus and art director at Young&Rubicam Budapest Advertising Agency. I'm addicted to small details and stamps. This is my private portfolio, enjoy and don't hesitate to contact me if you think I can be of any service to you.
Tibor Z. Petényi


--- layout: post status: publish published: true title: Teach Your Children Well author: display_name: Andy login: Andy email<EMAIL_ADDRESS>url: '' author_login: Andy author_email<EMAIL_ADDRESS>wordpress_id: 6524 wordpress_url: http://ivyenvy.com/?p=6524 date: '2011-12-17 08:39:43 +0000' date_gmt: '2011-12-17 14:39:43 +0000' categories: - Offense - Outfield - Cubs fans tags: - Alfonso Soriano comments: [] ---
The last page of my son's Chicago Cubs ABC book. It's important to teach your children now what they should expect from Soriano since they will be adults when his contract comes off the books. "Son, when this guy comes to the plate, you can expect a gaping black-hole of a strike zone and plenty of zeroes (on the scoreboard). Also, be on the lookout for those zigzaggers heading for the infield."


WITNESS LIST Licensing & Administrative Procedures Committee April 20, 2005-10:30A HB 2128 Against: McKnight, Peyton (Texas Council of Enigineering Companies) Schulle, Jr., Gerhardt (Texas Society of Professional Engineers) HB 2128 - Committee Substitute (CSHB 2128) On: Farrow, Dale Beebe (Texas Board of Professional Engineers) HB 2590 - Committee Substitute (CSHB 2590) For: Girault, David (Self and Wine Styles, Inc.) HB 2836 For: Brooks, Baine (Self) HB 2856 For: Cullen, Sue (Self) Friese, Jan (Texas Counseling Association) On: Kuntz, Jr., William (Texas Department of Licensing & Regulation) HB 3004 For: Gerstenschlager, MerryLynn (Self and Texas Eagle Forum) LaFreniere, Carole (Self) Miller, David (City of Kennedale) Against: Burch, Scott (Burch Mgt.) Gonzalez, Victor (First Amendment Coalition of Texas) Swander, Steven (Texas Entertainment Association) HB 3343 Against: Gerstenschlager, MerryLynn (Self and Texas Eagle Forum) HB 3344 On: Zgabay (skyby), Sherrie (Texas Departrment of Public Safety)


W3C organization
Search with google
My portfolio site
Amazing pack of knowledge
GIT version control system


Who We Are
Kili Master is a tourism industry leader in Tanzania, which is dedicated to providing our clients with the most unique experience while our mission is to create a special holiday for our clients in Tanzania. We are passionate, inspired and dynamic to hear client’s voice and customize their trips according to their demands and budgets. Join us and have a wonderful adventure together!
About The Founder
Hamza M. Shiraz and Salim H. Chamshama
Hamza
Salim
Their experience
Hamza M. Shiraz and Salim H. Chamshama were born in Moshi Town, where the famous Kilimanjaro Mountain is located.
Hamza has worked as a porter in the tourism industry for many years and later he decided to be a guide. As for Salim, he enrolled in a Tourism College after graduated from high school.
Both of them are specialized in mountain climbing and safari. They fully understand client needs and the quality service that the local tourism demands. They are always proud of their work and the knowledge they learn from different clients. Their hard working and quality service eventually helped them to attract investment from their previous clients, which helped them to set up their own company and fulfill their dream. Having worked as a porter and a guide was a very interesting journey for them. Although this journey is along with challenges and obstacles, with “mountain mentality”, they believe this is the new start to their dream.
Their dream
To set up their own company is not Hamza’s ultimate goal; this is only a start to their dream. “There are a lot of people need help in Africa, economy needs to be developed, children need to be educated and women need to earn more equal rights. I have been in this industry for 10 years since I started with being a porter. I had a really hard time, but because of my hard work and dedication to provide quality service, I finally started my own career. I am lucky. “Ｈamza wishes that one day he can help the people in the area of Mountain Kilimanjaro. “While running my company, I hope I can do something to benefit the community, like providing more jobs, improving the equal rights in work, doing more charity . This is not a joke. It is the road we are going through. Moshi is where I been born and raised; Tanzania is the country I deeply love. I hope more people come to my country, get to know her, fall in love with her and make it better with us.”
Salim has been interested in tourism since his childhood. He has a chance to get into the government college, which means decent work and steady income, but he gave up and insisted to turn to the tourism college, inspired of family objection. “I love mountain”, when climbing with Salim, you can always hear he says that mountain is his office. “Mountain Kilimanjaro has always been Tanzanian proud and dignity. “It is not just a mountain; it means freedom.
“Uhuru”means freedom in local language. We overcome difficulties during the mountain climbing and set our soul free eventually. “This is the meaning of climbing. I hope one day that I might have to explain to people that how important and interesting climbing Mount Kilimanjaro is.”
They believe in their dream and they are in the practice of making their dream come true. As Chinese entrepreneur Jacky Ma said，”You still need to have a dream. What if it came true?”


DataBeers is a non-profit and open community whose mission is to become a summit for professionals and students inside the scope of Big Data and Data Science to discuss and share experiences also promoting events where everybody with an interest in data is welcome to exchange their knowledge.
Databeers is an international community in which we invite all the people who are interested in learning and sharing their experiences with the data while enjoying a few beers. This is an event for data scientists journalists, documentalists, data artists, developers, engineers, etc. In summary for all those that are working, using, treating, visualizing, discovering, exploting, ... data.
DataBeers was fundend in May 2014 by Giovanna Miritello(@gmiritello), Marcelo Soria (@msoriaro) and Dani Villatoro (@dani_agent) in Madrid. Since then this event has spread in several cities around the world making this community bigger.
Ana Valdivia
@ana_valdi
Data Scientist UGR
Sentiment Analysis
Manuel Parra
@manugrapevine
PhD. student UGR
Big Data Time Series Data Mining


This page contains reference information about how to build and debug the MyBatis Generator (MBG) feature from source.
The feature is built using Eclipse Tycho - which is Maven support for Eclipse projects. Tycho is a thin wrapper over the normal Eclipse PDE build processes. Even though some of the projects have a pom.xml, the projects are not structured like normal Maven projects. Within Eclipse, you still need to use normal PDE support and editors to modify the feature. Do not try to import the projects into your IDE as Maven projects - it will not work. The projects need to be imported as regular Eclipse projects.
There are eleven total projects that makeup the feature. Some projects are just for build support and testing.
The published MBG feature is composed of five different Eclipse projects - a feature project, and four plugin projects. The feature project groups the four plugins together for easy installation. Those projects are structured as follows:
| Project | Description |
|---|---|
org.mybatis.generator |
This project is the Eclipse feature project for MBG. |
org.mybatis.generator.core |
This plugin holds the Java source for the core MBG library. Source from the core MBG source tree is copied into this plugin during the build. There is an Ant build file in this plugin (copySource.xml) that performs the copy. If you find a bug in the core MBG, you must make the correction in the core source tree - NOT this plugin. |
org.mybatis.generator.eclipse.core |
This plugin holds Java support classes for the other plugins. This plugin does not contribute to the Eclipse user interface. This plugin includes classes for Java file merging, and Eclipse implementations of the MBG callback interfaces. |
org.mybatis.generator.eclipse.doc |
This plug-in holds the documentation for MBG. There is an Ant build file in this plugin (buildDoc.xml) that will build the documentation and package it for inclusion into the Eclipse help system. The Ant script merges the core MBG documentation into the eclpse documentation. If you need to correct something in the core MBG documentation, you must make the correction in the core MPB project - NOT the eclipse documentation project. |
org.mybatis.generator.eclipse.ui |
This plug-in holds the Java code for the Eclipse user interface for MBG. If you
are experiencing trouble with the plugin specific features (like the integrated Ant task), then
the code for those features will be found in this plugin. An Ant script in this plugin
(copyDtds.xml) will copy the DTDs from the core MBG source tree into a location suitable for
packaging in this plugin.
This plugin also contains a custom Ant builder for the Ant task. This is required because of the way that eclipse accepts contributed Ant tasks - they need to be in a separate JAR from the main plugin. |
There are six other Eclipse projects that are used in the build of the feature:
| Project | Description |
|---|---|
org.mybatis.generator.eclipse.site |
This project is a P2 publishing site that is used to publish the feature. |
org.mybatis.generator.eclipse.core.tests |
This project is a plugin fragment that holds unit tests for the org.mybatis.generator.eclipse.core plugin. |
org.mybatis.generator.eclipse.ui.tests |
This project is a plugin fragment that holds unit tests for the org.mybatis.generator.eclipse.ui plugin. |
org.mybatis.generator.eclipse.test.utilities |
This project is a plugin that contains specialized AST visitors and custom Hamcrest (http://hamcrest.org) matchers that are used in the test fragments for writing unit tests that cover the Java merge functionality. |
org.mybatis.generator.eclipse.test.utilities.tests |
This project is a plugin fragment that holds tests for the org.mybatis.generator.eclipse.test.utilities plugin. |
releng |
This project is a simple project that holds other items useful during the build. |
The following instructions show how to setup an Eclipse workspace for building the MBG feature and plug-ins from the latest source in the GitHub repository. We assume that you are somewhat familiar with git and the Eclipse plug-in development environment (PDE).
releng
project. To activate
the target platform, open the proper target file and click on the link that says "Set as active target platform". This action
may take a few minutes to complete. The README in the releng project contains information about which target platform file to use.
org.mybatis.generator.core
project. There are two ways to solve this:
pom.xml
in the
parent directory of all Eclipse projects (../eclipse)
A slight warning: this will download many
dependent JARs from Maven central and eclipse.org the first time you run it.
This method is preferred because it runs the full build for all the plugins. This will make is possible to debug all of the plugin features including documentation.
copySource.xml
Ant file in the org.mybatis.generator.core
project. This should resolve the build errors.
At this point the projects should be successfully compiled in Eclipse. If you want to debug something in the plug-in, you will need to start another instance of Eclipse in debug mode. The following instructions explain how to do this.
Once you have the other instance of Eclipse started you should create a new Java project in the new workspace, create and fill out an MBG configuration file, and then run MBG. MBG should eventually hit your breakpoint, and then you step through the code. Note that the "Manual Test Scripts" page in these instructions has instructions for creating a test project if you need one.
The following classes will likely be of the most interest in debugging:
| Class | Description |
|---|---|
org.mybatis.generator.eclipse.ui.launcher.GeneratorLaunchConfigurationDelegate |
This class is used by eclipse launch support to execute a launch. If you are
experiencing a problem where the attributes you set in a launch configuration seen
to be ignored or aren't working, you should set a breakpoint in the
launch method of this class to follow the launch from the beginning.
Note that the launcher uses Ant under the covers, so this method simply sets up an Ant environment and launches Ant. If you are experiencing issues in the core functionality of MBG, see below for a better staring point. |
org.mybatis.generator.eclipse.ui.ant.GeneratorAntTask |
The MBG launcher uses Ant under the covers, and will eventually cause this task
to be executed. You can set a breakpoint in the execute method of this
class to follow the MBG code generation process from the beginning.
Note that eclipse will not be able to find the source code initially, so the
debug window will just show a blank class file. Add the |
org.mybatis.generator.eclipse.core.merge.JavaFileMerger |
This class implements the Java file merge function. You can set a breakpoint
in the getMergedSource method to follow the merging process.
|
The plugin fragment project org.mybatis.generator.eclipse.core.tests
contains unit tests for many of the classes in the
org.mybatis.generator.eclipse.core
project.
These tests cover the core functionality of Java code merging and workspace file resolution
that is an extra capability added by the eclipse feature.
The tests will be run during a maven build of the feature, but you can also run them directly in eclipse. Running these unit tests is similar to running regular unit tests in eclipse with the following exceptions:
To run all tests, run the class org.mybatis.generator.eclipse.core.tests.RunAllTests
which contains a test suite of all unit tests.
The documentation for MBG is integrated into the Eclipse help system.
The documentation is partially generated (JavaDocs), partially copied in from the
core MBG source tree, and partially maintained in the plugin itself.
This full documentation set is not in source control because it is partially generated. If you would
like to rebuild the documentation, simply execute the buildDoc.xml
file
in the org.mybatis.generator.eclipse.doc
project (an Ant build file).
This step is included in the Maven build, so if you are using the Maven build you will
not need to do this.
If you want to build an updated version of the feature and distribute it locally, then follow these steps:
target/repository
directory of the org.mybatis.generator.eclipse.site
project.After the build executes, the easiest way to install this new version of the feature is to create a new local repository that points to this directory (Help>Install New Software...) and install the new version with P2.
If you are interested in publishing a new version to JFrog, please see the instructions on the Publishing page.


HashMap.js is a library which adds HashMaps to JavaScript. While some modern browsers support Maps, this library supports all browsers back to even IE8!
This library also works well with the Stream.js library.
Setting a value using a complex object as a key:
var statuses = new HashMap();
var user = {names: ['Paul',' PaulBGD'], logged_in: true};
statuses.put(user, 'online');
console.log('Paul\'s Status: ' + statuses.get(user));
// => Paul's Status: online
Getting a value, or adding a default one:
console.log('Paul\'s Status: ' + statuses.getOrCompute(user, function (user) {
return database.getStatus(user);
}));
// => Paul's Status: online
Using the Stream.js library to get all online usernames:
new Stream(status.entries)
.filter(function (entry) { return entry.value == 'online' })
.map(function (entry) { return entry.key.username })
.forEach(function (username) {
console.log(username + ' is online!');
});
new HashMap() => HashMap
Creates a new HashMap.
HashMap.prototype.get(key:Object) => Object
Returns the value associated with the key
HashMap.prototype.put(key:Object, value:Object) => Object
Sets a value associated with the key, returns the previous value if it was set.
HashMap.prototype.remove(key:Object) => Object
Removes an entry from the specified key, returns the entry removed if it exists.
HashMap.prototype.toArray() => Array
An array containing all of the entries.
HashMap.prototype.size => Number
Returns the size of this HashMap


{% extends 'eha/base.html' %} {% comment 'LICENSE' %} Copyright (C) 2023 by eHealth Africa : http://www.eHealthAfrica.org See the NOTICE file distributed with this work for additional information regarding copyright ownership. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. {% endcomment %} {% load render_bundle from webpack_loader %} {% block style %} {% include 'gather/styles.html' %} {% endblock style %} {% block scripts %} {# Common JS libraries #} {% render_bundle 'common' %} {% endblock scripts %} {% block content %} {% block navbar %} {% include 'gather/navbar.html' %} {% endblock navbar %}


home
Train
Networks
Run
Data structures
Settings
add
settingstz
New Data Structure
Data Structure name
OpenHab Data
Function Approximation
openhab coming soon...
functions
Function
drag_handle
From
To
play_arrow
start train
stop
stop train
Stochastic Gradient Decent
RMSProp (comming later)
Adagrad (comming later)
Optimizer
Learn rate
Network Progress
add
New neural network
network name
hidden layers
neurons per layer
Settings
Section 1
Stuff
Section 2
Stuff
Section 3
Stuff
Debug console
Send