Multiple path planning algorithms are implemented in this assignment. These algorithms include A-star, DFS, BFS and greedy best first search. Each of them has their pros and cons. This report will compare and analysis their difference and propose a use case when they are appropriate.
First of all, the performance of these algorithms will be compared in the setting of same start and end point on different maps.
Figure 1. A-star result in empty space
Figure 2. A-star result in 3 sec space
Figure 3. A-star result in misc space
Figure 4. A-star result in narrow1 space
Figure 5. A-star result in narrow2 space
Figure 6. DFS result in empty space
Figure 7. DFS result in 3 sec space
Figure 8. DFS result in misc space
Figure 9. DFS result in narrow1 space
Figure 10. DFS result in narrow2 space
Figure 11. BFS result in empty space
Figure 12. BFS result in 3 sec space
Figure 13. BFS result in misc space
Figure 14. BFS result in narrow1 space
Figure 15. BFS result in narrow2 space
Figure 16. Greedy result in empty space
Figure 17. Greedy result in 3 sec space
Figure 18. Greedy result in misc space
Figure 19. Greedy result in narrow1 space
Figure 20. Greedy result in narrow2 space
| Algorithm | Scene | Iteration | Path Length |
|---|---|---|---|
| a-star | empty | 2873 | 8 |
| DFS | empty | 1281 | 128 |
| BFS | empty | 3501 | 8 |
| greedy | empty | 81 | 8 |
| a-star | misc | 2611 | 9.8 |
| DFS | misc | 1590 | 95.8 |
| BFS | misc | 3235 | 9.8 |
| greedy | misc | 2074 | 17.8 |
| a-star | narrow1 | 934 | 8 |
| DFS | narrow1 | 685 | 66.2 |
| BFS | narrow1 | 1568 | 8 |
| greedy | narrow1 | 81 | 8 |
| a-star | narrow2 | 1394 | 11.4 |
| DFS | narrow2 | 649 | 62.6 |
| BFS | narrow2 | 2095 | 11.4 |
| greedy | narrow2 | 138 | 11.4 |
| a-star | 3 section | 2538 | 14.2 |
| DFS | 3 section | 1071 | 95.6 |
| BFS | 3 section | 3165 | 14.2 |
| greedy | 3 section | 905 | 14.4 |
Table 1. Algorithm Outcome in Different Scenes with Same Start and Goal Point
As shown by the figures above, BFS, a-star always produce the shortest path towards the goal. Greedy best first search produce a result that is less optimized under certain configuration. DFS, on the other hand, produce a bad result even if it usually have a low iteration count.
A-star algorithm is definitely the most robust and optimized path planning algorithm among these four because it reduced the amount of computation for a considerable amount by biasing the searching process towards the target. In addition, it still take the environment into account so that it won't miss the best route along the search. This is especially important when being applied to robotics because of robotics' nature of interating with unpredictable environment.
However, greedy best first search(GBFS) is still worth considering. If the robot is expected to work in an environment such that is stable and has minimum amount of obstacles, GBFS can be a better choice. By putting the robot in a more predictable environment, the robot is more likely to avoid the extra computation caused by incorrect prediction from GBFS. Moreover, GBFS significantly cut off the computational complexity. This can free up memory and power for the robot to perform other processes.
Finally, DFS and BFS may not be a good choice for path planning, but if the robot need to explore the entire map for some purpose. They can be more useful than the other two because neither A-star nor GBFS explore the entire map.In addition, for map exploration, DFS would be serve the purpose better. As shown by the statistisc, DFS generally have an iteration count that is less than half of BFS's iteration count.
In the previous section, the algorithms analyzed on whether they are appropriate for robot path planning. In this Section, algorithms fit for the purpose(A-star, GBFS) will be analyzed by performance given different start and goal point.
Figure 21. A-star result 1 in 3 sec space
Figure 22. A-star result 1 in misc space
Figure 23. A-star result 1 in narrow1 space
Figure 24. A-star result 1 in narrow2 space
Figure 25. A-star result 2 in 3 sec space
Figure 26. A-star result 2 in misc space
Figure 27. A-star result 2 in narrow1 space
Figure 28. A-star result 2 in narrow2 space
Figure 29. Greedy result 1 in 3 sec space
Figure 30. Greedy result 1 in misc space
Figure 31. Greedy result 1 in narrow1 space
Figure 32. Greedy result 1 in narrow2 space
Figure 33. Greedy result 2 in 3 sec space
Figure 34. Greedy result 2 in misc space
Figure 35. Greedy result 2 in narrow1 space
Figure 36. Greedy result 2 in narrow2 space
| Algorithm | Scene | Iteration | Path Length | Algorithm | Scene | Iteration | Path Length | |
|---|---|---|---|---|---|---|---|---|
| a-star | 3-section 1 | 3165 | 14.2 | greedy | 3-section 1 | 905 | 14.4 | |
| a-star | 3-section 2 | 1694 | 8 | greedy | 3-section 2 | 647 | 8.4 | |
| a-star | misc 1 | 2611 | 9.8 | greedy | misc 1 | 2074 | 17.8 | |
| a-star | misc 2 | 2130 | 9.8 | greedy | misc 2 | 161 | 9.8 | |
| a-star | narrow1 1 | 934 | 8 | greedy | narrow1 1 | 81 | 8 | |
| a-star | narrow1 2 | 1469 | 8 | greedy | narrow1 2 | 770 | 9 | |
| a-star | narrow2 1 | 1394 | 11.4 | greedy | narrow2 1 | 138 | 11.4 | |
| a-star | narrow2 2 | 1469 | 8 | greedy | narrow2 2 | 770 | 9 |
Table 2. Algorithm Outcome in Multiple Scenes with Different Start and Goal Point
From the statistics and figure above, it is easy to see that A-star has a stable performance. A-star's performance in the same map wasn't affected significantly by where it starts and ends. On the other hand, GBFS is observed to perform extremly well in both time and getting the optimal path when there is no or few obstacles on its direct path towards the goal. But when that is not the case, GBFS produce a path that detours and sometimes goes in the opposite direction. In conclusion, GBFS saves computing power significantly if the environment has simple geometry and are expected to have low interference. While A-star is versatile but cost more time and power to make a more precise prediction.


{% extends "layout.html" %} {% block body_content %} {% for post in Jobs_post %}
- positions :{{ post.positions }}
- years of experience:{{ post.years_of_experience }}
- salary:{{ post.salary }}
- address :{{ post.address }}
- postcode :{{ post.postcode }}


{% call macros.panel("info", "Step 1 - Pick a flavor") %}
Mailu comes in multiple "flavors". It was originally designed to run on top of Docker Compose but now offers multiple options including Docker Stack, Rancher, Kubernetes.
Please note that "official" support, that is provided by the most active developers will mostly cover Compose and Stack, while other flavors are maintained by specific contributors.


You cannot view the Flash version when running the demo from your local disk. You need to run this demo on a webserver. This is a Flash security restriction.


Before you begin
This is an Android class. To complete the coding exercises, you will need an Android development environment with either an emulator or a device to run the exercise on. Please see the setup page if you need help installing the Xamarin development environment.
Overview
Activities are the fundamental architectural element of Android applications. A common way to describe an Android app is "a collection of collaborating Activities". This course shows you how to implement that collaboration. You will see how to start your own Activities and how to start standard Android Activities such as the camera or the web browser. You will learn how to pass arguments to an Activity when you start it and how to retrieve results when it finishes. By the end of the course, you will be able to code all the common patterns needed to make Activities work together.
Objectives
- Start an Activity in your .apk
- Finish an Activity
- Pass arguments to an Activity
- Get Activity results
- Start a system Activity
Lecture
AND102 - Activities and Intents in Android.
Exercises
-
Explore the completed lab exerciseExercise
You will begin by taking a few minutes to run the completed lab exercise to get an idea of the course goals. -
Start an Activity in your .apkExercise
Here you will launch one of your own Activities. -
Programmatically end an ActivityExercise
Next, you will programmatically finish an Activity in order to implement a "Cancel" button. -
Pass arguments to an ActivityExercise
In this exercise, you will load arguments into a Bundle and pass them to an Activity. -
Get Activity resultsExercise
Next, you will work inside an Activity to send results back to the Activity that started you. -
Launch a system ActivityExercise
Finally, you will integrate one of the standard Android Activities into your app.
Additional resources
Here are the Frequently Asked Questions about Activities and Intents in Android.


Sintef Module User’s Guide¶
- Release
2.1
- Date
Jun 05, 2020
Scripts¶
The functions defined in the sintef module provide the means to compute volume mean diameter (d_50) or oil and gas from a blowout and the resulting particle size distribution on a volume basis. These functions are based on the work published in Johansen, Brandvik, and Farooq (2013), “Droplet breakup in subsea oil releases - Part 2: Predictions of droplet size distributions with and without injection of chemical dispersants.” Marine Pollution Bulletin, 73: 327-335. doi:10.1016/j.marpolbul.2013.04.012.
The example detailed below demonstrates how to interact with the functions
defined in the sintef module. Further examples are presented in the
following scripts distributed in the ./bin/sintef
directory with the
source code.
Examples¶
This simple example demonstrates how to compute the volume mean diameter for an oil leak and compute the particle size distribution. For a more complete example, please see the script file listed above.
Volume Mean Diameter¶
The first step in evaluating a particle size distribution from an oil leak or well blowout is to compute a characteristic droplet size. For the SINTEF model defined in Johansen et al. (2013), the characteristic scale is the volume mean diameter, d_50. We will consider a simple oil leak here.
Import the necessary tools and input the oil and seawater properties:
>>> from tamoc import sintef
>>> from tamoc import seawater
>>> rho_p = 850.
>>> mu_p = 0.0005
>>> sigma_p = 0.026
>>> rho = seawater.density(273.15+4.5, 34.5, 100.e5)
Specify the outlet conditions for the release:
>>> D = 0.03
>>> Q = 0.005
>>> md = Q * rho_p
Compute the volume mean diameter. The function call can consider flows of oil and gas together. When only one phase is present, pass zeros for the parameters of the absent phase:
>>> d50_oil, _ = sintef.modified_We_model(D, rho_p, md, mu_p, sigma_p, 0., 0., 0., 0., rho)
This also works by reversing the inputs with only one immiscible phase is present:
>>> _, d50_oil = sintef.modified_We_model(D, 0., 0., 0., 0., rho_p, md, mu_p, sigma_p, rho)
The resulting droplet size is:
>>> d50_oil
0.00067659800106017825
Maximum Stable Droplet Size¶
The volume mean diameter calculation always checks to ensure that the returned value does not exceed a theoretical value for the maximum stable droplet size for the given fluids. In this example, the maximum stable droplet size can be computed as follows:
>>> dmax = sintef.de_max(sigma_p, rho_p, rho)
>>> dmax
0.015267057735857908
Hence, the value for d_50 computed above was below the maximum stable droplet size. This is expected for such a high leak flow rate through a small leak hole.
Droplet Size Distribution¶
The droplet size distribution is obtained from the Rosin-Rammler distribution with an assumed known spread coefficient (see Johansen et al. 2013 for details). From the compute d_50, the volume size distribution can be calculated for any number of bins. Consider an example with 20 bins:
>>> nbins = 25
>>> de_oil, md_oil = sintef.rosin_rammler(nbins, d50_oil, md, sigma_p, rho_p, rho)
>>> de_oil
array([ 7.41874956e-05, 8.91929874e-05, 1.07233557e-04,
1.28923091e-04, 1.54999647e-04, 1.86350564e-04,
2.24042655e-04, 2.69358516e-04, 3.23840164e-04,
3.89341511e-04, 4.68091452e-04, 5.62769705e-04,
6.76598001e-04, 8.13449713e-04, 9.77981660e-04,
1.17579257e-03, 1.41361359e-03, 1.69953734e-03,
2.04329330e-03, 2.45657886e-03, 2.95345740e-03,
3.55083679e-03, 4.26904478e-03, 5.13252071e-03,
6.17064711e-03])
>>> md_oil
array([ 0.01997373, 0.02696623, 0.03658705, 0.0497585 , 0.06766545,
0.09177166, 0.12377268, 0.1654128 , 0.21804747, 0.28178723,
0.35406647, 0.42767454, 0.4889011 , 0.51767027, 0.49287299,
0.40515515, 0.27211148, 0.13876944, 0.0491626 , 0.01156503,
0.0028402 , 0.00189551, 0.00185774, 0.00185734, 0.00185734])
The data are more easily interpreted via histogram:
>>> from matplotlib import pyplot as plt
>>> plt.figure(1)
>>> plt.clf()
>>> index = np.arange(nbins)
>>> bar_width = 0.75
>>> opacity = 0.4
>>> plt.bar(index, md_oil, bar_width, alpha=opacity, color='b')
>>> ntics = 10
>>> dtics = int(round(nbins/np.float(ntics)))
>>> ticnums = []
>>> ticlocs = []
>>> for i in range(ntics):
ticnums.append('%2.2f' % (de_oil[(i)*dtics]*1000.))
ticlocs.append(index[(i)*dtics] + bar_width/2)
>>> plt.xticks(ticlocs, ticnums)
>>> plt.xlabel('Oil droplet size (mm)')
>>> plt.ylabel('Oil mass flux (kg/s)')
>>> plt.show()


{% extends "cats/base.html" %} {% block content %}
My name is Brent Muha and I created Companion Cats. I'm a former elementary school teacher transitioning into software engineering. I love problem solving and collaborating with others. This site is my capstone project at Holberton School, and I am pursuing opportunities as a full stack web developer with a focus on back end.


class asIScriptContext { public: // Memory management int AddRef(); int Release(); // Engine asIScriptEngine *GetEngine(); // Script context int GetState(); int Prepare(int funcID); int Unprepare(); int SetArgByte(asUINT arg, asBYTE value); int SetArgWord(asUINT arg, asWORD value); int SetArgDWord(asUINT arg, asDWORD value); int SetArgQWord(asUINT arg, asQWORD value); int SetArgFloat(asUINT arg, float value); int SetArgDouble(asUINT arg, double value); int SetArgAddress(asUINT arg, void *address); int SetArgObject(asUINT arg, void *object); void *GetArgPointer(asUINT arg); int SetObject(void *object); asBYTE GetReturnByte(); asWORD GetReturnWord(); asDWORD GetReturnDWord(); asQWORD GetReturnQWord(); float GetReturnFloat(); double GetReturnDouble(); void *GetReturnAddress(); void *GetReturnObject(); void *GetReturnPointer(); int Execute(); int Abort(); int Suspend(); int GetCurrentLineNumber(int *column = 0); int GetCurrentFunction(); // Exception handling int SetException(const char *string); int GetExceptionLineNumber(int *column = 0); int GetExceptionFunction(); const char *GetExceptionString(int *length = 0); int SetLineCallback(asUPtr callback, void *obj, int callConv); void ClearLineCallback(); int SetExceptionCallback(asUPtr callback, void *obj, int callConv); void ClearExceptionCallback(); int GetCallstackSize(); int GetCallstackFunction(int index); int GetCallstackLineNumber(int index, int *column = 0); int GetVarCount(int stackLevel = -1); const char *GetVarName(int varIndex, int *length = 0, int stackLevel = -1); const char *GetVarDeclaration(int varIndex, int *length = 0, int stackLevel = -1); int GetVarTypeId(int varIndex, int stackLevel = -1); void *GetVarPointer(int varIndex, int stackLevel = -1); int GetThisTypeId(int stackLevel = -1); void *GetThisPointer(int stackLevel = -1); void *SetUserData(void *data); void *GetUserData(); };
int AddRef();
This method increases the internal reference counter of the object and returns the count. The returned value shouldn't be used for anything else but debugging.
Call AddRef() each time you assign a reference to a new variable.
The internal reference counter.
int Release();
Decreases the internal reference counter and returns the count. If the counter reaches 0 the object is deleted and the memory is freed.
After calling Release() don't forget to set your reference to 0 so that you don't mistakenly try to use the reference again.
The internal reference counter.
asIScriptEngine *GetEngine();
This function is used to retrieve the engine which created this context.
Returns the pointer to the engine object.
int GetState();
This method returns the state of a context.
Returns a negative value on failure. And one of asEXECUTION_FINISHED, asEXECUTION_SUSPENDED, asEXECUTION_ABORTED, asEXECUTION_EXCEPTION, asEXECUTION_PREPARED, asEXECUTION_UNINITIALIZED, or asEXECUTION_ACTIVE on success.
int Prepare(int funcID);
This method prepares the context for execution of a script function. It allocates the stack space required and reserves space for return value and parameters. The default value for parameters and return value is 0.
funcID |
The id of the function which is to be executed, or asPREPARE_PREVIOUS to use the same function again. |
Returns a negative value if the function cannot be found. Returns 0 or greater if sucessful.
int Unprepare();
This method can be called to free resources held by the context, without freeing the context itself. This may be useful in a few instances where you want to guarantee that a reference counted object is freed at a specific moment.
Resources that are freed with this call, include the returned object from the last execution, the script module from which the execution was made, and other internal resources.
This call is optional, only call it if you absolutely must.
Returns a negative value on error.
int Execute();
Executes the prepared function until the script returns. If the execution was previously suspended the function resumes where it left of.
Note that if the engine freezes, e.g. if trapped in a never ending loop, you may call Abort() from another thread to stop execution.
Returns a negative value on an unexpected error. On success it returns one of the following values to show the state of the context asEXECUTION_FINISHED, asEXECUTION_SUSPENDED, asEXECUTION_ABORTED, or asEXECUTION_EXCEPTION.
int Abort();
Aborts the current execution of a script.
Negative value on failure.
int Suspend();
Suspends the current execution of a script.
Negative value on failure.
int SetArgByte(asUINT arg, asBYTE value); int SetArgWord(asUINT arg, asWORD value); int SetArgDWord(asUINT arg, asDWORD value); int SetArgQWord(asUINT arg, asQWORD value); int SetArgFloat(asUINT arg, float value); int SetArgDouble(asUINT arg, double value); int SetArgAddress(asUINT arg, void *address); int SetArgObject(asUINT arg, void *object);
These method sets function arguments when calling script functions.
arg |
This is the argument number starting from 0, i.e. the first argument is on 0, the second on 1, and so on. |
value |
This is the value of the argument. This should be used for passing primitive data to the function. |
address |
This is the address of a value. This should be used for passing values by reference to the function. |
object |
When the function expects an object, either by value or by reference, you should use SetArgObject(). Pass a pointer to the object. If the function expects an object by value the library will automatically make a copy of the object. |
Returns a negative value if the function cannot be found. Returns 0 or greater if sucessful.
void *GetArgPointer(asUINT arg);
Returns a pointer to the argument.
You should copy the value to the location pointed to by the address. For primitives simply dereference and assign. For object handles, you must first increase the reference counter. For objects, you must make a copy of the object, and then pass the pointer to the new object.
arg |
The index of the argument, beginning with 0. |
The address of the argument.
int SetObject(void *object);
This method sets object pointer when calling class methods.
object |
The object pointer. |
Returns a negative value if the function cannot be found. Returns 0 or greater if sucessful.
asBYTE GetReturnByte(); asWORD GetReturnWord(); asDWORD GetReturnDWord(); asQWORD GetReturnQWord(); float GetReturnFloat(); double GetReturnDouble(); void *GetReturnAddress(); void *GetReturnObject();
This method gets the return value from the script function. The value returned is only valid if the script function has finished successfully, i.e. if the state of the context is asEXECUTION_FINISHED.
The functions return the value that the script function returned. If the function returns an object, either by value or by reference you should use GetReturnObject(), which will return a pointer to the object. If the object is returned by value you need to make a copy of it, as the library will release the object when the context is released or reused.
void *GetReturnPointer();
Gets the address to the location where the return value is.
For primitives you get a pointer to the primitive itself. For references you get a pointer to the pointer to whatever is being referenced. For object handles you get a pointer to the pointer to the object. For objects you get a pointer to the pointer to the object.
The address to where the return value is to be stored.
int GetCurrentLineNumber(int *column);
This method returns the line number where the context is currently located. The line number is relative to the script section where the function was found.
column |
An optional pointer to an integer that will receive the column number. |
The line number, where the first line is 1. May also return 0, if the line number counter has been disabled.
Returns negative value on failure.
int GetCurrentFunction();
Use this method to get the id of the function that the context is currently positioned in.
Returns the id of the function, or a negative value on failure.
int SetException(const char *string);
This method sets a script exception in the context. This will only work if the context is currently calling a system function, thus this method can only be used for system functions.
Note that if your system function sets an exception, it should not return any object references because the engine will not release the returned reference.
string |
The exception string. |
Returns a negative number on failure.
int GetExceptionLineNumber(int *column);
This method returns the line number where the exception ocurred. The line number is relative to the script section where the function was found.
column |
An optional pointer to an integer that will receive the column number. |
The line number, where the first line is 1. May also return 0, if the line number counter has been disabled.
Returns -1 if no context was prepared or no exception ocurred.
int GetExceptionFunction();
Use this method to get the id of the function in which the exception ocurred.
Returns the id of the function.
Returns -1 if no context was prepared or no exception ocurred.
const char *GetExceptionString(int *length = 0);
This function gives the exception string, which describe what happened.
length |
Pointer to a variable that will receive the length of the returned string. |
Returns a null-terminated string with the exception description.
int SetLineCallback(asUPtr callback, void *obj, int callConv);
This function sets a callback function that will be called by the VM each time the SUSPEND instruction is encounted. Generally this instruction is placed before each statement. Thus by setting this callback function it is possible to monitor the execution, and suspend the execution at application defined locations.
The callback function can be either a global function or a class method. For a global function the VM will pass two parameters, first the context pointer and then the object pointer specified by the application. For a class method, the VM will call the method using the object pointer as the owner.
void Callback(asIScriptContext *ctx, void *obj); void Object::Callback(asIScriptContext *ctx);
The global function can use either CDECL or STDCALL, and the class method can use either THISCALL, CDECL_OBJLAST, or CDECL_OBJFIRST.
callback |
Pointer to a the function or method. |
obj |
Pointer to the object or parameter for the function. |
callConv |
The calling convention for the function. |
Returns a negative value on failure.
void ClearLineCallback();
This method removes the line callback function.
int SetExceptionCallback(asUPtr callback, void *obj, int callConv);
This callback function will be called by the VM when a script exception is raised, which allow the application to examine the callstack and generate a detailed report before the callstack is cleaned up.
See SetLineCallback() for details on the calling convention.
callback |
Pointer to a the function or method. |
obj |
Pointer to the object or parameter for the function. |
callConv |
The calling convention for the function. |
Returns a negative value on failure.
void ClearExceptionCallback();
This method removes the exception callback function.
int GetCallstackSize();
This methods returns the size of the callstack, i.e. how many parent functions there are above the current functions being called. It can be used to enumerate the callstack in order to generate a detailed report when an exception occurs.
The size of the callstack.
int GetCallstackFunction(int index);
Returns the function id of a function on the determined level in the callstack.
index |
The index into the callstack. |
The function id.
int GetCallstackLineNumber(int index, int *column);
Returns the line number for the function at the callstack index.
index |
The index into the callstack. |
column |
An optional pointer to an integer that will receive the column number. |
The line number.
int GetVarCount(int stackLevel);
Returns the number of declared variables, including the parameters, in the function on the stack.
stackLevel |
The stack level. 0 is the first called function on the stack, the greater the number the younger the function. -1 (default) is the current function. |
The number of variables in the function.
const char *GetVarName(int varIndex, int *length, int stackLevel);
Returns the name of the variable in the function.
varIndex |
The index of the variable. |
length |
This argument will receive the length of the returned string. Can be 0. |
stackLevel |
The stack level in which the variables are enumerated. -1 is the default, and means the current function. |
Returns the pointer to a temporary string with the name of the variable.
const char *GetVarDeclaration(int varIndex, int *length, int stackLevel);
Returns the declaration of the variable in the function.
varIndex |
The index of the variable. |
length |
This argument will receive the length of the returned string. Can be 0. |
stackLevel |
The stack level in which the variables are enumerated. -1 is the default, and means the current function. |
Returns the pointer to a temporary string with the declaration of the variable.
int GetVarTypeId(int varIndex, int stackLevel);
Returns the type id of the variable in the function.
varIndex |
The index of the variable. |
stackLevel |
The stack level in which the variables are enumerated. -1 is the default, and means the current function. |
Returns the type id of the variable.
void *GetVarPointer(int varIndex, int stackLevel);
Returns a pointer to the variable, so that its value can be read and written. The address is valid until the script function returns.
The address points to the position in the stack where the variable is stored. As primitives are stored directly on the stack, the value of primitive types is gotten by dereferencing the pointer. Object variables are not stored directly on the stack, instead the stack holds a pointer to the object. Thus for object types the object is gotten by dereferencing the pointer twice.
Note that object variables may not be initalized at all moments, thus you must verify if the address returned points to a null pointer, before you try to dereference it.
varIndex |
The index of the variable. |
stackLevel |
The stack level in which the variables are enumerated. -1 is the default, and means the current function. |
Returns the pointer to the variable.
int GetThisTypeId(int stackLevel);
Returns the type id of the object for the class method.
stackLevel |
The stack level. -1 is the default, and means the current function. |
Returns the type id of the object.
void *GetThisPointer(int stackLevel);
Returns a pointer to the object, so that its content can be read and written. The address is valid until the script function returns.
stackLevel |
The stack level. -1 is the default, and means the current function. |
Returns the pointer to the object.
void *SetUserData(void *data);
This method allows the application to associate a value, e.g. a pointer, with the context instance.
data |
The user data value (usually a pointer). |
Returns the previous user data value.
void *GetUserData();
This method allows the application to retrieve the associated value.
Returns the current user data value.


Brush fire on Maui prompts temporary closure of Pulehu Road
by HNN StaffMAUI, Hawaii (HawaiiNewsNow) -Firefighters on Maui worked to put out a brush fire Sunday afternoon.
Maui police said the fire was burning near the central Maui landfill. Early reports indicate about 20 acres were burned.
The fire forced the closure of Pulehu Road from Hansen Road to just above the landfill.
This story may be updated.
Copyright 2019 Hawaii News Now. All rights reserved.


Click here to place a new order
This is an order for the following tier(s):
Tier 2 -
$7291
The following rings have been removed: (already subtracted from the tier cost above)
C8F14/SILVERCF
POLISH
129
The following rings have been added:
Z7F15-METEORITE
cross satin
379
ZC8B15/SILVERCF
polish
0
ZC8B15/CF
polish
0
ELYSIUM BEVELED POLISHED
Polish
649
ELYSIUM DOME MATTE
Matte
649
ELYSIUM DOME POLISHED
Polish
649
ELYSIUM ROUNDED SATIN
Satin
649
The following other items have been added:
DISPLAY CASE WB
WHITE/BLUE
0
The following custom items have been added:
The following stock balance has been added.
Stock balance must be returned to Lashbrook within 10 business days. Amount not to exceed:
1
- $
-5000
If stock is not returned within 10 business days, invoice will be amended to full amount.
Your sub-total is:
$5266
Date: 2015-02-27
Store Name: test
Last Name: kjhgkjhgkjhv577
First Name: khgf
Address: jhyf
Phone: 555555test
e-mail: test
Terms: jhgf
Notes:
Sales Rep: Charles Nielson
Sales Rep e-mail<EMAIL_ADDRESS>Your shipping costs are $35
Order Total: $5301


Powder X-ray diffraction patterns of 3D-TPE-COF. PXRD profiles of experimental pattern (black curve), Le Bail fitting pattern (red curve), their difference (green curve) and Bragg position from the seven-fold interpenetrated pts structure (blue curve)


(defun eg.hi(my) (format t "~&Welcome to keys~%"))
(defun eg.a(my) (print 1))
(defun eg.csv(my &aux (n 0))
(setf (! my all eg) "../data/auto93.csv")
(assert (= 3192 (with-csv (row (! my all data) n)
(incf n (length row))))))
(defun eg.seed (my)
(let ((n 100) a b)
(setf *seed* 1
a (loop for x below n collect (randf 1000))
*seed* 1
b (loop for x below n collect (randf 1000)))
(want (equal a b) "lists not equal")))
(defun eg.inca (the)
(let ((lst '((a . 1) (b . 2) (c . 3) (d . 4))))
(inca 'a lst)
(inca 'z lst)
(want (and
(equal 1 (cdr (assoc 'z lst)))
(equal 2 (cdr (assoc 'a lst)))) "nad inca")))
(defun eg.sym (the)
(let ((n (make-sym)))
(add n '("a" "b" "b" "c" "c" "c" "c"))
(want (< 1.378 (var n) 1.379) "bad ent")))
(defun eg.num (the)
(let ((n (init(make-num :txt "asd-"))))
(print n)
(add n '(2 3 4 4 4 4 5 5 6 7
7 8 9 9 9 9 10 11 12 12))
(want (= 3.125 (var n)) "bad sd")
(want (= 7 (mid n)) "bad mean")))


INSTRUCTIONS: Click on any of the robot masters to see their profile
Blizzard Man
DWN-041
HP:
28
Contact Damage:
3 (3 on Roll)
Main Attack(s):
Blizzard Attack
Damage:
3
Centaur Man
DWN-041
HP:
28
Contact Damage:
4
Main Attack(s):
Centaur Flash (Shots)
Damage:
3 (2)
Flame Man
DWN-042
HP:
28
Contact Damage:
4
Main Attack(s):
Flame Blast (Fireballs)
Damage:
4 (3)
Knight Man
DWN-043
HP:
28
Contact Damage:
4
Main Attack(s):
Knight Crusher
Damage:
5
Plant Man
DWN-045
HP:
28
Contact Damage:
4
Main Attack(s):
Plant Barrier
Damage:
4
Tomahawk Man
DWN-046
HP:
28
Contact Damage:
4
Main Attack(s):
Silver Tomahawk (Feathers)
Damage:
5 (4)
Wind Man
DWN-047
HP:
28
Contact Damage:
5
Main Attack(s):
Wind Storm
Damage:
4
Yamato Man
DWN-048
HP:
28
Contact Damage:
4
Main Attack(s):
Yamato Spear (Shots)
Damage:
4 (4)


This software has evolved from fisheries research conducted at the Pacific Biological Station (PBS) in 'Nanaimo', British Columbia, Canada. It extends the R language to include two-dimensional plotting features similar to those commonly available in a Geographic Information System (GIS). Embedded C code speeds algorithms from computational geometry, such as finding polygons that contain specified point events or converting between longitude-latitude and Universal Transverse Mercator (UTM) coordinates. Additionally, we include 'C++' code developed by Angus Johnson for the 'Clipper' library, data for a global shoreline, and other data sets in the public domain. Under the user's R library directory '.libPaths()', specifically in './PBSmapping/doc', a complete user's guide is offered and should be consulted to use package functions effectively.
| Version: | 2.70.5 |
| Depends: | R (≥ 3.0.0) |
| Suggests: | foreign, maptools, deldir |
| Published: | 2018-06-06 |
| Author: | Jon T. Schnute [aut], Nicholas Boers [aut], Rowan Haigh [aut, cre], Alex Couture-Beil [ctb], Denis Chabot [ctb], Chris Grandin [ctb], Angus Johnson [ctb], Paul Wessel [ctb], Franklin Antonio [ctb], Nicholas J. Lewin-Koh [ctb], Roger Bivand [ctb] |
| Maintainer: | Rowan Haigh <rowan.haigh at dfo-mpo.gc.ca> |
| License: | GPL-2 | GPL-3 [expanded from: GPL (≥ 2)] |
| Copyright: | 2003-2018, Fisheries and Oceans Canada |
| URL: | https://github.com/pbs-software/pbs-mapping, https://github.com/pbs-software/pbs-mapx, http://www.angusj.com/delphi/clipper.php |
| NeedsCompilation: | yes |
| SystemRequirements: | C++11 |
| In views: | Spatial |
| CRAN checks: | PBSmapping results |
| Reference manual: | PBSmapping.pdf |
| Package source: | PBSmapping_2.70.5.tar.gz |
| Windows binaries: | r-devel: PBSmapping_2.70.5.zip, r-release: PBSmapping_2.70.5.zip, r-oldrel: PBSmapping_2.70.5.zip |
| OS X binaries: | r-release: PBSmapping_2.70.5.tgz, r-oldrel: PBSmapping_2.70.5.tgz |
| Old sources: | PBSmapping archive |
| Reverse depends: | RapidPolygonLookup |
| Reverse imports: | raptr, RchivalTag, smartR, vmsbase |
| Reverse suggests: | MapGAM, maptools, PBSmodelling, prioritizr, RgoogleMaps |
Please use the canonical form https://CRAN.R-project.org/package=PBSmapping to link to this page.


First paragraph
Second paragraph
Third paragraph
Paragraph inside a div
Paragraph inside a span inside a div
HelloI'm interfering with the Hello!!!!


Hacking your first HTML5 Mobile Game
Christie Koehler,
@christi3k
,
<EMAIL_ADDRESS>Hacking your first HTML5 Mobile Game
Christie Koehler, MozFest 2013
Create a Github account
You'll need a Github account a bit later. Create one at
github.com
.
What do we mean when we say "HACK"?
photo source
Hacking: Make it work for you!
Solving a problem or meeting a need.
Starting with the knowledge you already have.
You can hack anything!
Article: Kids Hacking Their Tablets
Why make HTML5 Mobile games & apps?
photo source
Platform: Which would you choose?
photo source
Why choose?
What if you could create a game that would work on any device?
photo source
HTML5 Mobile Games
Anyone can participate or innovate using well-known, open web technologies without asking permission from others.
photo source
See. Remix & Rematch.
You can see the code others create and understand it, remix it and make something new.
Building blocks
The web is made up of components that are like Lego building blocks... ...that let you make an infinite number of things.
photo source
The world of the web encourages remixing to make new things because that is how it is built.
photo source
Why learn to code?
Could you imagine being able to read but not write?
photo source
Knowing how to read and write code allows you to turn your ideas into games and apps to share with others and make a difference.
photo source
Let's code!
We're going to start with existing code. We'll examine it, remix it, and make our own custom card matching game.
Where does this code come from?
github.com/christi3k/browser-pairs
Ready, set, go!
Thank you!
Christie Koehler
@christi3k
<EMAIL_ADDRESS>Slides
: {slideurl}


Guidance
Specifications for software suppliers developing school summary reports for the school censuses in autumn 2015, spring 2016 and summer 2016.
Ref: DFE - 00195 - 2015 PDF , 941KB , 74 pages
Ref: DFE-00194-2015 PDF , 1.02MB , 58 pages
Ref: DFE-00193-2015 PDF , 611KB , 42 pages
These documents are for suppliers developing software for school management information systems (MIS).
They explain what information software suppliers should include in school summary reports for the school census . Schools can then use the reports to check the accuracy of their termly school census data before sending it to their local authority or to us.
More guidance on submitting data for the school census is available.
Published: 10 July 2015
Updated: 6 April 2016
From: Department for Education
Part of: School census: closed collections


{% extends "base.html" %} {% block extra_head %} {% endblock %} {% block content %}
The process of launching an instance of the platform takes a few minutes. Once the instance and the necessary services are running, a link to your server will be shown (in Server IP address field). To manage your newly created cluster, please use the CloudMan console from the shown link.
{% if request.session.ec2data.cloud_type == 'ec2' %}Amazon is now charging you per hour for your new server. You may use the EC2 console to monitor the status of your instance.
{% endif %}For login, use ubuntu username and the password you provided on the previous page (also available in the table below once the server becomes ready).
| From zero to an analysis platform in | |
|---|---|
| Server state |
|
| Server IP address (CloudMan console) | Please wait |
| Additional server information | |
|---|---|
| For command line SSH access use | ssh ubuntu@{{ request.session.ec2data.public_ip }} (Use key pair or password from the entry form; show: {{ request.session.ec2data.password }}) |
| For FreeNX remote desktop access |
User: ubuntu Password: from the entry form (show: {{ request.session.ec2data.password }}) Host: {{ request.session.ec2data.public_ip }} Window Manager: GNOME |
| Cluster name | {{ request.session.ec2data.cluster_name }} |
| Instance ID | Not yet available |
| Image ID (AMI) | Not yet available |
| Security group | Not yet available |
| Key pair | {# Show the link to download key pair material only if a new key pair was created #} Not yet available |
| Placement (zone) | Not (yet) available |


Wallet
1.33 ETH
Public Address
Address
Show Private Key
Logout
Create Deal
Name Of Deal
Price
Seeker Collateral
Provider Collateral
Address of Seeker
Address of Provider
Address of Arbitrator
Fund Deal
Search for a Deal to Fund
View Deal
Search for a Deal to View


Class: Puma::Reactor
| Relationships & Source Files | |
| Inherits: | Object |
| Defined in: | lib/puma/reactor.rb |
Overview
Monitors a collection of ::IO
objects, calling a block whenever any monitored object either receives data or times out, or when the Reactor
shuts down.
The waiting/wake up is performed with nio4r, which will use the appropriate backend (libev, Java NIO or just plain IO#select
). The call to NIO::Selector#select
will ‘wakeup’ any ::IO
object that receives data.
This class additionally tracks a timeout for every added object, and wakes up any object when its timeout elapses.
The implementation uses a Queue to synchronize adding new objects from the internal select loop.
Class Method Summary
- .new(backend, &block) ⇒ Reactor constructor
Instance Method Summary
-
#add(client)
Add a new client to monitor.
-
#run(background = true)
Run the internal select loop, using a background thread by default.
-
#shutdown
Shutdown the reactor, blocking until the background thread is finished.
-
#register(client)
private
Start monitoring the object.
- #select_loop private
-
#wakeup!(client)
private
‘Wake up’ a monitored object by calling the provided block.
Constructor Details
.new(backend, &block) ⇒ Reactor
# File 'lib/puma/reactor.rb', line 23
def initialize(backend, &block) require 'nio' unless backend == :auto || NIO::Selector.backends.include?(backend) raise "unsupported IO selector backend: #{backend} (available backends: #{NIO::Selector.backends.join(', ')})" end @selector = backend == :auto ? NIO::Selector.new : NIO::Selector.new(backend) @input = Queue.new @timeouts = [] @block = block end
Instance Method Details
#add(client)
Add a new client to monitor. The object must respond to #timeout
and #timeout_at
. Returns false if the reactor is already shut down.
# File 'lib/puma/reactor.rb', line 49
def add(client) @input << client @selector.wakeup true rescue ClosedQueueError false end
#register(client) (private)
Start monitoring the object.
# File 'lib/puma/reactor.rb', line 100
def register(client) @selector.register(client.to_io, :r).value = client @timeouts << client rescue ArgumentError # unreadable clients raise error when processed by NIO end
#run(background = true)
Run the internal select loop, using a background thread by default.
# File 'lib/puma/reactor.rb', line 35
def run(background=true) if background @thread = Thread.new do Puma.set_thread_name "reactor" select_loop end else select_loop end end
#select_loop (private)
[ GitHub ]# File 'lib/puma/reactor.rb', line 69
def select_loop begin until @input.closed? && @input.empty? # Wakeup any registered object that receives incoming data. # Block until the earliest timeout or Selector#wakeup is called. timeout = (earliest = @timeouts.first) && earliest.timeout @selector.select(timeout) {|mon| wakeup!(mon.value)} # Wakeup all objects that timed out. timed_out = @timeouts.take_while {|t| t.timeout == 0} timed_out.each(&method(:wakeup!)) unless @input.empty? until @input.empty? client = @input.pop register(client) if client.io_ok? end @timeouts.sort_by!(&:timeout_at) end end rescue StandardError => e STDERR.puts "Error in reactor loop escaped: #{e.} (#{e.class})" STDERR.puts e.backtrace retry end # Wakeup all remaining objects on shutdown. @timeouts.each(&@block) @selector.close end
#shutdown
Shutdown the reactor, blocking until the background thread is finished.
# File 'lib/puma/reactor.rb', line 58
def shutdown @input.close begin @selector.wakeup rescue IOError # Ignore if selector is already closed end @thread.join if @thread end
#wakeup!(client) (private)
‘Wake up’ a monitored object by calling the provided block. Stop monitoring the object if the block returns true
.
# File 'lib/puma/reactor.rb', line 109
def wakeup!(client) if @block.call client @selector.deregister client.to_io @timeouts.delete client end end


It should be possible for a Masked input field that has an initial value to be automatically processed against a pattern when the Mask is invoked.


The 2018 Best Picture Nominees Ranked, Reviewed, and Reflected Upon
The nominees are all great, but which are best? And why they are they so great? My take. |
Intro
When the 2018 Oscar best picture nominees were released, I realized I had already seen most of them before they were known to be the nominees purely because I was excited for them as works of art. Then, just for fun, I endeavored to watch the rest and cataloged my personal preferences. But then I realized I could do more. I had reviews and further thoughts on most of these films, and could write up a whole big summary - what you are reading now! So without further ado, ordered from least to most liked for the sake of ending on the most positive note, reviews and thoughts on all the best pictures nominees:
Darkest Hour
Viewing Date: 02/03/18
Original Score: 3.5/5
Original Review:
A showy movie of romance and splendor - too much romance and splendor, in fact. Especially in its first half, the loud soundtrack, fancy panning/zooming/flying shots, and weird bouts of humor all add up to annoy and exhaust rather than highlight the excellent central performance. This improves in the second half, with show-off shots that are quite nice and serve to highlight the peril Churchill stands in. But, then the romantic bit cuts in and ruins that improvement with a bastardized version of history that does not seem realistic and indeed is utterly false. Still, the movie looks great, Oldman crafts a compelling portrayal, and overindulgence combined with a liberal interpretation of history are at least a far lesser sin than being boring or shallow.
Current Score: 3.5/5
Thoughts:
The only movie among all of these I would not call great. This is an unusual case of a movie on which I am split, as I can find both great and not so great elements within it. Sadly, great plus not so great equals not so great.
As with the rest of these, my perspective on it has been affected a good deal by external listening and reading, in this case The Q&A with Jeff Goldsmith which reveals many interesting tidbits such as:
- The linked interview is with the screenwriter Anthony McCarten, who has previously written The Theory of Everything. My impression of the critical response to that one was that a sort-of schmaltzy Oscar bait flick, which is a broadly correct characterization of this movie as well.
- The movie’s chief theme is the power of words, but the case of Churchill hardly seems like a good case for that; many figures (MLK Jr. comes to mind) have made far far more impactful speeches than the ones shown the film.
- There is also a focus on the wisdom of having uncertainty as a leader, but once more I don’t think Churchill and Dunkirk are the best possible frames to tell that story.
- Gary Oldman, who gives a memorable performance despite looking nothing like Churchill, had to go through three and a half hours of makeup each day to be able to look like the portly old Winston. Though it certainly is a good portrayal, it seems a bit overkill given that the movie’s showy direction ultimately overshadows the acting and plenty of fine actors who look more like Churchill could have done a fine job as well…
The Post
Viewing Date: 25/02/18
Original Score: 4.5/5
Original Review:
A timely and smart allegory for the importance of a free press and the pervasiveness of sexism in the 1970s (and rather obviously, in the present). Strikes just the right balance of gripping-character-driven story and not-at-all-subtle social critique, and Spielberg is as good as ever at the basic craft of cinema. Hanks is a little predictable if solid, but Meryl Streep absolutely owns the role and makes the character come alive. Plenty of critics will just dismiss this as forgettable awards fluff, but when watched without cynicism it’s clear this is an excellently made, thoroughly enjoyable, and unusually intelligent film.
Current Score: 4.5/5
Thoughts:
I have seen this one recently, and unlike Darkest Hour I don’t think it is schmaltzy Oscat-bait at all despite looking like it might be. Spielberg smartly made it a lean and direct message-movie, and its direct address of the importance of the press and the reality of sexism in society is still as relevant as it was in the 1970s. And again, Meryl Streep is just so sublime, the movie is worth seeing for that alone. I leave you with a fantastic interview that delves into the impressive real life figure Streep portrayed so well:
Get Out
Viewing Date: 21/01/18
Original Score: 4/5
Original Review:
A clever, effective, and timely satire horror comedy.
Current Score: 4.5/5
Thoughts:
One of the multiple movies among these for which my esteem has only grown. As with others, listening to conversations with its makers played an important role in evolving my view of it. In particular, the Q&A with Jeff Goldsmith interview with the writer and director Jordan Peele revealed many suble and smart aspects:
- Grounding the film’s horror in a universal experience (meeting a significant other’s parents) made it relatable for all viewers.
- Peele has had the idea for many years, and he decided to collaborate with Blumhouse Productions because they encouraged him to have full creative control and craft it in accordance with his vision. This has resulted in one of the most original and timely movies of the year.
- There is more subtle symbolism and implied detail than I realized while watching the film, which not typically true of such audience pleasers/crowd favorites.
Additionally, others have done an excellent job aspousing how smart the movie actually is:
Lady Bird
Viewing Date: 18/11/17
Original Score: 4.5/5
Original Review:
A great coming-of-age movie with fantastic acting, editing, writing, and… just about everything. A few bits of dialogue feel a bit too clever for their own good, and having a few scenes go slower might’ve been good, but the strength of the central performance and so many individual memorable moments alone make this utterly worth watching.
Current Score: 4/5
Thoughts:
A rare film for which my esteem has somewhat dropped. Some of the writing just feels too clever for its own good (like the ‘my mother made one mistake’ scene notably highlighted in the trailer), and like its protagonist the movie feels like its trying hard to be cool and smart but is not being vulnerable and honest in the process. Still, a fantastic growing of age movie, in particular because of the brilliance of lead actress Saoirse Ronan and writer/director Greta Gerwig - definitely some of the most exciting young talents in film today.
Phantom Thread
Viewing Date: 03/02/18
Original Score: 4.5/5
Original Review:
A surprisingly sly, perverse, and darkly funny period romance. Exquisitely staged, exquisitely acted, exquisitely directed… exquisite.
Current Score: 5/5
Thoughts:
And now we get to the set of movies I unabashedly love! Once again my appreciation has grown due to BBC Film Programme interview:
- The key inspiration for the movie, the writer director Paul Thomas Anderson being sick and taken care of by his wife, is unusual and unexpected. He gets at aspects of romance and relationships not often explored, which is impressive.
- As the interviewer notes, on a second viewing it’s much easier to see the film as being utterly comedic rather than serious and dramatic like the director’s other work. I have been describing this as a ‘sly, intelligent, dark romantic comedy’ to friends, and it is refreshing to see such a non-formulatic romantic comedy.
- Another unexpected aspect is the richness of the female characters, who may be more fully three dimensional than Daniel Day Lewsis’s excellently portrayed male character. As Anderson says in his interview:
“Daniel is front and center because he is Daniel… I think Audiences go in with expectation this is Daniel’s film, but in fact he is support for the girls who are our protags.”
Shape of Water
Viewing Date: 09/12/17
Original Score: 4.5/5
Original Review:
Like the fantastical creature at its core, The Shape of Water is beautiful, strange, and exquisitely crafted.
Current Score: 4/5
Thoughts:
While watching the movie, I was struck by how unabashedly and unreservedly beautiful it was. So I was glad to hear that was Guillermo del Toro’s intent; as stated on the BBC Film Programme
“The overwhelming reaction is the same overwhelming reason why I wanted to make it, which is, can you please show me something beautiful, can you please show me something life affirming, can you please take me out of the news, right now…”
That being said, it is also one of the few movies I consider great for which my esteem has lessened. A big part of the reason is the lengthy discussion on the Next Picture Show podcast, in which most of the participants felt tepid about the film. I agree with their perspective that the movie feels a little artificial in all its beauty, and that going as far as it does in portraying the romance explicitly undercuts it somewhat. Still, this is a rare simple allegory of sensual delights that is definitely worth seeing.
Dunkirk
Viewing Date: 23/07/17
Original Score: 4/5
Original Review:
Visceral. Unlike Nolan’s many other neat-idea or plot-puzzle movies, this one is made with the obvious intent of making you feel an experience to your bones. But, some of Nolan’s fondness for fancy intellectually fun structure is here - there is no conventional 3 act structure or protagonist with an arc and instead an ensemble cast going through overlapping but temporally offset narratives that come together by the end. Yet more daringly, the ensemble story has minimalist character development and plot, which leaves it free to almost entirely avoid exposition and fully immerse you in the characters’ dreaded pulse-pounding experiences.
This all is great and for the most part executed beautifully, except that I am not sure if the 3 narrative threads really work well together, and by the end the cross-cutting between narrative threads gets overdone and lessens the impact of the ending a good deal. And, after that ending there is just not a whole lot to think back on or relate to; it’s a hell of a ride, but not much more. It made me think back to Gravity, which is likewise a non-stop visceral tale of survival, but one that I think managed to still have a resonant theme and message. But damn, is this one of a hell of a ride.
Current Score: 4.5/5
Thoughts:
So many thoughts… as indicated in the review I was unsure of Nolan’s layered fancy structure was actually warranted, but I have since grown to appreciate it more. Once, much insight comes from an interview on the BBC Film Programme:
- The movie is discussed as ‘The most expensive experimental film in cinema history’, which feels quite right. Just the audacity to do something so intricate and out there in a big budget movie earns a lot of respect from me.
- The idea of the structure came before writing the script, which makes sense; the script is utterly
- Nolan describes the movie as being ‘Intensively subjective’, and justifies the structure by its ability to get across the bigger picture of the Dunkirk event while also staying extremely close to the boots-on-the-ground soldiers. He has a nice line of not having wanted to cut to a room of general discussing the situation, and indeed he does not, and the movie is far far stronger for it.
- With regard to the experimentation of the film, Nolan says that he wants to work at the ‘Edge of what mainstream audience can get enlivened by’ and feels that audiences that don’t treat movies like puzzles but rather just let ‘the experience of the movie wash over them’ will enjoy them most. I feel that Nolan’s movies are far too often treated as puzzles, and liked his perspective on this a lot.
- Nolan commented that cinema has unique ability to manipulate perception of time, and that his intent pull with this film was to ‘pull that part of machinery out’ and have an ‘explicit discussion with the audience’ rather letting it be subliminal as in most movies.
- What I appreciated most, and still appreciate most, about the film is its ability to make me feel like I was there. It was evident this was not accidental * Nolan discusses at length of how he wanted to make it feel as real as possible by setting things in real physical spaces, and by leveraging the grammar of suspense ‘present tense narrative’. That is, he focused on just showing the character in a given situation without extra dramatization or characterization; such daring minimalism is rare and was incredibly successful here.
- A last interesting tidbit is that early in the music composition, Nolan sent the composer a recording of a pocket watch. Unlike most movies, which add music after the movie is made, composition was done from very early on so that the ‘score could be fused with picture and sound effects early on’. This worked fantastically well - as Nolan says, there is a ‘physical fusion of picture and music and sound effects unlike anything else’. The music is ‘objective’; just the screenplay is stripped of all unnecessary dialogue (all conversation except that which is needed to survive), the music is stripped of all unnecessary emotion and is meant to convey the experience of the preset moment. But the intelligence and the brilliance of the score goes even beyond that, as highlighted in this video:
Call Me By Your Name
Viewing Date: 21/01/18
Original Score: 5/5
Original Review:
Luscious, sensual, rapturous - perfectly captures the feeling of being young during a care free summer of discovery that is equal parts exciting and nerve wrecking. And it does so beautifully, artistically; there are so many close ups and frames in this movie that convey an endless depth of emotion and thought without a word being spoken. And it does so intelligently, thematically tying back to the greeks’ views on sensuality and love; unlike so much of recent 80-set media, this does not feel nostalgic - it feels timeless.
And the music! Sufjan Stevens is such a perfect fit for this, singing in his soft voice of the ‘Mystery of Love’. And the writing! Adapted by now 89-year old James Ivory, it feels wise and fully aware of the subtle unspeakable eternal truths of life. I credit Ivory too, with the unusual lack of tension over being found out as gay and the character’s fully supportive parts; as discussed in an interview , this felt like a welcome change from more conventional cinema:
... it’s been very hard to find a gay film which was about happiness and joy and love,” Ivory said during the Q&A after the film. ... The moderator of the event, cinema studies instructor Sergio Rigoletto, said that one of the revolutionary things about “Call Me By Your Name” is that it allows its gay characters to be in love without the impending threat of punishment. Sure, the fear of being found does live in the back of their minds, but their main reasons for not being able to be together are their age differences and the fact that Elio and Oliver only have six weeks of their summer together.
So, the movie is joy, happiness, love. And the final shot! Watch this film, if only for the final conversation, and the final shot.
“I remember everything”
Current Score: 5/5
Thoughts:
Well, my appreciation of this movie has certainly not lessened - everything that I said in that original review, I still feel. But as with Three Billboards, hearing interviews and watching videos has also deepened my appreciation of the movie. In particular, the lengthy and detailed interview of the director and co-author by Luca Guadagnino on the The Q&A with Jeff Goldsmith highlights many great elements:
- The protagonist is very well portrayed as what he is - a 17 year old kid, a “mini bomb of different contradictions”. He has not come to think of himself as belonging to any group or label, and is appropriately excited and afraid of the desires he feels.
- The interview frankly discusses the issue of the age difference between the 17-year old protagonist and his 24-year old lover. For one the age of consent in Italy is 16, and for another this has been done before with such classics as Dirty Dancing. But far more importantly, the movie does something many romantic movies without such an age difference do not: show direct and clear disclosure of one’s feelings, portray explicit and enthusiastic consent during sex, and linger on direct discussions over each person’s concerns and desires. And it does so while not losing any sense of romance, passion, or beauty - what a feat!
- The director would not change anything about the movie if here to do it over. And he is right! I would not want him to.
- Sufjan Stevens came into collaboration on the movie’s soundtrack after a large amount of narration was cut out from the original screenplay. Stevens’ songs are meant to act as a sort of third person narrator communicating the universality of the love story we are seeing, and I think that was done perfectly.
Lastly, what I’ve grown to appreciate even more than I did after just watching the movie is this element of portraying an utterly happy love story (even if it ends with separation, rather than marriage). As stated perfectly by the book’s author in an interview of both him and the movie’s director,
“Both the novel and film do one thing that is so essential - there is no accident, there is no death, there is no banning of any sexual proclivity - these are two individuals who have a relationship, and I think it should serve as a model for essentially happy romance.”
Three Billboards Outside Ebbing, Missouri
Viewing Date: 21/01/18
Original Score: 4.5/5
Original Review:
Challenging, unexpected, dark, funny - a rare treat. Definitely worth seeing.
Current Score: 5/5
Thoughts:
A rare movie for which my esteem has only grown, and in just one month.
I think what I appreciate so much about this film (and why I think it deserves to win best picture) is that it is far more challenging that any of the other films on here. As eloquently stated by the writer and director Martin McDonagh on the BBC Film Programme, the core of the film is two characters going to war in which neither one is really the bad guy. It would be so easy to make the grieving mother the one to clearly root for and to portray the authorities as incapable and uncaring. But as McDonah says:
“Even though she’s technically the hero of the piece she does things that are way out of order, indefensible. That’s part of why I really like her, the character and Frances’ playing of her, she’s really three dimensional and not somebody you could say is the perfect person at all. That’s good characterisation, I think, and makes it hopefully a film you can see more than once. It’s not a simple heroes against villains story.”
The very simple and clear setup of this conflict - the titular three billboards - is also utterly inspired and immediately interesting. So it’s unsurprising that such a striking moment is actually drawn from the real world:
“I saw something on a bunch of billboards about twenty years ago which is almost identical to what we see on the first two billboards, they’re literally verbatim.”
There was some controversy and negative takes about this film, with regard to whether it ultimately redeemed the racist and violent police officer played by Sam Rockwell. I am sure this controversy will likely make this movie not receive the best picture, but I also just don’t agree with it at all. Like the non-perfection of the central character, the ‘redemption’ of Rockwell’s character is actually completely subverted in opposition to what would typically be done in Hollywood. The morally ambiguous and subversive ending is actually one of my favorite things about the movie, and I recommend it to anyone who is a fan of black comedy, complicated explorations of morality, and just great cinema.


Quizzes
Quiz
Create Quiz
Need to add a new quiz? Click here!
Let's go!
Quiz
Manage Quizzes
Is there a quiz you no longer need?
Let's go!
Quiz
Category Names
Let's go!


Name your session
Name it whatever you want!
Date of Run
Pick your Trail
If your trail isn't listed, create it in the "Add a Trail" button above
Number of laps?
Enter Run Session Time:
:
:
Log this run


Hexadecimal color codes are six-digit, three-byte hexadecimal numbers. Bytes represent red, green and blue (RGB) and each color ranges from 00 to FF: Wikipedia Web Colors Article.


The Fry Award is given to a Canadian Zoologist who has made an outstanding contribution to knowledge and understanding of an area in zoology, and who is expected to deliver a plenary lecture at the next AGM.


Irken is a simplified, statically-typed dialect of Scheme. It uses an ML-like type system supporting parametric polymorphism (i.e., "let polymorphism") and algebraic datatypes. With type inference and a pattern-matching syntax, it could be considered ML with a lisp/scheme syntax.
Irken's syntax is nearly identical to Scheme's. The main differences are:
"(+ x[i] y[i])
)"{field0=10 field1="foo" field2="bar"}
).":"
) is a reserved character (it identifies constructors)."->"
) and function definitions.
[A few other discrepancies will remain undocumented in the hope that they will someday be fixed]
Compared to Scheme, the biggest change is that all expressions are statically typed. Expressions like '(1
"two" three)
will not pass the type checker. All lists must be monomorphic, i.e., a list of ints, or a list of bools, etc... This
sounds horribly restrictive, but in practice it is not; indeed the type safety guarantees made by this type system make for a more
secure design that can outperform dynamic languages because it needs no runtime type checking.
You may, for example, declare a datatype (i.e., a union) of these three types and make a list of those objects.
Irken implements algebraic data types using the datatype
declaration:
;; -*- Mode: Irken -*-
(include "lib/core.scm")
(include "lib/pair.scm")
(datatype thing
(:int int)
(:str string)
(:sym symbol)
)
Note: int
, string
, and symbol
are builtin base/ground types
Objects of this datatype are created by calling their constructors:
(LIST (thing:int 1) (thing:str "two") (thing:sym 'three))
The list
datatype is declared thus:
(datatype list
(:nil)
(:cons 'a (list 'a))
)
In English, this means that the datatype list
consists of two different variants. The first,
nil
, contains no additional data, and corresponds to an empty list. The second, cons
, contains two
objects. The first element is of type 'a
, and the second is of type (list 'a)
, making this a
recursively defined datatype. In other words, a cons
object has a CAR
of any type, and a
CDR
of a list of that same type. The type 'a
is a type variable, which means it can take on any type.
list
is not built into the compiler, but rather declared as part of the
prologue in the file "lib/pair.scm".
If you want to write a function that deals with lists, the type checker will force you to deal with each branch of the datatype. This is the source of Irken's type safety: it's impossible to accidentally not handle a nil case.
A constructor
is an automatically generated function that creates an object based on one of the branches/variants of
a datatype declaration. The name of a constructor function is formed from the names of the datatype and variant, delimited with a
colon: <datatype>:<constructor>
.
For example, to create an empty list, you would call list:nil
:
(list:nil)
To create a list of one element:
(list:cons x (list:nil))
This may seem a little tedious, and it can be. Like ML, Irken has some extra support for the list datatype (like the
LIST
macro used above) to make it a bit more convenient.
In the ML family of languages, constructors are usually globally unique, so the datatype prefix is unnecessary. A single global namespace for constructors means you can't use the same name more than once. This leads to the use of Hungarian notation (e.g, "TXNil"); I think it's cleaner to just require the name of the datatype to disambiguate.
How do you write functions that deal with this datatype? Irken has a builtin vcase
special form (similar to a Scheme
case
), that covers the branches of a datatype constructor. Here's how the length
function looks using vcase
:
(define (length l)
(let loop ((l l)
(n 0))
(vcase list l
((:nil) n)
((:cons _ tl)
(loop tl (+ n 1))))))
And here's a version using pattern matching:
(define length
() -> 0
(_ . tl) -> (+ 1 (length tl)))
(length '(1 2 3 4 5))
Wow, that looks a lot cleaner! (There's actually something a little unfair about the comparison that I will explain later). The
vcase
special form isn't really needed in Irken any more; however pattern matching expressions are translated
automatically by the compiler into vcase
expressions.
Notice a few things about this definition of length
. First, there is no argument list; the name of the function
follows define
unadorned. That's because names for the formal arguments are superfluous - the patterns
destructure the cases, (optionally) binding variables to the objects inside each branch.
Secondly, you see some of the builtin language support for the list datatype. Normally, the patterns would have to be written like this:
(define length1
(list:nil) -> 0
(list:cons _ tl) -> (+ 1 (length1 tl)))
The empty list ()
corresponds to (list:nil)
, and (_ . tl)
corresponds
to (list:cons _ tl)
. (If you're from the ML/Haskell world, (hd . tl)
is the same thing as [hd::tl]
).
A third thing to note are the wildcard variables, denoted with underscores (_
). These are "don't cares", and
internally the compiler doesn't even bother to look at them or bind them.
Let's look at another example of pattern matching on something other than lists.
;; -*- Mode: Irken -*-
(include "lib/core.scm")
(datatype tree
(:empty)
(:node 'a (tree 'a) (tree 'a))
)
(define indent
0 -> #f
n -> (begin (print-string " ") (indent (- n 1)))
)
(define tree/print
d (tree:empty) -> #f
d (tree:node val left right) -> (begin
(indent d)
(tree/print (+ d 1) left)
(print val)
(print-string "\n")
(tree/print (+ d 1) right)))
(let ((t (tree:node
5
(tree:node 7 (tree:empty) (tree:node 12 (tree:empty) (tree:empty)))
(tree:node 9 (tree:empty) (tree:empty))
)))
(tree/print 0 t)
)
The datatype tree
defines a simple binary tree. A tree
is either empty
, or
a node containing an object of type 'a
(i.e., this datatype is polymorphic), and two more trees of that same type - the
left and right branches of that node.
The tree/print
function uses a helper for indenting its output. We've defined it succinctly using pattern matching.
The indent
function takes a single integer argument - the amount of indentation to print. The base case of zero simply
returns a boolean, which becomes the return type of the whole function. The second case binds the argument to the variable
n
, which is then used to print two spaces before recursively calling indent.
The tree/print
function itself takes two arguments - a depth argument d
and the tree to print. It
prints the left side of the tree first (indented by one step), the value of that node, then finally the right tree.
match
special formSometimes you want to pattern match somewhere other than the arguments to a defined
function. The
match
special form facilitates this:
(match <exp0> <exp1> ... with
<pat0> <pat1> ... -> <result0>
<pat0> <pat1> ... -> <result1>
)
(match (+ 1 x) y with
12 z -> (+ z 9)
15 9 -> 0
x y -> (+ x y)
))
Like Scheme, Irken is properly tail recursive. Irken doesn't have imperative-style looping constructs. Instead, the compiler
detects tail-recursive calls and translates them into a goto
(with the C back end, literally). For most people,
picking up this style of programming is relatively easy, especially when you learn the 'accumulator' trick. Let's take another
look at that pattern-matching length
function:
(define length
() -> 0
(_ . tl) -> (+ 1 (length tl)))
This function is recursive, but it's not tail-recursive. Why? Look at the recursive call to length
. After calling
length, it adds one to the result. When length is called, the stack will fill up with a bunch of +1 calls until it reaches the end
of the list. It's O(N) time, but it's also O(N) space. The accumulator trick will fix the problem:
(define length2
() acc -> acc
(_ . tl) acc -> (length2 tl (+ 1 acc))
)
(define (length3 l)
(length2 l 0))
Note here that the call to the +
function is inside the recursive call (i.e., one of its arguments), rather
than outside. This version of the length
function is properly tail recursive, and will compute the length of a
list in O(N) time and O(1) space; just like the loop you might have written in C. [It's called a tail call because it's the
very last thing the function does]. Another thing: length2
takes two
arguments, not one. Note how the acc
variable passes through the pattern match untouched.
Notice the auxiliary function length3
. It provides the same interface as the original function, and provides the
initial value for the accumulator. You could hide the definition of length2
inside length3
, like
this:
(define (length4 l)
(define recur
() acc -> acc
(_ . tl) acc -> (recur tl (+ 1 acc))
)
(recur l 0)
)
Another approach would be to bind acc
inside length4, avoiding the acc
argument inside
recur
. These are style issues, ones that I'm still working out myself.
Now you understand why the vcase
comparison above was a little unfair. The vcase
version was written
with an accumulator loop, and the first pattern-matching version was not.
Irken includes a simplified version of Scheme's syntax-rules
macro facility. The main purpose of macros in Irken is
for syntax extension, not for inlining of functions (the compiler already inlines aggressively).
Here's the definition of the and
special form (see "lib/derived.scm"):
(defmacro and
(and) -> #t
(and test) -> test
(and test1 test2 ...) -> (if test1 (and test2 ...) #f)
)
This macro defines three cases of translation. An empty and
is converted into the boolean #t
. An
and
with only one case in it simplifies to that case. The normal use of and
is converted into an
if
conditional. Notice that the macro itself is recursive!
Here's another useful macro. Given a datatype for a lisp 'association list'... (see "lib/alist.scm")
(datatype alist
(:nil)
(:entry 'a 'b (alist 'a 'b))
)
...you might want to create a table. But the constructor syntax is pretty annoying:
(define numbers
(literal
(alist:entry
0 'zero
(alist:entry
1 'one
(alist:entry
2 'two
(alist:entry
3 'three
(alist:entry
4 'four
(alist:entry
5 'five
(alist:entry
6 'six
(alist:entry
7 'seven
(alist:entry
8 'eight
(alist:entry
9 'nine
(alist:nil)))))))))))))
Here's a macro to the rescue:
(defmacro alist/make
(alist/make) -> (alist:nil)
(alist/make (k0 v0) (k1 v1) ...) -> (alist:entry k0 v0 (alist/make (k1 v1) ...))
)
And the much cleaner table definition
(define numbers2
(literal
(alist/make
(0 'zero)
(1 'one)
(2 'two)
(3 'three)
(4 'four)
(5 'five)
(6 'six)
(7 'seven)
(8 'eight)
(9 'nine)
)))
Irken supports polymorphic records based on rows. A great introduction to Row Polymorphism (especially to support object-oriented features) is a slide set from Neel Krishnaswami at CMU. Rows are a very powerful feature, one that you won't find in Standard ML or Haskell. Of the mainstream ML's, only OCaml supports them, and uses them as the base for their OO/class features.
Ok, now in English/Tutorialese.
Here's how you can create a record ('struct' in C parlance) in Irken:
;; -*- Mode: Irken -*-
(include "lib/core.scm")
(define my-record {f0=#t f1="stringy" f2=1234})
(printn my-record.f0)
(printn my-record.f1)
The brackets {
and }
surround the record literal. Each slot in the record is named with a label.
When you run this file through the compiler, you'll see the type assigned to my-record
:
my-record: {f2=int, f1=string, f0=bool}
(Note: at the moment the compiler is printing row types in a much more frightening way, this will be fixed soon).
As far as the compiler is concerned, the ordering of these fields is arbitrary.
Here's a function that will deal with that record:
(define (fun r)
(+ r.f2 34))
If you look at the type of fun
as discovered by the compiler, you'll see that it is polymorphic on the field
f2
.:
fun: {f2=int, ...}
What this means is that fun
will accept for its argument any record type containing an integer field named "f2"
.
There is no need to declare record types, just use them. Here's an example of pattern matching on records:
(include "lib/core.scm")
(define thing
{a=x b=2} -> x
{a=3 b=y} -> y
{a=m b=n} -> (+ m n)
)
(printn (thing {a=3 b=1}))
(printn (thing {a=3 b=2}))
(printn (thing {a=4 b=5}))
There's a type-theoretic flip side to polymorphic records: polymorphic variants are the dual of polymorphic records.  The datatype
declaration in Irken declares a boring, statically defined
variant/sum type. But in Irken, you can create and use polymorphic variants on the fly:
;; -*- Mode: Irken -*-
(include "lib/core.scm")
(define v0 (:pair 3 #t))
(define v1 (:thingy 12))
The constructor syntax is very similar to the normal datatype constructor; only that the name of the datatype is left off.
(define fun
(:pair n _) -> n
(:thingy n) -> n
)
(printn v0)
(printn (fun v0))
(printn (fun v1))
The type for the function fun
is:
Σ{thingy='a pair=('a,'b)}
This means it'll accept any polymorphic variant of that shape: a variant called 'thingy' containing one object (of any type), or a
variant named 'pair' containing two objects (where the first one matches the type held by the thingy
variant)
Polymorphic variants are very handy; their ease of use, without declaration, anywhere, reminds me of a dynamically typed language like Python. They feel very Pythonic, yet have all the type safety you could ask for. In fact, I spent some months trying to get by in Irken with polymorphic variants as the main datatype abstraction. Two issues stopped me: First, they're inappropriate for systems-level programming - i.e., they are underspecified and would never fly in something like an OS Kernel. The second issue had to do with performance of the type solver given huge data structures (like parser tables) built using them.
OCaml supports polymorphic variants, they are introduced with a backquote in OCaml's syntax.
Irken uses a constraint-based type inference algorithm, based directly on Chapter 10 of "Advanced Topics in Types and Programming Languages". An extended version of the chapter is available online. Currently, the type solver does not support subtyping (it uses equality where a subtype rule would apply), but this should be relatively easy to change when the time is right.
The Irken compiler is written in Python, and compiles to C. It's a whole-program compiler that generates a single C file, in fact, a single C function, to represent the Irken program. The compiler translates Irken source to a core lambda-calculus language. After typing and optimization, the program is transformed into a CPS register-machine language before the final output to C.
The C output relies critically on two gcc extensions: the ability to take the address of a label, and inline/lexical functions. Other C compilers support the address-of-label extension, but fewer support lexical functions. The garbage collector is implemented as a lexical function to give it access to local heap-related variables, while still allowing the compiler to put them in registers. I've experimented with a non-lexical gc() function (and thus putting the heap-related variables into globals), and the impact on performance is hugely bad.
In practice, there are three compilers that can be used on the output from Irken:
The LLVM compiler actually does a better job of compiling the Irken output. Both compilers are able to see right through the integer tags and generate amazingly good code for integer math, for example.
The CPS/RTL output is extremely well suited for an LLVM backend, and I hope to someday explore this possibility.
In the meanwhile, the best performance to be had is with the dragonegg compiler. This is an LLVM backend jammed into gcc using its new plugin architecture.
Irken has a very lisp/scheme-like runtime. It uses runtime type tagging to enable the garbage collector to work without needing extra data from the compiler on the composition of the stack. This simplifies debugging enormously, and allows the runtime to print out objects in a useful manner. Do not underestimate the importance of this! However, there is nothing in the language that requires runtime type tagging. At some point in the future, a tagless, unboxed runtime could be designed (similar to OCaml), that would cut down on some of the heap and runtime overhead.
Integers are tagged with a single bit, the least significant. This allows the runtime to distinguish an integer by looking only
at this bit. Any odd value is an integer. This means our int
datatype loses one bit of information. In the 16-bit
days, this was horribly painful. In the 32-bit days, it was a mild inconvenience. Today, with 64 bits, I would claim that it
hardly matters at all.
Characters, #t, #f, #undefined, nil
, enum types, etc... are all represented with the second bit set and lowest bit cleared (i.e., multiples
of 2, but not 4). A dataype declaration with an empty variant constructor is also represented from this code space. This allows
all these values to be stored in a single word, and thus in a register.
All pointer types have a one-word header stored on the heap. The lowest byte of this header gives a type code (allowing the runtime to distinguish between datatypes, and between builtin types). The remainder of the word gives the number of words to follow. Pointer types are distinguished at runtime by having their lowest two bits cleared - in other words, they are aligned to (at least) a 32-bit boundary.
The garbage collector is a very simple Cheney two-space copying collector. It consists of 153 lines of C. Someday, someone will write a generational collector for Irken.
The copying collector enables Irken to have a dump/load facility. An image of the running system can be dumped to disk and reloaded later very quickly. This would be useful for things like moving or distributing a computation, checkpointing, or to get a CGI to load quickly.
Why have I written this compiler? The compiler's main purpose is to compile a VM for a python-like language. The continuation-passing design in combination with the address-of-label extension just happens to generate code identical to what someone would write by hand when implementing a threaded virtual machine. I hope to be able to write a high-performance VM in Irken directly. The other main advantage is scalability. Both the VM (for a python-like language) and its low-level runtime (written in Irken) will support full-blown continuations. This will enable the design of massively scalable systems built on user/green/non-preemptive threads. The engineering goal is to support 100,000+ threads. This goal cannot be efficiently reached with a runtime that uses pre-allocated C stacks for each thread, so we avoid using the C stack completely.
Look here to get an idea what the VM code will look like.
It has been my experience that having a green-threaded VM is not enough to build world-class systems. Usually there is a requirement for performance that dictates dropping down into C. With a system like Stackless Python, this means writing C in continuation-passing style. This is not a job for mortals. Now, to write CPS code in C without introducing bugs that impact stability and security is even harder... a job for the gods themselves.
The plan is thus to drop down to Irken when extra performance is needed, and this will be much safer than C. It will also be possible to push performance-critical networking code down to the Irken layer.
Irken began life as a straightforward implementation of Scheme, intended for writing a VM without having to do so in C (which I despise). One of my favorite Scheme implementations is scheme48, which uses a similar implementation technique - a restricted version of Scheme called 'PreScheme' that uses type inference to cut down on runtime type checking as much as possible. I decided to try to learn about type inference. After about 18 months, I finally had something working well enough for my purposes.
A similar project, with much bigger goals, is the BitC project. It is in many ways much further along than Irken, but less suited to my purposes because it uses the C stack. And they dumped the lisp syntax. 8^) But it's definitely worth following the project, I very much look forward to seeing kernels written in BitC soon!
This project is the culmination of about 15 years of work with Scheme, originally inspired by The Essentials of Programming Languages. All three editions are excellent, and very different books. The first edition is the largest and most challenging; but it contains a lot more information about continuation-passing style than the others.
Other critical references:
The following books have the additional advantage of being available online for free. Many thanks to the authors!
[XXX: I have a stack of 20 or so papers that should also be listed here]


Our goal is to make your shopping experience hassle-free. We can help with your online order, tracking a package or any other information you need. Answers to many common questions can be found below.
We accept the following credit cards for online or phone purchases:
We also accept the following payment methods for online purchases only:
- PayPal
- PayPal Credit
- Amazon Payments
You may track your order by accessing your online account and viewing the order status and tracking information in the order history details. Once the order ships, a Shipping Confirmation e-mail is sent to you with the order details and tracking number, which you may use to track your order. Economy shipping orders cannot be tracked.
Delivery times are dependent upon product, inventory status and delivery method. Typically, orders will arrive to your home within 7-10 business days. Items shipping via common carrier can take up to three weeks to arrive. Exceptions are communicated on the product information page and in your shopping cart. In rare instances, when an in-stock item becomes unavailable after you have placed an order, you will be notified via e-mail.
Registered users can log into their account and view the order history and details of any online order.
You may change or cancel your order if it hasn't been processed. Simply contact us.
General Shipping Information
Shipments are delivered Monday through Friday. We do offer Saturday delivery where available and at an additional charge. To place an order for Saturday delivery, get rates or location availability.
Delivery times may vary as orders maybe ship from more than one location and certain items could take up to 3 weeks for delivery. Item delivery times quoted are to metropolitan areas and shipments to remote locations may also take longer. Prices and terms are subject to change without notice.
Items Ship Separately
Please note that item(s) may ship separately from other locations and/or ship in separate boxes. For example, large heavy items will not ship with a light bulb. So if your purchasing items that are not friendly shipping together, you will receive the balances of your order in separate boxes.
We administer return credits within 48 hours after the product is received in our return center.
Yes, depending on the availability of the items. Contact us.
Promotional shipping offers cannot be applied to orders being shipped via Air (Next Day or Second Day). All offers are while supplies last and may not be applied to any other promotional offers or discounts, applied to previous orders or to Business to Business orders.


| complete.tbl_lazy {dbplyr} | R Documentation |
Turns implicit missing values into explicit missing values. This is a method
for the tidyr::complete()
generic.
complete.tbl_lazy(data, ..., fill = list())
data |
A lazy data frame backed by a database query. |
... |
Specification of columns to expand. See tidyr::expand for more details. |
fill |
A named list that for each variable supplies a single value to use instead of NA for missing combinations. |
Another tbl_lazy
. Use show_query()
to see the generated
query, and use collect()
to execute the query
and return data to R.
if (require("tidyr", quietly = TRUE)) { df <- memdb_frame( group = c(1:2, 1), item_id = c(1:2, 2), item_name = c("a", "b", "b"), value1 = 1:3, value2 = 4:6 ) df %>% complete(group, nesting(item_id, item_name)) # You can also choose to fill in missing values df %>% complete(group, nesting(item_id, item_name), fill = list(value1 = 0)) }


AppDirect is the leading commerce platform for selling cloud services. We help companies find, buy and use software. Our Montreal office is always on the lookout for exceptional engineering talent.
Come early! Beer and pizza being served starting at 6PM, and presentations start at 7PM.


This module allows you to tap into the pusher service directly into your Titanium Mobile applications.
Please follow the guide here.
Please see the changelog file.
To access this module from JavaScript, you would do the following:
var Pusher = require("com.pusher");
The Pusher variable is a reference to the Module object.
Please notice that besides the Pusher.setup
call, you should just use the official Pusher JS
documentation, because it's plain better than this, and the API is almost compatible :)
This should be the first function you should call on the module, and it will configure the Pusher module with the appropriate credentials. It accepts a Pusher key as the first argument, and an optional object with options.
key [string, required]: The Pusher key credential for your application
options [object, optional]: An object with advanced options:
false
if you don't
want the module to automatically reconnect to the Pusher servers when
the connection goes down. Default value is true
5
secondstrue
.auth
option are as follows:
Example:
Pusher.configure('pusher_key_deadbeef', {
appID: 'your app ID',
secret: 'your secret',
reconnectAutomatically: true,
reconnectDelay: 5,
encrypted: true,
auth: {
headers: {
CSRFToken: 'some_csrf_token'
},
params: {
param1: 'value1',
param2: 'value2'
}
}
});
When you call this function, the module immediately tries to connect to Pusher.
Initiate the connection with the Pusher servers. Please notice that the connection doesn't become immediately ready! You should wait for the "connected" event (see below) before you start subscribing and/or sending messages to Pusher.
Example:
Pusher.connect();
Manually disconnects from the Pusher server.
Example:
Pusher.disconnect();
Subscribes to a channel. The first and only argument is a String, required, and corresponds to the channel name you want to subscribe.
Example:
var channel = Pusher.subscribe('test');
Please notice that this method returns a Channel
object. For more
information about that object see the Channel documentation.
Also, please notice that after this line, the client isn't immediately binded to
the channel. You must wait for the pusher:subscription_succeeded
event on the channel
(more on that on the Channel documentation).
Unsubscribes from a channel. The first and only argument is a String, required, and corresponds to the channel name you want to unsubscribe form.
If you want to bind to an event, regardless of the channel, you should use this function. You enter the event name as the first argument, and a callback function on the second argument.
The event parameter passed on the callback function contains only the data object sent on that message (the payload) already parsed and ready to use.
Example:
Pusher.bind('testingevent', function(data) {
Ti.API.warn("Received test event with payload " + data);
});
Please notice that to stop receiving events on that callback, you should
use the unbind
function.
Unbinds a specific callback from a previously binded event.
Sends an event to a channel.
Example:
Pusher.sendEvent('eventname', 'test', {foo: 'bar', zbr: 123});
Please notice that, to use this method, you have to provide both the appID and the secret on the configure function above.
It is possible to bind to all events at either the global or channel level by using the method bind_all. This is used for debugging, but may have other utilities.
Example:
Pusher.bind_all(function(name, data) {
Ti.API.warn("Received event named " + name);
Ti.API.warn("DATA: " + JSON.stringify(data));
});
Returns the current connection state as a string.
Fired when the Pusher module successfully connects and handshakes with the Pusher servers.
Fired when Pusher disconnects from the server. If reconnectAutomatically
was
true
, Pusher will automatically try to call the server again.
Fired when Pusher is in a configured state, ready to connect.
If you bind the event named bind_all
you will automatically receive all
the events that your device receives, regardless of the event name or the
channel where it was fired. Useful for debugging purposes.
Please see the example/app.js
file included with this module.
Ruben Fonseca fonseka@gmail.com


February 26th
First Website
(Portfolio v1.0)This was the first site I created. I first discovered html playing around with iChrome's customizable iFrame. I then learned more at W3Schools
(view code)
February 26th
February 26th
February 26th


XF.pages
drives the appearance of the pages sticking together with the router. It has some basic animations for switching pages such like slideleft
, slideright
, fade
and none
. Not so much for now but keep in mind that it is possible to define your own animation to use it together with XF.pages
.
To create a page you just need to make a

with necessary classes):

<<<<<<< HEADid
is used to make page switching work together with the router. It should be equal to first url fragment of the route (e.g. books/:cat(/:subcat)
) or the name of the handler (e.g. showBooksCategory
). In this case the page with such id attribute will be shown automatically when the route (e.g. books/fiction
) will be triggered.
To show the page without changing the url or using route binding:
XF.trigger('pages:show', 'books', 'fade');
// …directly
XF.pages.show('books', 'fade');
```
`XF.App` is a 'class' that you able to extend with your own methods and properties needed in the application. In this case an instance of this class is something like a main controller of the whole app.
To define the default animation type for all device types it's needed to set up the necessary properties on the start of app:4da00e27f941b8e09cee59a7e8cd8d6fd27b4d8a
var app = new MyApp({
// …
// other settings for the application
animations: {
standardAnimation: 'slideleft' // 'slideleft' is default
}
});
If you want to create your own animation type and use it for page switching you (please care about necessary CSS animations in xf.animations.less
file):
<<<<<<< HEAD
var app = new MyApp({
// …
// other settings for the application
animations: {
types: {
'myOwnAnimation': {
fallback: function (fromPage, toPage) {
// fallback to JS animation for old legacy browsers
/// …
}
}
}
}
});
XF.device
contains the information about current user device app was launched:
XF.device.supports.touchEvents
XF.device.supports.pointerEvents
XF.device.supports.cssAnimations
XF.device.isMobile
. It was a necessary trick to detect mobile OS's using navigator.userAgent
.XF.device.type
is a selected type of devices from specified in options passed on the start of application. Based on this selected device type the necessary template for the component will be loaded.
4da00e27f941b8e09cee59a7e8cd8d6fd27b4d8a
var app = new MyApp({
// …
// other settings for the application
device: {
types : [{
name : 'tablet',
range : {
max : 1024,
min : 569
},
templatePath : 'tablet/',
defaultAnimation: 'fade' // 'fade' for tablet devices
}, {
name : 'phone',
range : {
max : 568,
min : null
},
templatePath : 'phone/'
// 'slide left' will be used for device type 'phone'
}]
}
});
XF.trigger('pages:animation:default', 'fade');
// …or not so elegant way
XF.setDefaultAnimationType('fade');
data-animation
attribute on the element with data-href
:Back
XF.trigger('pages:animation:next', 'slideright');
// …or not so elegant way
XF.setNextAnimationType('slideright');


susanne
Aubert
Product Designer
Susanne Aubert
Hi. I'm Susanne.
I'm passionate about humanising digital design through user research, empathy, movement and gamification.
Email

LinkedIn

Behance

Instagram
ticket
Restaurant
Re-design of the
ticket Restaurant
mobile app
FRIEND
REC
A travel app
based on tips
from your friends
NOS
PLAY
Redesign &
Onboarding of
streaming service
NOS Play
piercy
sans serif font
Kleo
Light Font
design
challenges


Your Emergency Support Services (ESS) File Number is:
{{referenceNumber}}
If you are under evacuation order and have identified that you require food, clothing, lodging, transportation, incidentals or other emergency supports, proceed to your nearest Reception Centre where one of the ESS volunteers on site will be able to assist you with completing your registration.
A list of open Reception Centres can be found at EmergencyInfoBC.
Please bring your ESS File Number (listed above) & government-issued ID with you to the Reception Centre.
Click here to view a full list of accepted ID.
If you do not require supports, or are under alert, no further actions are required.
With BC Services Card you'll be able to log back in to your profile to view your evacuation history, supports received as well as keep your profile details up-to-date.


- G - Static variable in class com.jwetherell.motion_detection.image.ImageProcessing
-
- getARGB(int) - Static method in class com.jwetherell.motion_detection.image.ImageProcessing
-
Get RGB values from pixel.
- getCompareX() - Method in class com.jwetherell.motion_detection.detection.Comparer
-
Number of X Boxes.
- getCompareY() - Method in class com.jwetherell.motion_detection.detection.Comparer
-
Number of Y Boxes.
- getDebugMode() - Method in class com.jwetherell.motion_detection.detection.Comparer
-
Debug mode of the comparer.
- getHeight() - Method in class com.jwetherell.motion_detection.detection.State
-
Get the height of the State.
- getLeniency() - Method in class com.jwetherell.motion_detection.detection.Comparer
-
Leniency of the pixel comparison.
- getMap() - Method in class com.jwetherell.motion_detection.detection.State
-
Get Map of the State.
- getPrevious() - Method in class com.jwetherell.motion_detection.detection.AggregateLumaMotionDetection
-
Get the previous image in integer array format
- getPrevious() - Method in interface com.jwetherell.motion_detection.detection.IMotionDetection
-
Get the previous image in integer array format
- getPrevious() - Method in class com.jwetherell.motion_detection.detection.LumaMotionDetection
-
Get the previous image in integer array format
- getPrevious() - Method in class com.jwetherell.motion_detection.detection.RgbMotionDetection
-
Get the previous image in integer array format
- getWidth() - Method in class com.jwetherell.motion_detection.detection.State
-
Get the width of the State.
- GlobalData - Class in com.jwetherell.motion_detection.data
-
This class is used to store global data.


Page Road Site Plans
IAR is seeking "site work" subcontractors for site development at 3104 Page Road, Durham.
Initially the work will include grading and related site work, building pad, foundation for a 5,160 SF building (to be upgraded to 11,000 SF later internally). A space for the trailer (close to the building) will need to be provided for the building contractor.
This work needs to start as soon as we get permit from city of Durham, hopefully in next 1-2 months. The rest of the site work including landscaping, parking, procuring all site utilities (5'-0" outside the building), power, water and sewer to the building as well as the single fire hydrant that the City has asked us to bring next to the building will be done later.
We will wait to do the final topping for parking after all work is completed.
Please note that the sewer connection is through a lift station to the development at back of our property. Page road currently does not have sewer access.
Plan are being reviewed by city and are subject to some changes but can be viewed using the link below.
For further questions please contact Hashim Naqui at<PHONE_NUMBER>, or by email<EMAIL_ADDRESS>or Dr AG Chaudhry via email achaudhrymd@gmail.com