JavaScript is required for this website to work. Please enable JavaScript on this website in order to use it.


---
layout: site
permalink: melbourne
location: University of Melbourne
dates: February 1-3, 2016
map: sites/melbourne.geojson
accommodation: somewhere in melbourne, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
days:
- day: February 1
sessions:
- title: session 1
- title: session 2
- title: session 3
- day: February 2
sessions:
- title: session 1
- title: session 2
- title: session 3
- day: February 3
sessions:
- title: session 1
- title: session 2
- title: session 3
speakers:
- name: Dr. Pika
img: img/speaker.jpg
blurb: xxx
- name: Dr. Pika
img: img/speaker.jpg
blurb: xxx
- name: Dr. Pika
img: img/speaker.jpg
blurb: xxx
- name: You!
img: img/sponsors/fake-sponsor.png
blurb: We want you to help lead a session; get in touch here.
sponsors:
- name: 'Sponsor Number One'
img: fake-sponsor.png
- name: 'Sponsor Number Two'
img: fake-sponsor.png
- name: 'Sponsor Number Three'
img: fake-sponsor.png
---
{{page.dates}}
Schedule
{{ d.day }}
Register here for the {{page.location}} Research Bazaar.
The registration process starts with a Pre-Assessment Survey, so that we can create the best possible experience for you. Use the promo code given to you at the end of the survey to complete the registration form.
{{ speaker.blurb }}
{{page.accommodation}}
Many thanks to all our sponsors for helping bring the Resarch Bazaar to the {{page.location}}.
{% for sponsor in page.sponsors %}


portfolio
more
more about me
more about what i do
more about my skills
Contact me
loading page content


{% extends "layout.html" %} {% block page_title %} GOV.UK prototype kit {% endblock %} {% block content %} BETA This is a new service – your feedback will help us to improve it. Andrea Authoriser Casterbridge College UKPRN:12345678 Home page Contracts Funding claims Settings Sign out The college of Pet Welfare Limited ESF Enter the value for the budget type £ Do you already have a personal user account? Is the activity for carry over learners? Yes No What is the start date? For example, 31 3 2016 Day Month Year What is the end date? For example, 31 3 2017 Day Month Year Select sub-contractor location Search Central Eastern East Midlands Greater Manchester / Cheshire / Warrington and Staffs Liverpool City Region / Cumbria and Lancashire London North East South Central South East South West Thames Valley West Midlands Yorkshire and the Humber Save and exit {% endblock %}
BETA This is a new service – your feedback will help us to improve it.
Is the activity for carry over learners?
Save and exit


Toggle navigation
Down to Donate
Home
${{project.amountNeeded-project.amountSofar}} more needed
for {{project.focus}}
{{project.location}}
more_vert
Breakdown
{{bar.value}}%
Donate
{{project.doctorName}}
close
{{project.treatment_description}}
{{bar.value}}%


Don't leave your money on the street.
Bitcoind is labelled as the backend of the network. When I explain this to friends I explain it like its the router that you have stuffed behind the sofa or if you are more professional, in a server room, sometimes not even in the same country you are in. Either way, it is something needed for everything else to work. But mostly ignored.
This is how I imagine the users of Bitcoin Classic to use the software, and it is the way I think it should be. They use it as something that just works to make it possible for them to keep their business or infrastructure running.
One such group of Bitcoin Classic users are the miners, they run bitcoin-classic to have an accurate view of the state of the network. The new transactions are collected in Bitcoin Classic and it creates new block templates for them. In short; Bitcoin Classic helps miners connect to the network.
What is totally out-of-character with the design that Bitcoin has had for years is that, when the miner actually mines the block that the block-reward is "stored" in the Bitcoin node.
This means that your Bitcoin Classic suddenly isn't just a piece of network infrastructure anymore. It holds thousands of dollars worth of value. And because of that you'd have to protect it. Which is not always compatible with the way that you want to use a piece of network infrastructure.
See, the original Bitcoin node that Satoshi made was a reference client and it included the ability to relay messages, it has a wallet and it knows how to mine blocks.
Over the years we stopped using the mining software because other software and hardware solutions have appeared that were much better.
We have also seen many better wallets which are much more used than a full node based wallet.
All of those still use the bitcoin full node software, like Bitcoin Classic, as a platform to build on. They communicate via various channels with the Bitcoin software which in turn connects them to the Bitcoin Network.
It is in my opinion time to separate Bitcoin Mining from the Bitcoin Wallet. We should no longer force Miners to use the Bitcoin wallet that is shipped in Bitcoin Classic. We should no longer force the horrible security practice of storing bitcoin private keys (and the money they represent) on a piece of equipment that really is meant to be like a router or a hub connecting your business to the Bitcoin network.
Stop demanding a wallet in a mining node
In Bitcoin Classic's development branch we have changed the system to allow mining on a node that does not have a wallet compiled in.
I introduced a new RPC command called createaddress
, which returns
something like this;
{ "address": "1E852VpivAYpZcwGo5bNB9U4twjnJfrL2c", "pubkey": "0303a60a215af3ea3240705db3201b5161445e1bdbd1e4e942284cfd9e9ede0ea1", "private": "KyjwYTJrhAS14fV7fP16Z9bhiudpPcSTT5HpPgpoampS57zgT59w" }
The private key is the one piece of information needed to later spent the money that would be stored on the address. To benefit from this change the miner would store this private key in a secure location.
The pubkey and the address are not needed to be stored securely, they can be used in future mined blocks. When a block is mined with the pubkey set, the money can later be redeemed using the safely stored private key.
A second new RPC command is setcoinbase
. When called with the 'pubkey'
field from above this will cause any following calls to
getblocktemplate
to be generated so when it is mined all the fees and
block reward will go to the address.
People can use the output of createaddress
, or if they don't like
change, just use the existing getnewaddress
and validateaddress
rpc
calls to create a coinbase that will end up in your bitcoind wallet.
Additionally the command-line option --gencoinbase
is added to bitcoind
which has the same effect as the setcoinbase RPC command and that may be
useful to use until the mining software is upgraded to use these new RPC
commands. Because calling getblocktemplate without setting the coinbase
will now cause an error to be returned.
This change is still only available on the development branch, and has not been scheduled for release just yet. So there is still time to give feedback on what you like or dislike or would like to change.
In my opinion these changes will have the positive effect that miners can now feel much more safe when their bitcoind connects them to the bitcoin network, without needing all the security that a full wallet should have.
When I first started working with Bitcoin, a couple of years ago, I tried to find out how to contribute code and to understand the Quality Assurance policies they held.
At this time I naturally was talking to people from the Bitcoin Core group, and the answers I got were quite confusing to me.
After having worked in the software industry for 20 years I had become very reliant on good quality assurance policies. As well as good usage of distributed source management control. Turns out that Core didn't really have any of that in place.
When I was asked to work with Gavin on Bitcoin Classic I first started to work on quality assurance policies and practices. And I'm happy to say that we have reached at least industry standard, if not a little above. But I haste to say that there is still room for improvement.
Git workflow
The first thing that I changed is that we now have a proper git workflow. This means that developers fix bugs on the stable branch and we use git merges to make those bugfixes go up to the development branch. You will find this process in any git book, so I wont' spent too much time on this. The important part is that merges between branches is done often and that way we can't lose work or introduce bugs by doing it manually. See also our contributing document.
Release process
The second part that changed is the release process itself. Based on the fact that we now have a stable branch that is always releasable the release process will become easier. The aim is to follow the good old open source concept of "Release early, release often".
One of the biggest changes is that we now follow the Semantic Versioning concept which is almost universal for open source software as well as for many closed source products.
Let me quote the core concept;
Given a version number MAJOR.MINOR.PATCH, increment the:
- MAJOR version when you make incompatible API changes,
- MINOR version when you add functionality in a backwards-compatible manner, and
- PATCH version when you make backwards-compatible bug fixes.
Additionally I wrote this in the release tag of v1.1.0
At first we wanted to follow the Core releases, but they have different
core-values and push out hundreds of lines of new code in a bugfix release
which feels dirty to have to inherit. The result of that is that the CSV
soft fork code feature release has received a bigger version bump. And
when that disconnect between Core and Classic versions it also stopped
making sense to stay close to versioning of Core.
It was time to review the numbering scheme altogether.
When I talked about the "less than 1.0" versioning over beers with
Eric S. Raymond (author of The Cathedral and the Bazaar) he explained it like this:
The idea was that when the app reaches the set of features required
for the user with the lowest demands to use it for its intended usage,
that's when you call it 1.0.
Bottom line, Bitcoin is certainly far past its 1.0 release. We will follow the Semantic Versioning from now on.
Continues Integration building
What I was really missing was a proper Continuous integration (CI) system. Naturally, there is the freely available Travis. But thats been a frustrating experience and really not useful as a build server. Apart from the fact that Travis is really slow (taking an hour or more), some and 60% of the time when it says there is a failure, it actually isn't a problem in our code, its really not useful to rely on.
I got a dedicated server in a secure environment and installed Teamcity on it. Teamcity is one of the most used CI software systems out there and quite useful for our purposes.
It does a couple of things;
- every single time a change is made in Git (in all branches) it builds this for all platforms and runs unit tests at least for the Linux ones. Notice that it does the building in a fraction of the time that Travis took. Typically a build completes in less than 15 min.
- It builds both using the 'gitian' concept of reproducible (or static) build environment for all platforms as well as using the native Linux way of using the platform dynamic-libraries (dlls). This makes sure we know it works on more than one version of boost and all the other supporting libraries.
- It builds nightly builds of the development branch allowing people to test these that don't want to compile.
- It pushes the build to remote builders (like Ubuntu's launchpad) to have an easy way to distribute nightly builds or maybe even future releases with minimum effort.
- It tests the Debian contrib to actually build properly.
As I mentioned, the server is in a secure location. What that means is that it is not connected to the internet and physically protected to make sure we can trust the output of that server. When we ship sources anyone can check quickly if they are unaltered from the tags in git. But with binaries (evil) changes can be much harder to detect. So I refuse to gpg-sign any releases unless I know they actually came from the exact sources that are in git, visible for all.
Ongoing work
There is plenty of issues that could use improvements. It turns out that the original developers don't really like writing unit tests and the code lacks any organization to make unit testing practical or easy. With some small changes such efforts could be made much easier.
We also have exactly one executable that runs all the test. Which is against the unit testing practices of having small units because one failure in one test can cause a lot of tests afterwards to start failing too, mostly because the memory states were not cleaned up properly after a failure.
Ideally we have a lot of small test executables which can be run by a simple runner. With the added benefit that you can run various in parallel (one per cpu-core) which makes the whole complete much faster as well.
We currently have a benchmark framework, but nothing in there. The idea of
a benchmark is that code which is time critical can be tested in there and
the output can be printed and plotted over a long time (months) to see that
such time critical code doesn't get slower by unintended changes from
release to release.
I find it hard to believe that Bitcoin has no time critical code, as such
we should be able to find value to locate, test and keep code from getting
slower.
Better integration Linux distro's. Bitcoin was made to be shipped as a big
executable with all the libraries inside. The thinking was that this saves
the application from misbehaving when another library changes behavior.
While the idea seems logical, it shows a lack of experience because the
open source community has been solving this problem for 30 years and it
does so quite successfully. Going against that only introduces a different
set of problems. For instance when the libc DNS exploit was made public
Bitcoin dodged a bullet because libc is one of the very few libraries we
don't actually compile in. But imagine any of the libraries we include has
such a similar vulnerability and the only way to solve that is to re-build
Bitcoin and get everyone to manually update. The Linux alternative of
just running an apt-get upgrade
or similar is vastly more secure and
better supported.
As mentioned in the CI section, I already added support for Classic in launchpad. This may be something to expand upon and support more Linux distros in a similar fashion.
Conclusion
Bitcoin Classic has a strong Quality Assurance policy, adopts long time industry standard practices and sheds unsafe self-invented ones from upstream.
We also take all the best practices from Open Source and Free Software to make releases often for those that want to test the latest and contribute by reporting issues, or simply by being part of the network.
The future is bright!


Boost QVM allows accessing vector elements by swizzling, exposing vector views of different dimensions, and/or views with reordered elements. The example below rotates v around the X axis, and stores the resulting vector back in v but with the X and Y elements swapped:
float3 v = {0,0,7}; YXZ(v) = rotx_mat<3>(3.14159f) * v;
A special case of swizzling provides next-dimension-view of a vector object, adding either 0 or 1 as its last component. Assuming float3 is a 3D vector type, and float4 is a 4D vector type, the following statements are valid:
float3 v = {0,0,7}; float4 point = XYZ1(v); //{0,0,7,1} float4 vector = XYZ0(v); //{0,0,7,0}
It is also valid for swizzling to address vector elements more than once:
float3 v = {0,0,7};
float4 v1 = ZZZZ(v); //{7,7,7,7}
Boost QVM defines all permutations of X, Y, Z, W for 1D, 2D, 3D and 4D swizzling, plus each dimension defines variants with 0 or 1 used at any position (if 0 or 1 appear at the first position, the swizzling function name begins with underscore, e.g. _1XY).
Tutorial navigation: Quaternions, Vectors, Matrices | C Arrays | Views | Swizzling | Interoperability
See also: Boost QVM


Comback - Community and Give Back
I Love attending an events from Tech-community and Also Love about Open Source.
Because I believe from there we can learn something new and improving our self.
So in my free time I tried to contribute to Open Source Projects even it's only fixing the docs.
I have been contribute to Open Source Projects such as Odoo, OCA (Odoo Community Association), odoo-themes, etc.
More information on https://github.com/repodevs.


Type Safety:
Typing
Put them in types.js
When you create a new Composi project with create-composi-app
, in the src/js folder there will be a file called types.js
. This imports default types from @composi/core
that are already used in the default code in your project's src/js/app.js file. In fact, this is where you will define any new JSDoc types you need for the code you write.
JSDoc Types
There are three ways we implement JSDoc types: on function/method parameters, as custom types with the @typedef
tag and with the @type
to indicate something's type. JSDoc supports the following native JavaScript types: null
, undefined
, string
, number
, Array
, Object
, Date
, RegExp
, Symbol
, as well as all the DOM types, such as Document
, Node
, Element
, HTMLElement
, HTMLDivElement
, etc.
Example
To show how to type your code we are going to use a simple example of a todo list. This will have a state object and we will need to add and delete items from the state. We will be using a tagged union for messages as well, which we will use to define the actions that the program's update method uses.
State
Let's start with the state. For our todo list we need an object that holds an array of items. Because it is a list, we need to keep track of keys for the virtual DOM, so we need a new key propert in the state. We also need a place to store whatever the user types in a form input to enable addding new items. Based on this we could have a state object like this:
const state = {
newKey: 104,
inputValue: '',
items: [
{
key: 101,
value: 'Talk to Mom'
},
{
key: 102,
value: 'Eat snacks'
},
{
key: 103,
value: 'Take a nap'
}
]
}
Now let's define its types. To do so we create new types using the @typedef
tag and define their properties with the @prop
tag.
// Define an Item type:
/**
* @typedef {Object} Item
* @prop {number} key
* @prop {string} value
*/
// Define the State type:
/**
* @typedef {Object} State
* @prop {number} newKey
* @prop {string} inputValue
* @prop {Item[]} items
*/
First we define an Item
type. Then, when we define the State
type, we define items as an array of type Item
. This is how you break down complex object types into simpler ones. Now we can import both the state and item types to use. We would need the item type if we want to iterate over the state's items.
Runtime Messages
The Composi runtime uses taged unions to make using messages simpler and more intuitive.  You provide the union
method a series of string for the names of the messages you need to handle. It returns an object with methods corresponding to the names. These methods return message objects of type:
{
type: 'someMessage',
data: undefined
}
The union object also has a match
method that gets two arguments, the send message and an object of methods to use if there's a match. For there to be a match, the object has to have a method that corresponds to the message type received. That means the names of the message union method that sends the message have to be identical to the object method you provide the match method with. I know, it sounds complicated, but it works out really intuitiely. Here's our messages and an actions method that deals with those messages for our hypothetical todo list:
// Create tagged union of messages:
const Msg = union('updateInputValue', 'addItem', 'deleteItem')
// Destructure the union methods:
const {updateInputValue, addItem, deleteItem} = Msg
// Now define actions to handle these messages:
function actions(state, msg, send) {
// Destructure the state:
const prevState = {...{state}}
// Test what message was recieved:
return Msg.match(msg, {
updateInputValue: value => {
prevState.inputValue = value
return prevState
},
addItem: () => {
if (prevState.inputValue) {
prevState.items.push({
key: prevState.newKey++,
value: prevState.inputValue
})
prevState.inputValue = ''
} else {
alert('Please provide a value before submitting.')
}
return prevState
},
deleteItem(key) {
prevState.items = prevState.items.filter(item => item.key !== key)
return prevState
}
})
}
If you hover the cursor over these values you'll see that the editor has now idea what types these are. We can resolve this issue by providing types for these. We'll start by define types for the actions object methods, then we'll define the message union. The reason, the message union's match method needs to know the type of the actions object. We'll be putting these in our projects src/js/types.js
file after the type we defined for our project's state.
// Define actions object:
/**
* @typedef {Object} ActionMethods
* @prop {(value: string) => State} updateInputValue
* @prop {() => State} addItem
* @prop {(key: number) => State} deleteItem
*/
// Define message union.
// Use the ActionMethod as the return type of the match method.
/**
* @typedef {Object} MessageUnion
* @prop {(msg: Message, object: ActionMethods) => State} match
* @prop {(value: string) => Message} updateInputValue
* @prop {() => Message} addItem
* @prop {(key: number) => Message} deleteItem
*/
Now we can import this MessageUnion
type to use on our tagged union:
// Import MessageUnion and apply it to the Msg object:
/** @type {import('../types').MessageUnion} */
const Msg = union('updateInputValue', 'addItem', 'deleteItem')
Doing this give our destructured functions the correct types. Next lets type the actions function:
// Import default types for state, message and send:
/**
* @typedef {import('../types').State} State
* @typedef {import('../types').Message} Message
* @typedef {import('../types').Send} Send
*/
// Apply imported types to parameters:
/**
* @param {State} state
* @param {Message} msg
* @param {Send} send
*/
function actions(state, msg, send) {
// Apply State type to prevState:
/** @type {State} */
const prevState = {...{state}}
// Apply message union type here:
/** @type {import('../types').MessageUnion} */
return Msg.match(msg, {
updateInputValue: value => {
prevState.value = value
return prevState
},
addItem: () => {
if (prevState.inputValue) {
prevState.items.push({
key: prevState.newKey++,
value: prevState.inputValue
})
prevState.inputValue = ''
} else {
alert('Please provide a value before submitting.')
}
return prevState
},
deleteItem(key) {
prevState.items = prevState.items.filter(item => item.key !== key)
return prevState
}
})
}
With the above type additions we can hover over any properties and see the corret types being shown. This lets you know that TypeScript is understanding the types that you have provided for your code. It also means that if someone tries to change the code to provide a wrong type, they will immediated get a warning from Visual Studo Code that the type is incorrect.
Learn More About Types
We just touched the surface of types with JSDoc. For more information you can consult the JSDoc documentation. I've also writen two articles about typing: JavaScript Type Linting and Type Safe JavaScript with JSDoc.
Download Examples
You can download a collection of working examples of proejcts using the Composi runtime that are fully typed as we described above. These are available at https://github.com/composi/examples. Examine the types.js
file in each project src/js
folder to see how custom types are defined. Then examine all the other JavaScript files to see how types are imported and used.


Home
About Us
Contact Us
Reservations
Mega Travel is the best travel agency you can choose. No matter the destination, we would love to help you out!
Here are some of our wonderful destinations!
Brisbane
Vancouver
New York City
Berlin
Cancun


About This Application
This application was made by Ryan Insley, with the intent to allow users to search upcoming and past movies in various parks for a fun night.
This application was made by Ryan Insley, with the intent to allow users to search upcoming and past movies in various parks for a fun night.


Introduction
About This Package
This package is currently a preview release. The first official release is expected in January. After the first official release, breaking changes will be avoided whenever possible, with the exception being breaking changes as a result of changes in the Valence API itself. However, as last minute details are worked out, there may be changes to this preview release that may cause code you create with this to be changed. It is being offered for experimental purposes at this time.
This open-source package was built to make it easier to use the API (Valence) and data exports (Data Hub) of D2L Brightspace.
This package is written in PHP. If you do not use PHP, while the packages themselves may not be of direct use to you in your applications, it may inspire you to port them over to the language of your choice.
You'll find that the documentation of this package is sparse, which is intentional. The primary functionality for this package is to use with an IDE, like PhpStorm, which offers completion for using classes, functions, fields, etc.
Want to enroll a user in a course with Valence? Just type $valenceobjectname->enroll
and
check the autocompletes for the function that contains action you're looking for. The idea is that
you will not need to dig through documentation, or memorize all the API routes and fields. You'll
use autocomplete to do it for you.
If you do not use an IDE with class-awareness and autocompletion, this package problem won't help you very much. In fact, it will probably increase the amount of time it takes to develop applications with the API as it just adds another layer of documentation you need to read.
Want to access information from the Data Hub? Just type the name of the report you want to retrieve data from (which should autocomplete for you) and access information using the Eloquent ORM.
Features
- Query the Data Hub using the auto-complete feature, chaining methods to find what you're looking for.
- Join Data Hub reports using methods.
- Leverage the Valence API using your IDE's autocomplete features, both to find the appropriate API calls and access the returned object's fields.
- Work directly in your timezone, letting the Valence class convert the times returned from API
calls in GMT to your LMS's or custom time zone, and convert them back to GMT automatically when
making a
POST
orPUT
request, all while using a more friendly format. - Use virtual PATCH objects, allowing you to specify the object you want to modify and specify only the fields you want to change, without needing to rebuild the entire data object to send with a PUT.
- Use the Data Hub as a backdrop for retrieving data, allowing you to specify specific reports to utilize or a certain threshold for how long a course must be completed to use the Data Hub, while returning the data in the same format as the API call, no longer requiring you to use two different sets of code depending upon which source you use.
Future Possible Features
- More API calls added
- More documentation, both written and inline
- More helper functions for specific processes
- More object-specific classes
- More report relationships
- Built-in support to process full and differential reports into a local database
- Helper functions to use additional features of Eloquent
- Ability to process monthly changes to the Data Hub
Note that there are some areas of the API that will not be included. For example, Wilkes University does not have the Learning Object Repository or ePortfolio addons, so they will not be included. However, if you review the source code and the documentation below, you will find that you can extend this class to add functions of your own to the API calls not included as needed.
Presentations
See the presentation below from the D2L Site Administrator Network Connection Event from May 2021:
Setup
Requirements
This class requires you to use PHP 8.1 or later to fully utilize the type hinting options available. It also requires composer. To utilize functionality of the Data Hub, you must have a database setup with each table named after a report and each field in the table named after the corresponding column of the report.
Install the Package
Install the package from composer using the command:
composer require jason-wagner/brightspace-dev-helper:dev-main
This will install the package, as well as all dependencies, including guzzlehttp/guzzle
,
nesbot/carbon
, vlucas/phpdotenv
, illuminate/database
, and
phpleague/csv
.
Generate App and User IDs and Keys
You will need to create an API App ID and key. While this package does support user authentication, you may also need to create a service account, and capture that account's USER ID and key as well. You can find the directions to use generate these through this community post.
Create the .env File
The .env file contains information about your D2L environment and database where the Data Hub reports
have been loaded, and is loaded into $_ENV
each time you run a script using this helper
class.
Use the following to get started with your .env file.
D2L_VALENCE_HOST= D2L_VALENCE_PORT= D2L_VALENCE_SCHEME= D2L_VALENCE_APP_ID= D2L_VALENCE_APP_KEY= D2L_VALENCE_USER_ID= D2L_VALENCE_USER_KEY= DB_DRIVER= DB_HOST= DB_DATABASE= DB_USERNAME= DB_PASSWORD= DB_CHARSET= DB_COLLATION= DB_PREFIX=
For the configuration, it is recommended that you set the charset to utf
and the
collation to utf8_unicode_ci
. The prefix should be set to be blank, but it is required
by the constructor of the database connection class. It may be utilized if additional functionality
to support it is added in the future.
Create the init.php File
Finally, create an init.php file which will be included in all files you create that use this package. This will automatically include all composer packages, initialize the environment variables and create a database connection.
<?php require_once __DIR__.'/vendor/autoload.php'; use Illuminate\Database\Capsule\Manager as Capsule; use BrightspaceDevHelper\Valence\Object\BrightspaceConfig; $dotenv = Dotenv\Dotenv::createImmutable(__DIR__)->load(); $valence_config = new BrightspaceConfig($_ENV['D2L_VALENCE_HOST'], $_ENV['D2L_VALENCE_PORT'], $_ENV['D2L_VALENCE_SCHEME'], $_ENV['D2L_VALENCE_APP_ID'], $_ENV['D2L_VALENCE_APP_KEY'], $_ENV['D2L_VALENCE_USER_ID'], $_ENV['D2L_VALENCE_USER_KEY']); $capsule = new Capsule; $capsule->addConnection([ 'driver' => $_ENV['DB_DRIVER'], 'host' => $_ENV['DB_HOST'], 'database' => $_ENV['DB_DATABASE'], 'username' => $_ENV['DB_USERNAME'], 'password' => $_ENV['DB_PASSWORD'], 'charset' => $_ENV['DB_CHARSET'], 'collation' => $_ENV['DB_COLLATION'], 'prefix' => $_ENV['DB_PREFIX'], ]); $capsule->setAsGlobal(); $capsule->bootEloquent();
If you will not be using this to connect to a database utilizing the Data Hub, remove the lines
related to the Capsule
above.
Using the Package
Basic Examples
Making Valence Requests
First, you will need to create a new Valence Client object:
$valenceObject = new Valence($valence_config);
Then, you just need to find the calls you want to use. Suppose you want to enroll John Smith (UserId 12345) into the ENG 101 A (OrgUnitId 67890) as a student (RoleId 246). Then you can use:
$response = $valenceObject->enrollUser(67890, 12345, 246);
The response is an object in which each of the returned items is an attribute. For example, if the
returned item has a field that is returned called Identifer
, you would access it with
$response->Identifier
.
There are also "IDer functions" which allow you to easily retrieve the IDs of items that have easily queriable codes, like Users and OrgUnits.
For example, suppose in the exam above, John Smith's username is jsmith12 and the course has an offering code of 13579.202101. We can use the IDer functions to find these IDs.
$userId = $valenceObject->getUserIdFromUsername('jsmith12'); $orgUnitId = $valenceObject->getOrgUnitIdFromOfferingCode('13579.202101'); $response = $valenceObject->enrollUser($orgUnitId, $userId, 246);
If a function does not exist for the API call you want to use, you can use the apirequest($route,
$method = 'GET', $data = null)
function to make the call. $data
is an array with
the field names provided as keys.
For example, suppose the whoami
function did not exist in this class:
$response = $valenceObject->apirequest("/d2l/api/lp/".Valence::VERSION_LP."/users/whoami");
Note the use of the constant Valence::VERSION_LP
to get the current version of the
learning platform supported by the class.
Querying the Data Hub
For the Data Hub, this package uses the Eloquent ORM to define relationships to the tables. Once relationships are defined, you can simply call methods on the classes named after what you're attempting to join. Looking for John Doe's assignment submissions?
$user = User::whereUserName('john.doe'); foreach($user->assignmentsubmissions()->get() as $submission) echo implode("\t", [$user->FirstName, $user->LastName, $submission->assignmentsummary->orgunit->Name, $submission->assignmentsummary->Name, $submission->LastSubmissionDate, $submission->Score, $submission->assignmentsummary->PossibleScore]) . "\n";
This creates a tab-delimited table with the student's first name, last name, name of the course the assignment is in, name of the assignment, timestamp of the submission, score, and number of points possible.
But what does all of this mean?
First, we find the user with the username John Doe. Normally, we would use
User::find($UserId)
, but since we probably don't know $UserId
, a helper
function was created to easily find the user by username instead. We can also use other functions of
Eloquent to find what we're looking for, such as User::where('Email',
<EMAIL_ADDRESS>or User::where('FirstName', 'John')->where('LastName',
'Doe')
. Then, since the Data Hub has a relationship between the Users
table
and AssignmentSubmissions
table (through UserId
), a relationship is
defined on the User
class in a method called assignmentsubmissions
. We
call that method, then get()
, and loop through the results.
Within the results, you can see that there are a few instances where we call
assignmentsummary
on the $submission
object. As we did above, we also
defined a relationship on the AssignmentSubmissions
and AssignmentSummary
tables to join the information. We did this again when we call orgunit
to get the name
of the course it is in, defining a relationship between AssignmentSummary
and
OrganizationalUnits
.
For other examples. you will first need to come up with a starting point, with a query on one of the objects in the database.
Then, functions were created for the relationships on each object, in both directions.
The syntax of the call for the relationship depends upon the type of relationship.
For example, consider the relationship between an OrganizationalUnit
and a
QuizObject
.
This is a one-to-many relationship: each OrganizationalUnit
can have many
QuizObject
s, but each QuizObject
belongs to only one
OrganizationalUnit
.
When something has many, we call it as a function, followed by get()
. In this
case, to get the QuizObject
s of the OrganizationalUnit
with OrgUnitId
123456, we would use the following code:
$orgObject = OrganizationalUnit::find(12345); foreach($orgObject->quizobjects()->get() as $quizobject) // loop through each quiz in $quizobject, such as $quizobject's name in $quizobject->Name
However, when something belongs to, we call it as an attribute. In this case, to get the
OrganizationalUnit
that the QuizObject
with a QuizId
of
24680, we would use the following code:
$quizObject = QuizObject::find(24680); $orgObject = $quizObject->orgunit; // record for the org unit is in $orgObject, such as $orgObject's offering code in $orgObject->Code
In a many-to-many relationship (such as the relationship between Users
and OrganizationalUnits
,
which goes through UserEnrollments
), you always use functions. In a one-to-one
relationship (such as the relationship between OrganizationalUnits
and GradebookSettings
),
you always use attributes.
Options
Logging
The setLogging($mode, $filename)
function allows you to automatically log each API call
that is requested.
If $mode
is 0, nothing is logged; if $mode
is 1, only API calls that change
data (anything besides a GET) is logged; if $mode
is 2, all calls, including GETs, are
logged.
If $filename
is provided, the logs will be saved to a file in that path. If
$filename
is not provided, it will automatically be saved in that directory in a file
called valence.log in the current directory.
Logging is disabled by default.
Error Handling
The setExitOnError($option)
function tells whether the class should exit if there is an
HTTP error is encountered, or allow the script to continue.
exitOnError is enabled by default. To disable it:
$valenceObject->setExitOnError(false);
However, if you disable it, be sure to check the HTTP status code after each call to ensure the API calls have been successful.
To re-enable it, set it to true
.
Return Object on Create
The setReturnObjectOnCreate($option)
function tells whether the class should return a
User or Course client object when one of these entities is created with the Valence class using
createCourseOffering
or createUser
. If it is set to false, it will return
the default object, which is the default setting. However, to use it:
$valenceObject->setReturnObjectOnCreate(true); $newCourseObject = $valenceObject->createCourseOffering(...); print_r($newCourseObject->get()); // displays course information $userid = $valence->getUserIdFromUsername('jsmith12'); $response = $newCourseObject->enrollInstructor($userid); // enroll John Smith in the course
Alternatively, if it were not enabled:
$valenceObject->setReturnObjectOnCreate(false); // not necessary unless it was previously enabled $newCourseResponse = $valenceObject->createCourseOffering(...); print_r($newCourseResponse); // displays course information $userid = $valence->getUserIdFromUsername('jsmith12'); $newCourseObject = $valence->course($newCourseResponse->Identifier); // to get object, must use OrgUnitId from response on creation $response = $newCourseObject->enrollInstructor($userid); // enroll John Smith in the course
Set Class Clients
There are functions, setUserClass
and setCourseClass
, that allow you to set
which class should be used to create User and Course clients if you choose to extend them to add
more customized functions. See the section below on Extending Clients.
Create Objects
To use create objects, use the constructor to create the object you want to create. When you're
created it, you can simply call the create()
.
$newCourse = $valence->newCreateCourseOfferingObject(/* arguments here */); $newCourse->create();
This will make the appropriate API call. Alternatively, you can manually call the method for the API call and pass the object as a parameter.
$newCourse = $valence->newCreateCourseOfferingObject(/* arguments here */); $valence->createCourseOffering($newCourse);
Update Objects
To use update objecrts, they work similarly to create objects except you'll call the
update()
method when finished.
$updateCourse = $valence->newCourseOfferingInfoObject(/* arguments here */); $updateCourse->update();
Like above, you can also create an update object and pass it as an argument to the method for teh API call.
$updateCourse = $valence->newCourseOfferingInfoObject(/* arguments here */); $valence->updateCourseOffering($updateCourse);
Patch Objects
Patch Objects allow you to update an entity while specifying only the fields you want to change and automatically carrying over existing items by at GET request in the background.
For example, suppose you want to activate the course with the OrgId 123456.
$patchObject = $valence->newCourseOfferingInfoPatchObject(123456); $patchObject->setIsActive(true); $patchObject->update();
Note that there is a method, setXXXXX($value)
method for every property of the block.
Array Block Objects
Array Blocks allow you to iterate through an array of results of a given object.
Support you want to iterate all the topics in ForumId 7890 of OrgUnit 123456:
$topics = $valence->getDiscussionTopics(123456, 7890); foreach($topics as $topic) // use $topic->TopicId, $topic->Name, etc.
For results that are paginated, this will automatically grab the next page of results and continue through the loop. There is no need to manually maek another API call.
Extending Clients
In the event that you need to make custom classes, you can extend any of the clients and include them in your application. This may be to add additional functions that are not supported, or to customize functions for your instance or institution.
For example, at Wilkes University, all course offering codes follow the format
crn.termcode
from Banner. Thus, I may create a helper function by doing the following:
class MyValance extends Valence { public function findIdFromCrn(int $termcode, int $crn) { return $this->getOrgUnitIdFromOfferingCode($crn . "." . $termcode): } }
If you override any class besides the main Valence class, you should set the Valence object to utilize that new class.
For example, if you extend the ValenceCourse class:
class MyValanceCourse extends ValenceCourse { ... }
Then, to tell the course object generator in the Valence class to use this when you make a new course object, use the following:
$valenceObject->setCourseClass(MyValenceCourse::class);
Using Eloquent
To do more advanced querying of the database, you should use Laravel's Eloquent ORM. Each of the reports from the Data Hub was created in this package as an Eloquent model. To learn more about what you can do with Eloquent, check out Laravel's documentation.
If you do not use an IDE with class-awareness and autocompletion, this package problem won't help you very much. In fact, it will probably increase the amount of time it takes to develop applications with the API as it just adds another layer of documentation you need to read.
There are some more advanced features of Eloquent that use relationships that you may attempt to use, but may encounter errors if you attempt to use them. This is because many of Eloquent's features rely on default settings with a database created with specific naming conventions that are not utilized by the Data Hub. All the tables in the Data Hub are named exactly as the name of the respective report with spaces removed, while the fields in the table are named exactly as the name of the respective column in the report.
For example, under Laravel's naming conventions, all tables
are to be named, in lowercase, of the plural of the object, with a primary key of
id
, and when used as a foreign key, is to take on the name singularoftablename_id
.
However, in Data Hub, the tables utilize "uppercase words" casing, and the primary key is
TablenameId
.
For the majority of Laravel's operations, the default behavior is also to assume there is a single field as a primary key; however, the Data Hub does have several tables which have a composite key.
You can still use many of this additional functionality of Eloquent; however, you may need to dig into the documentation further to find the additional fields that you need to provide to the different functions.
 These are the relationships that are currently included:
- AssignmentSubmission
- assignmentsubmissions
- assignmentsummary
- orgunit
- users
- DiscussionForum
- discussiontopics
- orgunit
- DiscussionPost
- discussiontopic
- users
- DiscussionTopic
- discussionforum
- discussionposts
- OrganizationalUnit
- assignments
- department
- discussionforums
- parents
- quizobjects
- semester
- template
- users
- QuizAttempt
- quizobject
- user
- QuizObject
- orgunit
- quizattempts
- User
- assignmentsubmissions
- courses
- discussionposts
- quizattempts
Helper Functions
The following helper functions exist to find some of the objects that have a more common identifier you may be familiar with.
OrganizationalUnit::whereCode($code)
OrganizationalUnit::whereCodeAndType($code, $type)
OrganizationalUnit::whereOrgUnitId($orgunitid)
OrganizationalUnit::isCurrent($orgUnitId, $thresholdInDays)
Users::whereOrgDefinedId($orgdefinedid)
Users::whereUserId($userid)
Users::whereUserName($username)
Frequently Asked Questions
Why are some variables in the hints in camel case (i.e. variableName) and some with uppercase words (VariableName)?
This is intentionally done to be consistent with the corresponding variables in the API. In general, variables in URLs (such as parameters within the API calls and query strings) are in camel case and fields within the JSON parameters have the uppercase first words.
Why are the variables inconsistent in terms of some being arrays and some being objects? Is there a way to have all functions return arrays instead of objects?
This is to best utilize the functionality of your IDE. In PHP, there is no way to define anything like an "array template." Thus, if we simply utilized an array, you would still need to dig in to the documentation to find the fields that are available. However, by using objects, and using type-hinting to define the return type of a function to be a particular object, your IDE can then autocomplete the attributes of an object returned by a function. Although a later version of PHP introduces the ability to specify that a function may return one of several object types, it would break -- at least partially -- the ability to autocomplete attributes of a class if we were to specify that an array could also be returned.


William W Gaver, Jacob Beaver, Steve Benford
"Ambiguity is usually considered anathema in Human Computer Interaction. We argue, in contrast, that it is a resource for design that can be used to encourage close personal engagement with systems."
"This interpretative relationship is the source of ambiguity’s appeal: by thwarting easy interpretation, ambiguous situations require people to participate in making meaning. This can involve the integration of previously disconnected discourses, the projection of meaning onto an unspecified situation, or the resolution of an ethical dilemma."
"A number of tactics may be used to enhance ambiguity of information. These focus on creating or reflecting uncertainties about information that are in some way significant.
...Use imprecise representations to emphasise uncertainty.
...Over-interpret data to encourage speculation.
...Expose inconsistencies to create a space of interpretation.
...Cast doubt on sources to provoke independent assessment.
"Blocking the interpretation of a product or system in terms of an established discourse creates ambiguity of context. This is useful in spurring people to approach a particular system with an open mind, and more generally to question the assumptions they have about technological genres.
...Implicate incompatible contexts to disrupt preconceptions.
...Add incongruous functions to breach existing genres.
...Block expected functionality to comment on familiar products."
"Ambiguity of relationship creates the condition for a deeply personal projection of imagination and values onto a design.
...Offer unaccustomed roles to encourage imagination.
...Point out things without explaining why.
...Introduce disturbing side effects to question responsibility."
"The most important benefit of ambiguity, however, is the ability it
gives designers to suggest issues and perspectives for consideration
without imposing solutions. Ambiguity of information impels people to
question for themselves the truth of a situation. Contextual ambiguity
can question the discourses surrounding technological genres, allowing
people to expand, bridge, or reject them as they see fit. Relational
ambiguity, finally, can lead people to consider new beliefs and values,
and ultimately their own attitudes. In each of these cases, ambiguity
frees users to react to designs with scepticism or belief, appropriating
systems into their own lives through their interpretations. In the
process of reacting to the system either positively or negatively,
however, users engage with issues that the designer suggests. Thus
ambiguity is a powerful design tool for raising topics or asking
questions, while renouncing the possibility of dictating answers. By
virtue of this balance, ambiguity both offers an inspiring resource to
designers and shows a deep respect for users."


Spotlight effects can be useful while giving live presentations, creating demo videos and rest depends upon your creativity.


---
layout: archive
title: Lean Prover Zulip Chat Archive
permalink: 113488general/13059outparamsandproducts.html
---
The archive URL format has changed. Please find this page at:
https://leanprover-community.github.io/archive/stream/113488-general/topic/out_params.20and.20products.html


We incarcerate a lot of people in America
You've probably heard that we have the highest incarceration rate on the planet
You've probably heard that we have the highest incarceration rate on the planet
To really put that number in context
lets look at some of the rest of the world
It's pretty striking to see a graph like that
considering we only have ~4% of the world's population
It's pretty striking to see a graph like that
considering we only have ~4% of the world's population
And while China, Iran, and North Korea might
be downplaying their numbers, most of the world isn't
When you look at incarceration per capita
our position on the list hasn't moved
In a way, incarceration rate is the more telling number
In a way, incarceration rate is the more telling number
6 times Canada's
6-9 times Western Europe's
and 16 times Japan's
And there's one state that not only leads the nation in incarcerations per capita
And there's one state that not only leads the nation in incarcerations per capita
...but leads the entire world


The width parameter must be non-negative. If the width parameter is not large enough to represent the value of r it is implicitly increased as needed. The displayed value is rounded to the nearest decimal equivalent with this accuracy. In the case of a tie, the display value is rounded to the next larger value.
The string realstr (r, width ) is the same as the string frealstr (r, width, defaultfw ) when r =0 or when 1e-3 < abs (r ) < 1e6, otherwise the same as erealstr (r, width, defaultfw, defaultew), with the following exceptions. With realstr, trailing fraction zeroes are omitted, and the decimal point is omitted if the entire fraction is zero. (These omissions take place even if the exponent part is printed.) If an exponent is printed, any plus sign and leading zeroes are omitted. Thus, whole number values are in general displayed as integers.
Defaultfw is an implementation-defined number of fractional digits to be displayed. For most implementations, defaultfw will be 6.
Defaultew is an implementation-defined number of exponent digits to be displayed. For most implementations, defaultew will be 2.
The realstr function approximates the inverse of strreal, although round-off errors keep these from being exact inverses.


Burton man was caught with crack cocaine and heroin in the street
He also obstructed a police officer
by Beth PriddingA Burton man has admitted possessing crack cocaine and heroin with intent to supply after being caught by police in the town.
David Bowes, 23, of Blakeholme Court, was arrested in Dallow Street, in the town, on Tuesday, November 12.
He was later charged with possession of heroin and crack cocaine with intent to supply, possession of cannabis and wilfully obstructing a police constable.
When he appeared at North Staffordshire Justice Centre, in Newcastle-under-Lyme, yesterday, Thursday, November 14, Bowes admitted all the charges against him.
A second man, aged 42, from Burton, was also arrested at the time on suspicion of possession of heroin and crack cocaine. He was released under investigation while police carry out further enquiries.
Bowes will next appear at Stafford Crown Court for sentencing. The date of this hearing has not yet been set.
He has been given unconditional bail until then.
Another man Bilal Shafiq, 18, of Uxbridge Street, Burton, also appeared before magistrates on Thursday.
He has been charged with possession of crack cocaine with intent to supply after he was arrested after a vehicle stop in Blakeholme Court in Burton, on November 12. He has not entered a plea to the charge.
He will appear at Stafford Crown Court on December 16 and has been granted conditional bail.


The ggplot2 package allows to build donut chart with R. This post describes how, providing explanation and reproducible code.
ggplot2
The ggplot2
package allows to build
donut charts. Note however that
this is possible thanks a hack, since no specific function has been
created for this kind of chart. (This is voluntary, to avoid donut
charts that are dataviz
bad practice)
Here is the process: - input data provides a numeric variable for a
set of entities - absolute numeric values must be translated to
proportion - group positions must be stacked: we’re gonna display
them one after the other - geom_rect()
is used to plot
each group as a rectangle - coord_polar()
is used to
switch from stacked rectangles to a ring -
xlim()
allows to switch from pie to donut: it adds the
empty circle in the middle
# load library
library(ggplot2)
# Create test data.
data <- data.frame(
category=c("A", "B", "C"),
count=c(10, 60, 30)
)
# Compute percentages
data$fraction = data$count / sum(data$count)
# Compute the cumulative percentages (top of each rectangle)
data$ymax = cumsum(data$fraction)
# Compute the bottom of each rectangle
data$ymin = c(0, head(data$ymax, n=-1))
# Make the plot
ggplot(data, aes(ymax=ymax, ymin=ymin, xmax=4, xmin=3, fill=category)) +
geom_rect() +
coord_polar(theta="y") + # Try to remove that to understand how the chart is built initially
xlim(c(2, 4)) # Try to remove that to see how to make a pie chart
Here are a couple of things you can do improve your donut chart style:
theme_void()
to get rid of the unnecessary
background, axis, labels and so on.
# load library
library(ggplot2)
# Create test data.
data <- data.frame(
category=c("A", "B", "C"),
count=c(10, 60, 30)
)
# Compute percentages
data$fraction <- data$count / sum(data$count)
# Compute the cumulative percentages (top of each rectangle)
data$ymax <- cumsum(data$fraction)
# Compute the bottom of each rectangle
data$ymin <- c(0, head(data$ymax, n=-1))
# Compute label position
data$labelPosition <- (data$ymax + data$ymin) / 2
# Compute a good label
data$label <- paste0(data$category, "\n value: ", data$count)
# Make the plot
ggplot(data, aes(ymax=ymax, ymin=ymin, xmax=4, xmin=3, fill=category)) +
geom_rect() +
geom_label( x=3.5, aes(y=labelPosition, label=label), size=6) +
scale_fill_brewer(palette=4) +
coord_polar(theta="y") +
xlim(c(2, 4)) +
theme_void() +
theme(legend.position = "none")
It is important to understand that donut chart are just stacked
rectangles that are made circular thanks to
coord_polar
.
Thus, the empty circle that makes it a donut chart is just the space between the initial Y axis and the left part of the rectangle.
xlim
left boundary is big, no empty circle. You
get a pie chart
xlim
is low, the ring becomes thinner.
If you don’t get it, just plot the chart without
coord_polar()
# load library
library(ggplot2)
# Create test data.
data <- data.frame(
category=c("A", "B", "C"),
count=c(10, 60, 30)
)
# Compute percentages
data$fraction <- data$count / sum(data$count)
# Compute the cumulative percentages (top of each rectangle)
data$ymax <- cumsum(data$fraction)
# Compute the bottom of each rectangle
data$ymin <- c(0, head(data$ymax, n=-1))
# Compute label position
data$labelPosition <- (data$ymax + data$ymin) / 2
# Compute a good label
data$label <- paste0(data$category, "\n value: ", data$count)
# Make the plot
ggplot(data, aes(ymax=ymax, ymin=ymin, xmax=4, xmin=3, fill=category)) +
geom_rect() +
geom_text( x=2, aes(y=labelPosition, label=label, color=category), size=6) + # x here controls label position (inner / outer)
scale_fill_brewer(palette=3) +
scale_color_brewer(palette=3) +
coord_polar(theta="y") +
xlim(c(-1, 4)) +
theme_void() +
theme(legend.position = "none")


Author Owen Arnold
“Connecting the implementation to an evolving model.”
Object Orientation - the way it should be done
Extending the type system to fit the problem domain, not the other way around.
- Things that have identity
- Mutable things that do not have identity
- Things that provide functionality without the need for state
For Value Objects, the first thing to do in developement is to define what equality means for objects of that type. A TDD approach works very well for this.
Advantages:
Given this function:
void print_info(std::string name, std::string colour) {
std::cout << name << "'s favourite color is " << color;
}
This works:
int main() {
std::string favourite_colour = "Red";
std::string first_name = "Dave";
print_info(first_name, favourite_colour);
}
Dave's favourite color is Red
But so does this:
int main() {
std::string favourite_colour = "Dave";
std::string first_name = "Red";
print_info(favourite_colour, first_name);
}
Red's favourite color is Dave
Solution is to make favourite_colour and first_name ValueObjects in the domain. They are both different values AND types. This can be caught at compile time.


This week, I have spent some time learning about HTML, CSS and the DOM and have been charged with the task of coming up with my own unique analogies to describe what exactly it is they all do.
Here are the ingredients required to make a delicious spaghetti bolognese; these represent the HTML elements required to build a great web-page.
You could choose to serve up all the ingredients just as they are, or you could apply a little bit of CSS by cooking and seasoning the ingredients. HTML provides content and defines what the web-page will be about. CSS adds style and structure to the HTML elements and makes the overall web-page easier and more enjoyable to read.
In this analogy, the Document Object Model (DOM) is a written down recipe of the HTML ingredients currently being displayed on the screen. Because HTML content is often automatically generated as the page runs, the recipe in the DOM may not match the original recipe used to build the page. The HTML recipe within the DOM can be directly altered and adjusted, and any changes made will be applied directly to the screen. But because the changes are only being made to the DOM and not to the original recipe, the next time the page has to reload, it will refer back to the original recipe and all changes will be gone.
When displaying HTML, the DOM considers all individual pieces of code as separate nodes. All nodes are displayed by the DOM as a hierarchical family-tree-like structure. Uh oh, I feel another analogy coming on.....
Instead of HTML code, let's imagine we are converting your favourite novel into a DOM family-tree. In this scenario, the book itself would be the first node and would sit right at the top of the tree. Then, the direct children of the book node would be all the chapter nodes who sit one branch lower than the book node. The chapters would then be parents to the paragraphs, who would be parents to the sentances, who would be parents to the words, who eventually, would be parents to the individual letters from which the book was written. The letter nodes would sit right at the bottom of the DOM family-tree, as these are the lowest child elements in the book.
Now time for some serious non-analogies to briefly explain the difference between 'boxifying' and the 'box-model'.
Boxifying is the art of logically breaking down a web-page design into a series of individual boxes, thereby making it easier to understand.
The Box Model consists of margins, borders, padding and content, which together make up every HTML element on the page. Each of these aspects can be adjusted to create different styles, effects and spacing.
To see some of the other cool ideas I got from taking a look around other websites' DOMs, please check out My CSS Design Wishlist!
Cheers,


Tek
21-Jun-19 06:43 PM
well yeah but the BTC ratio is like
I remember last cycle when i was still a newb and I was buying eth at 0.04 ish and sold at 0.05ish
but it went all the way to 0.11
I don't think im selling my eth anymore
my eth, my xmr, my dash and btc


Anonymize DICOM with AWS Lambda
This proof-of-concept takes advantage of serverless computing to perform DICOM file anonymization. This also showcases the considerable number of DICOM file manipulations that can be performed client side in a browser.
Choose a DICOM file, folder of nested DICOM files, or a zip archive, and click "Anonymize" to kick off the process. Here's what will happen:
- The input DICOM file headers are parsed in the browser before upload, and some headers are displayed
- Upon clicking "Anonymize", a request is made to AWS API Gateway, which proxies the request to an AWS Lambda function. This function generates pre-signed upload credentials for AWS S3, or Simple Storage Service.
- The client page then uses the pre-signed upload credentials to send the DICOM data to S3 securely (via SSL/HTTPS). As soon as the upload completes, the anonymization Lambda function is triggered.
- The anonymization Lambda function contains an instance of the RSNA DicomAnonymizerTool, which is used within the Clinical Trials Processor to perform anonymization. The function loads the DICOM data from S3.
- Upon receiving the image data, the file is immediately anonymized and loaded back into S3. The original (non-anonymized) data is immediately deleted.
- While the Lambda function is processing the data, the client polls S3 for the completed file. Once finished, the file is downloaded and displayed in the page.
Some important points:
- This is for demonstration/testing purposes only. Do not upload files containing Protected Health Information as defined by HIPAA. If you don't know what that is, this tool probably isn't for you.
- However, if used in a properly managed healthcare environment with appropriate HIPAA logging and other standard security practices, this tool would conform to HIPAA PHI protection requirements when used with an AWS account having a signed BAA in place. The data is encrypted in transit via SSL/HTTPS, anonymized immediately and PHI is not stored anywhere outside the client machine.
- The source code is here.


The Scene object is a base class to construct a Scene upon. The scene is basically a view that can be swapped at runtime with other scenes. It is supposed to contain other Graphic Objects inside of it, since it won't draw anything on its own. The draw method is simply calling the draw method for each child object.
More...
#include <GraphicsScene.h>
The Scene object is a base class to construct a Scene upon. The scene is basically a view that can be swapped at runtime with other scenes. It is supposed to contain other Graphic Objects inside of it, since it won't draw anything on its own. The draw method is simply calling the draw method for each child object.
◆ GraphicsScene() [1/3]
| GraphicsScene::GraphicsScene |
( |
| ) |
|
◆ GraphicsScene() [2/3]
◆ GraphicsScene() [3/3]
◆ ~GraphicsScene()
| GraphicsScene::~GraphicsScene |
( |
| ) |
|
|
virtual |
◆ addObject()
Add an object to the scene. *** Once added, the object is bound to the scene and it will take care of deleting the object when destroyed ***.
- Parameters
-
◆ addObjects() [1/2]
| void GraphicsScene::addObjects |
( |
GraphicsObject ** |
toadd, |
|
|
size_t |
number |
|
) |
| |
Add an array of objects to the scene.
- Parameters
-
| toadd | The array of objects |
| number | The number of objects |
◆ addObjects() [2/2]
| void GraphicsScene::addObjects |
( |
const std::vector< GraphicsObject *> & |
toadd | ) |
|
Add a vector of objects.
- Parameters
-
| toadd | The vector of objects |
◆ clearObjects()
| void GraphicsScene::clearObjects |
( |
| ) |
|
Removes all the objects from the scene, taking ownership back on them.
◆ draw()
| void GraphicsScene::draw |
( |
uint32_t |
time | ) |
|
|
overridevirtual |
The draw method. It will be called once per frame for each object in a scene.
- Parameters
-
| time | A time parameter (as given by SDL_GetTicks) for time-based animation purposes |
Implements GraphicsObject.
◆ getObjects()
| const std::vector< GraphicsObject * > GraphicsScene::getObjects |
( |
| ) |
const |
◆ operator=()
◆ removeObject() [1/2]
Removes an object from the scene. *** You take ownership of the object back, so the scene won't delete it anymore ***.
- Parameters
-
| toremove | The object to remove |
◆ removeObject() [2/2]
| void GraphicsScene::removeObject |
( |
int |
index | ) |
|
Removes an object at the given index.
- Parameters
-
| index | The inner index of the object |
◆ show()
| void GraphicsScene::show |
( |
| ) |
|
The documentation for this class was generated from the following files:


| Medbourne HR 20m | 26 March 23 | 20 | miles | |
| Name | Position | Road bike | Actual Time | Avg. mph |
| Rhys Thomas | 1 | 1 | 00:59:23 | 20.21 |
| Matt Plews | 2 | 00:59:33 | 20.15 | |
| Jamie Kershaw | 3 | 01:01:26 | 19.53 | |
| Jonathan Durnin | 4 | 01:01:31 | 19.51 | |
| Julian Middleton | 5 | 01:01:58 | 19.37 | |
| Simon Ward | 6 | 01:05:47 | 18.24 | |
| Adrian Killworth | 7 | 01:05:58 | 18.19 | |
| Kevin Mills | 8 | 2 | 01:09:18 | 17.32 |
| Steven Coulam | 9 | 01:10:25 | 17.04 | |
| Ruby Isaac | 10 | 3 | 01:12:52 | 16.47 |
| Tom Evans | DNS | |||
| Andrew Weatherby | DNS | |||
| Richard Krause | DNS | |||
| Tom Reynolds | DNS |


{% extends 'base.html' %} {% block title %}Registration success{% endblock %} {% block content %}
Congratulations! You have successfully registered for an account!
You can go to your pantry to begin tracking groceries.


passphrase.io
private online notepad
Enter any passphrase above to get started. No account required.
- Private - all of your data is encrypted
- Safe - no cookies, tracking, or ads
- Simple - all you need is your passphrase
- Free - and open source
- Fun - enter common words/phrases to see notes left behind by others!
For high security, use a long, complex passphrase that is difficult to guess. Short passphrases lead to high visibility, and text can be overwritten by anyone who stumbles upon it. Please keep in mind that your passphrase is case sensitive.
Your notepad is encrypted in your browser before it is sent to our server for storage. We have no way of knowing your passphrase or seeing the contents of your notepad. If you forget your passphrase, there is no recovery process.
Technical Details:
Using client-side JavaScript, your passphrase is run through the memory-intensive scrypt key derivation function (N=218, r=8, p=1, dkLen=32) to generate a secret key.
Your secret key is used to encrypt your notepad with AES256 encryption. The ciphertext (encrypted notepad) is sent along with a SHA256 hash of your secret key to the server for storage.
When you retrieve your notepad, your SHA256 hash is sent to the server, and the ciphertext is returned. The ciphertext is decrypted using your secret key, revealing your notepad.
Passphrase.io was inspired by the concept of the Bitcoin briainwallet, which allows you to store money in your brain by memorizing a passphrase.
Created By:
Daniel Routman
<EMAIL_ADDRESS>16pxFP2C4mYBrG7mufnXZVWCLhNq7Vmdjo
terms of use
passphrase.io © 2016


| resolution {ggplot2} | R Documentation |
The resolution is the smallest non-zero distance between adjacent values. If there is only one unique value, then the resolution is defined to be one. If x is an integer vector, then it is assumed to represent a discrete variable, and the resolution is 1.
resolution(x, zero = TRUE)
x |
numeric vector |
zero |
should a zero value be automatically included in the computation of resolution |
resolution(1:10) resolution((1:10) - 0.5) resolution((1:10) - 0.5, FALSE) # Note the difference between numeric and integer vectors resolution(c(2, 10, 20, 50)) resolution(c(2L, 10L, 20L, 50L))


--- layout: default title: Tinymce parent: Reference nav_order: 1111111 ---
This page is the /swipe-articles/tinymce folder
/swipe-articles/tinymce


Best Buy Pre-Black Friday 2019: Today's Best Deals on Tech
by Forbes FindsBlack Friday may not be here just yet, but Best Buy has already announced a series of deals on awesome products on tech, from TVs to smart home devices. One of the best places to hunt for discounts is Best Buy’s Deals tab, which includes Deal of the Day offers, the weekly ad and a round-up of the hottest current deals. Using this tab, we’ve put together a list of our favorite deals from Best Buy, which are all available right now, weeks before Black Friday. Hey, with deals like these, who even needs Black Friday?
Samsung 75-inch NU6900
Original Price: $1,099.99
Sale Price: $999.99
Samsung has been building some of the better TVs of the past few years, and the 6 Series is an excellent example of that. You’ll get a 4K resolution, with support for HDR and Samsung’s UHD Engine, which should be able to upscale even older content to look great. The TV is smart too — it has Samsung’s Tizen operating system built right into it, which allows you to install all your favorite streaming apps and services.
JLab Audio Epic Air Sport
Original Price: $149.99
Sale Price: $119.99
Perhaps you’re looking for a great pair of true wireless headphones, and JLab Audio has been building some great ones for a while now. The best thing about JLab Audio’s true wireless headphones is the fact that they have an ear hook to stay firmly on your ears. No more worrying about your earbuds bouncing down the drain. The headphones are also pretty comfortable and sound great — which is always helpful.
Simplisafe Entryway Kit
Original Price: $299.99
Sale Price: $229.99
If you’re looking for a way to better secure your home, then Simplisafe is an excellent way to go. This kit comes with a main hub, a keypad, a door sensor and a video doorbell — so you’ll be able to secure your entire entryway, which is always handy. The camera has a 1,080p resolution and supports two-way audio, so it should be more than capable of capturing whatever is going on around your front door.
HP Envy x360 2-in-1 Laptop
Original Price: $829.99
Sale Price: $679.99
The HP Envy x360 is a great way to get a relatively powerful and stylish computer at an affordable price. The laptop comes with an Intel Core i5 processor, along with 8GB of RAM and 256GB of storage — plus it has a nice, big 15.6-inch display that’s perfect for watching movies and TV shows. Safe to say, this is a great laptop for professionals and students alike.
Lenovo Yoga C940 2-in-1
Original Price: $1,699.99
Sale Price: $1,499.99
You might need something a little more powerful, in which case the Lenovo Yoga C940 is a great laptop. This laptop swaps out the lower-power specs for an impressive Intel Core i7 processor, 16GB of RAM and 512GB of storage. You’ll even get an Nvidia GeForce GTX 1650 graphics card, which is great news for those who need slightly better graphics performance for basic video editing and gaming.


Back
About SheafScope
SheafScope's user interface is based on Java JDK 1.5. See the
usage documentation
for more detailed information about the various features of SheafScope.
Copyright © 2014 Limit Point Systems, Inc.
Back


Lattice Mapping Report File for Design Module 'ice40up_simple_adc_impl_1' Target Vendor: LATTICE Target Device: iCE40UP5KSG48 Target Performance: High-Performance_1.2V Mapper: version Radiant (64-bit) <IP_ADDRESS>0.6 Mapped on: Mon Sep 24 15:06:15 2018 Design Information Command line: map ice40up_simple_adc_impl_1_syn.udb D:/Radiant_porting/ADC_del taSigma/SimpleSigmaDeltaADCSourceCode/project/ice40up/verilog/ice40up_veril og.pdc -o ice40up_simple_adc_impl_1.udb -gui Design Summary Number of slice registers: 63 out of 5280 (1%) Number of I/O registers: 0 out of 117 (0%) Number of LUT4s: 101 out of 5280 (2%) Number of logic LUT4s: 37 Number of inserted feedthru LUT4s: 27 Number of replicated LUT4s: 1 Number of ripple logic: 18 (36 LUT4s) Number of IO sites used: 13 out of 39 (33%) Number of IO sites used for general PIOs: 13 Number of IO sites used for I3Cs: 0 out of 2 (0%) Number of IO sites used for PIOs+I3Cs: 13 out of 36 (36%) (note: If I3C is not used, its site can be used as general PIO) Number of IO sites used for OD+RGB IO buffers: 0 out of 3 (0%) Number of DSPs: 0 out of 8 (0%) Number of I2Cs: 0 out of 2 (0%) Number of High Speed OSCs: 0 out of 1 (0%) Number of Low Speed OSCs: 0 out of 1 (0%) Number of RGB PWM: 0 out of 1 (0%) Number of RGB Drivers: 0 out of 1 (0%) Number of SCL FILTERs: 0 out of 2 (0%) Number of SRAMs: 0 out of 4 (0%) Number of WARMBOOTs: 0 out of 1 (0%) Number of SPIs: 0 out of 2 (0%) Number of EBRs: 0 out of 30 (0%) Number of PLLs: 0 out of 1 (0%) Number of Clocks: 1 Net i_clk_in_c: 60 loads, 60 rising, 0 falling (Driver: Port i_clk_in) Number of Clock Enables: 4 Net SSD_ADC/sigmae_0_i: 10 loads, 10 SLICEs Net SSD_ADC/rollover: 8 loads, 8 SLICEs Net SSD_ADC/box_ave/accumulate: 11 loads, 11 SLICEs Net SSD_ADC/box_ave/latch_result: 8 loads, 8 SLICEs Number of LSRs: 1 Net i_rst_in_c_i: 59 loads, 59 SLICEs Top 10 highest fanout non-clock nets: Net i_rst_in_c_i: 59 loads Net SSD_ADC/rollover: 20 loads Net SSD_ADC/box_ave/count[0]: 15 loads Net SSD_ADC/box_ave/accumulate: 12 loads Net SSD_ADC/sigmae_0_i: 10 loads Net SSD_ADC/box_ave/accum10_0: 8 loads Net SSD_ADC/box_ave/count[1]: 8 loads Net SSD_ADC/box_ave/latch_result: 8 loads Net SSD_ADC/box_ave/count[2]: 6 loads Net SSD_ADC/box_ave/sample_d1: 5 loads Number of warnings: 0 Number of errors: 0 Design Errors/Warnings No errors or warnings present. IO (PIO) Attributes +---------------------+-----------+-----------+ | IO Name | Direction | Levelmode | | | | IO_TYPE | +---------------------+-----------+-----------+ | o_sample_rdy | OUTPUT | LVCMOS33 | +---------------------+-----------+-----------+ | o_analog_out | OUTPUT | LVCMOS33 | +---------------------+-----------+-----------+ | o_digital_out[7] | OUTPUT | LVCMOS33 | +---------------------+-----------+-----------+ | o_digital_out[6] | OUTPUT | LVCMOS33 | +---------------------+-----------+-----------+ | o_digital_out[5] | OUTPUT | LVCMOS33 | +---------------------+-----------+-----------+ | o_digital_out[4] | OUTPUT | LVCMOS33 | +---------------------+-----------+-----------+ | o_digital_out[3] | OUTPUT | LVCMOS33 | +---------------------+-----------+-----------+ | o_digital_out[2] | OUTPUT | LVCMOS33 | +---------------------+-----------+-----------+ | o_digital_out[1] | OUTPUT | LVCMOS33 | +---------------------+-----------+-----------+ | o_digital_out[0] | OUTPUT | LVCMOS33 | +---------------------+-----------+-----------+ | i_analog_cmp | INPUT | LVDSE | +---------------------+-----------+-----------+ | i_rst_in | INPUT | LVCMOS33 | +---------------------+-----------+-----------+ | i_clk_in | INPUT | LVCMOS25 | +---------------------+-----------+-----------+ Removed logic Signal GND undriven or does not drive anything - clipped. Signal SSD_ADC/box_ave/un5_accum_cry_0_0.S0 undriven or does not drive anything - clipped. Signal SSD_ADC/box_ave/un5_accum_cry_0_0.CIN undriven or does not drive anything - clipped. Signal SSD_ADC/box_ave/un5_accum_cry_9_0.COUT undriven or does not drive anything - clipped. Signal SSD_ADC/counter_cry_0[0].S0 undriven or does not drive anything - clipped. Signal SSD_ADC/counter_cry_0[0].CIN undriven or does not drive anything - clipped. Signal SSD_ADC/counter_s_0[9].COUT undriven or does not drive anything - clipped. Signal SSD_ADC/counter_s_0[9].S1 undriven or does not drive anything - clipped. Signal SSD_ADC/sigma_cry_0[0].S0 undriven or does not drive anything - clipped. Signal SSD_ADC/sigma_cry_0[0].CIN undriven or does not drive anything - clipped. Signal SSD_ADC/sigma_s_0[9].COUT undriven or does not drive anything - clipped. Signal SSD_ADC/sigma_s_0[9].S1 undriven or does not drive anything - clipped. Block GND_cZ was optimized away. ASIC Components --------------- Instance Name: SSD_ADC.DDRInst0 Type: IOLOGIC Run Time and Memory Usage ------------------------- Total CPU Time: 0 secs Total REAL Time: 0 secs Peak Memory Usage: 57 MB Copyright (c) 1991-1994 by NeoCAD Inc. All rights reserved. Copyright (c) 1995 AT&T Corp. All rights reserved. Copyright (c) 1995-2001 Lucent Technologies Inc. All rights reserved. Copyright (c) 2001 Agere Systems All rights reserved. Copyright (c) 2002-2018 Lattice Semiconductor Corporation, All rights reserved.


First time? - Click here for a guided virtual tour.
* Reminder: Do not share the private key provided when registering!
You can view messages sent online now !
This is the chat - everyone can send messages and request invitations if you have not yet been invited.
This is your wallet - here you can enter the public key you received when you registered and see transactions in the account.
Transactions - Here you can transfer coins from your personal wallet to another user's wallet.
All fields must be entered, and at the end of the transaction it will be transferred to the "Transactions pending" department (next step)
Transactions awaiting mining - Every transaction that is made moves here and waits for any user on the network who clicks the mining button and thus "approves" these transactions.
"Block Explorer - As implied by the word itself it is actually "Block researcher". A blockchain system consists of blocks, so that in each block there is a record of all the transactions made in the block. Here we can search by "Block ID", "User public key","Transaction ID".
Displays all user-made transactions: {{searchValue}}
The amount left over: {{ addressData.addressBalance }} HCMUS-CN
| Sender: | Address: | Sum: |
|---|---|---|
| {{ transaction.sender }} | {{ transaction.recipient }} | {{ transaction.amount }} |
A graph detailing recent payments
Sorted by dates and amounts sent on those dates by the user: {{searchValue}}
View recent transactions and begin the mining processNo results found for the above search key: {{searchValue}}
Transfer virtual currency (HCMUS-CN) to another account
| Transaction ID | Sender | Address | Sum |
|---|
*The table is updated in real time!
The mining was carried out successfully! Now the deals have been completed and the currencies have been updated in the digital wallets.
The main idea behind the technology is to create a system that enables online business activity without the need for the supervision of a central management entity. For example, transferring funds between colleagues without the need for supervision or management by an outside party. To date the banks have served as supervisors of all the money transfers and are the ones who guaranteed the value of the physical currencies and banknotes. In P2P (peer-to-peer) platforms, there is no external body that oversees business activity and technology replaces the role of banks.
This is actually the foundation behind blockchain technology. Using this technology the digital registration is kept in the computers of all the network users without revealing their identity. The digital registration includes information about the users' accounts and the registration of money transfers made from the accounts, where the information is accessible, transparent and available to any other user, while strictly maintaining the identity of the users and their privacy.
The information is encrypted at the highest level and stored in a block that joins the existing blockchain. Each block is mathematically related to the block in front of it so that existing information stored in the blocks cannot be changed. This reduces fraud and significantly minimizes the risk of various scams. It is worth noting that each block is locked within a given period of time, while in Bitcoin the operation takes about ten minutes. After locking the information and attaching the block to the block chain, the system produces a unique digital signature that originates from the previous block. Therefore, the technology is considered safe and any user who tries to change a particular detail in the information stored in one of the previous blocks will get a different result and its operation will be rejected.
It is important to emphasize that the information on all transactions is stored chronologically in blockchain technology. Once a block is digitally locked it joins the block chain, so the system is considered secure and reliable, and it is almost impossible to forge or change information in the blocks.
Using the technology, all users have access to the data, but do not have the ability to control the stored information. In this way, third-party supervision of the transfer of virtual currencies between digital wallets can be waived - saving fees, shortening time and streamlining the method for the benefit of the general public. This is exactly why banks and other financial institutions are afraid of technology, and only recently have they begun to explore how blockchain systems can help them.
Cong Anh - 21 years old - Student at HCMUS.
The Project about blockchain for a course which i enrolled !


| Created: | 1/27/2021 3:44:44 PM |
| Modified: | 1/27/2021 3:44:44 PM |
| Project: | |
| Advanced: |
| Attribute |
|
Public serial id |
|
Details:
|
|
Public date draw_date |
|
Details:
|
|
Public date pay_date |
|
Details:
|
|
Public varchar(255) state |
|
Details:
|
|
Public jsonb verification_status |
|
Details:
|
|
Public varchar(255) created_by |
|
Details:
|
|
Public varchar(255) updated_by |
|
Details:
|
|
Public timestamp with time zone(0) created_at |
|
Details:
|
|
Public timestamp with time zone(0) updated_at |
|
Details:
|
|
Public timestamp with time zone(0) sco_balance_verified_at |
|
Details:
|
|
Public integer smart_link_number |
|
Details:
|
|
Public date deposit_date |
|
Details:
|
| Operation | ||
|
Public draws_pkey( id: serial, |
||
|
Details:
<<PK>>
|
| Element | Source Role | Target Role |
|
«table» sco_balances Table «FK» |
Name: sco_balances_draw_id_foreign |
Name: draws_pkey |
|
Details:
|
||
|
«table» remittance_advices Table «FK» |
Name: remittance_advices_draw_id_foreign |
Name: draws_pkey |
|
Details:
|
||
|
«table» events Table «FK» |
Name: events_draw_id_foreign |
Name: draws_pkey |
|
Details:
|
| Tag | Value |
| Owner | public |
|
Details:
|
| Property | Value |
| isFinalSpecialization: | 0 |


Tel: +974 1234 5678 Mob: +974 8765 4321
OFFICE NO. 200-70, SECOND FLOOR, AL APTECH BUILDING - NO.10, AL MATAR STREET, ZONE 50, QATAR


Camellia - Artificial Snow (SoundCloud Link) Full Song: Your browser does not support the audio element. Loop Cut 1: Your browser does not support the audio element. Go Back


--- layout: archive title: Zulip Chat Archive permalink: /stream/113488-general/topic/prop_decidable.20breaks.20dec_trivial.3F.html ---
local attribute [instance] classical.prop_decidable example : (-1:ℤ) ≠ (0:ℤ) := dec_trivial -- fails /- exact tactic failed, type mismatch, given expression has type true but is expected to have type as_true (-1 ≠ 0) state: ⊢ as_true (-1 ≠ 0) -/
In practice this is in the middle of a big file which needs decidable props but occasionally also needs simple calculations like this. Is this expected behaviour?
Did you try local attribute [instance, priority 0] classical.prop_decidable
?
Works! Thanks!
What's happening here? Oh -- we have two instances
We really need that tips_and_tricks.md
in mathlib docs
I sometimes wonder why we can't solve diamond issues using priorities. "now we have two instances of topological_space (X x Y) and they're equal but not defeq so we have rw problems" -- "well just make the one you want a higher priority"
Good question!
{% endraw %}Last updated: Apr 24 2020 at 19:02 UTC


Pakistan expects India to appreciate Kartarpur Corridor initiative: FO
by https://www.dawn.com/authors/397/the-newspaper-s-staff-reporter, The Newspaper's Staff ReporterISLAMABAD: Foreign Office spokesman Dr Mohammad Faisal, at the weekly media briefing, on Thursday said that Pakistan expected India to appreciate its gesture of opening visa-free Kartarpur Corridor for Sikh pilgrims, which was taken in the spirit of promoting peace and harmony in the region.
Dr Faisal said approximately 12,000 Yatrees were present on the occasion of the corridor’s inauguration, including 5,000 Indian pilgrims who came through Wagah and about 5,000 from across the world. About 700 pilgrims came through Kartarpur Sahib Corridor.
Responding to a question about the ‘review and reconsideration’ of death sentence for Indian spy Kulbhushan Jadhav by military’s Field General Court Martial in the wake of the International Court of Justice’s verdict, the spokesman said: “All actions will be in line with the laws of Pakistan. The decision of the ICJ will be honoured in the light of laws of Pakistan”.
He ruled out “any deal” on Jadhav.
Foreign Office spokesman rules out ‘any deal’ on issue of spy Kulbhushan Jadhav
Replying to a question about the visit of Foreign Secretary Sohail Mahmood and the Inter-Services Intelligence’s director general to Kabul, he confirmed the trip and said that it yielded an agreement “to enhance mutual coordination and take steps to move forward”.
It was further agreed to hold a meeting of the Afghanistan-Pakistan Action Plan for Peace and Solidarity in Kabul in December.
Published in Dawn, November 15th, 2019


So I studied at Auburn to do hardware but did as much software as hardware. Served as a volunteer aboard a ship called the Logos Hope for 2 years. When I worked at Lockheed Martin as a hardware engineer, I was doing software for 100% of my time.
Anything I participate in, I usually rise to the top.
Anything that doesn't work right calls me to fix it.
I will quickly say 'yes' to things most people won't do.
If my job doesn't challenge me enough, I usually have to find something extra that to stimulate me.
Availability is a two-way street. Plan, and there's no problem.
My worst flaw: getting bored quickly.


Players joined: {{ game.players.joined }}/{{ game.players.expected }}
{{# if ready }} Ready {{ else }} Not ready {{/ if }}
Ready
Not ready
All players joined!
Click on START to begin the game.
Code: {{ game.city.code }}
{{> commonLoadingAction active="active" }}
waiting for players...
Are you sure you want to quit this game?


SuperSoccer
Payment deadline: 01/06/2015
Vantaa
13/07/2015
Bus leaving from Helsinki at 14:30
Hotel Vantaa
not included
20 €
80 €
30 €


Revoke and drop roles
You must log into the database as Pat before proceeding with this page.
To revoke and drop roles, the commands are as simple as the following.
- Revoke roles 'Mgr' and 'custService' from users Joe and Bob respectively using the REVOKE command.
- Drop roles using the DROP ROLE command.


polaron energy formation states hematite electron α-Fe Phys. {border-style Fig. photocurrent px;} #ffffff;} Chem. charge delocalised device polarons carrier state PPPC solar dynamics polaronic absorption lattice localised photoelectrochemical recombination small time using water Lett. applied localisation pump (Fig. Sci. metal observe transport ultrafast nm Rev. band excited transition Supplementary based carriers data electronic impact performed photoanodes potential px; signal strong trapping used {font-family X-ray calculations changes complex decay different excitation font-size kinetics lead measurements observed photogenerated push reorganisation small-polaron state, Mater. Nat. Research associated characteristic density double; excess large modes nature new oxides power process reported response semiconductors signals spectroscopy splitting states, transient (Supplementary ./acs.jpclett.b Creative Methods NIR Nature Ultrafast border-color border-width cells component detection early electrons function holes intrinsic longer method model optical oxidation oxide photoelectrodes rise role shown shows solid; spectrum transfer visible wave {font-style {font-weight (PPPC) (see (α-Fe ./PhysRevB.. ./s--- Adv. Baker Bakulin Commons Commun. Dynamics Ernzerhof However, Nano PEC Pendlebury Soc. [], agreement amplifier atomic barrier bold cell coherent configuration constant conversion courier; devices dielectric directly electrochemical electrode em; experiments films frequencies frequency grid.. higher http://orcid.org/--- increasing information intensity layer limit material materials mechanism organic performance performance. photoexcited photons photovoltage potentials probe probed proposed provide pt;} pulses resulting reveal self-trapping sensitive single slower structure study surface synthetic systems times timescales use ~ fs


Kirk Herbstreit Hints At College GameDay’s Potential Location During Rivalry Week
by Matt LombardiESPN College GameDay has never been to Minnesota, but it looks like it’s possible that could be changing soon. Kirk Herbstreit hinted that the Golden Gophers have a decent shot at luring the show next week.
A few weeks back, ESPN chose Tuscaloosa for Alabama vs. LSU over Minneapolis for Minnesota vs. Penn State. Golden Gophers fans were understandably upset, given the situation.
Herbstreit told viewers on ESPN on Saturday to keep an eye on Minnesota vs. Northwestern today, because it could have “GameDay implications.” In short, that means that if the Golden Gophers win, ESPN is going to very much consider heading up to Minneapolis.
If both Minnesota and Wisconsin win on Saturday, the rivalry game next Saturday would be for the Big Ten West title and a shot at either Ohio State or Penn State in the league’s title game.
Minnesota is in the midst of one of its best seasons in recent memory, but the Golden Gophers did lose to Iowa last week. Still, they’re 9-1 with a shot at winning the Big Ten and playing in the College Football Playoff.
Minnesota and Wisconsin are dead tied in their rivalry at 60-60-8. The Golden Gophers won last year’s meeting – their first win over the Badgers since 2003.
Hopefully, GameDay decides to make the trip. It’d be a nice change of pace.


Veteran outfielder Parra signs with Japan’s Yomiuri Giants
TOKYO (AP) - Veteran outfielder Gerardo Parra has agreed to a contract with the Yomiuri Giants.
The 32-year-old Parra has a career .276 batting average with 88 home runs and 522 RBIs over 11 seasons in the major leagues.
A native of Venezuela, Parra hit .250 with eight home runs and 42 RBIs in 89 games for the World Series champion Washington Nationals after spending the first 30 games of the 2019 season with the San Francisco Giants.
The two-time National League Gold Glove Award winner started his MLB career with the Arizona Diamondbacks in 2009 and also played for the Brewers, Orioles and Rockies.
The Yomiuri Giants are Japan’s oldest professional team and won the Central League pennant this season for the first time in five years.
More AP sports: https://apnews.com/apf-sports and https://twitter.com/AP_Sports
Sign up for Daily Newsletters
Copyright © 2019 The Washington Times, LLC.
Please read our comment policy before commenting.


Install and Run¶
Before installing Vizier DB Web UI, you should install VizierDB - Web API. The Web API is the backend that provides the API that is used by the Vizier DB Web UI.
Install VizierDB - Web API¶
Installation is still a bit labor intensive. The following steps seem to work for now (requires [Anaconda](https://conda.io/docs/user-guide/install/index.html)). If you want to use Mimir modules within your curation workflows a local installation of Mimir v0.2 is required. Refer to this [guide for Mimir installation details](https://github.com/VizierDB/Vistrails/tree/MimirPackage/vistrails/packages/mimir).
Python Environment¶
To setup the Python environment clone the repository and run the following commands:
>>> git clone https://github.com/VizierDB/web-api.git
>>> cd web-api
>>> conda env create -f environment.yml
>>> source activate vizier
>>> pip install git+https://github.com/VizierDB/Vistrails.git
>>> pip install -e .
As an alternative the following sequence of steps might also work (e.g., for MacOS):
>>> git clone https://github.com/VizierDB/web-api.git
>>> cd web-api
>>> conda create --name vizier pip
>>> source activate vizier
>>> pip install -r requirements.txt
>>> pip install -e .
>>> conda install pyqt=4.11.4=py27_4
Configuration¶
The web server is configured using a configuration file. There are two example configuration files in the (config directory)[https://github.com/VizierDB/web-api/tree/master/config] (depending on whether including Mimir `config-mimir.yaml`
or not `config-default.yaml`
).
The configuration paramaters are:
api - server_url: Url of the server (e.g., http://localhost) - server_port: Server port (e.g., 5000) - app_path: Application path for Web API (e.g., /vizier-db/api/v1) - app_base_url: Concatenation of server_url, server_port and app_path - doc_url: Url to API documentation
fileserver - directory: Path to base directory for file server - max_file_size: Maximum size for file uploads
engines - identifier: Engine type (i.e., DEFAULT or MIMIR) - name: Engine printable name - description: Descriptive text for engine - datastore:
- directory: Base directory for data store
- viztrails
- directory: Base directory for storing viztrail information and meta data
name: Web Service name
debug: Flag indicating whether server is started in debug mode
logs: Path to log directory
When the Web server starts it first looks for the configuration file that is reference in the environment variable `VIZIERSERVER_CONFIG`
. If the variable is not set the server looks for a file `config.yaml`
in the current working directory.
Note that there is a `config.yaml`
file in the working directory of the server that can be used for development mode.
Run Server¶
After adjusting the server configuration the server is run using the following command:
>>> cd vizier
>>> python server.py
Make sure that the conda environment has been activated using `source activate vizier`
.
If using Mimir the gateway server sould be started before running the web server.
API Documentation
For development it can be helpful to have a local copy of the API documentation. The [repository README](https://github.com/VizierDB/webapi-swagger-ui) contains information on how to install the UI locally.
Install VizierDB - Web UI¶
Start by cloning the repository and switching to the app directory.
>>> git clone https://github.com/VizierDB/web-ui.git
>>> cd web-ui
Inside the app directory, you can run several commands:
Install build dependencies
>>> yarn install
Start the development server
>>> yarn start
Bundles the app into static files for production
>>> yarn build
Additional Commands
Starts the test runner.
>>> yarn test
Remove this tool and copies build dependencies, configuration files and scripts into the app directory. If you do this, you can’t go back!
>>> yarn eject
Configuration¶
The UI app connects to the Web API server. The Url for the server is currently hard-coded in the file `public/env.js`
. Before running `yarn start`
adjust the Url to point to a running Web API server. By default a local server running on port 5000 is used.


WH Official Who Sat In On Ukraine Meetings To Depart NSC
A National Security Council official who attended Ukraine-related meetings that are now being probed by the House in an impeachment inquiry will leave the White House this Friday, Politico reported.
The report did not give a specific reason for Earl Matthews’ exit, but an NSC spokesperson praised Matthews and told Politico that “we have no doubt he will continue to serve his country well in his future endeavors.”
There are no plans to replace Matthews, according to the report, which noted that Robert O’Brien, the national security advisor who succeeded John Bolton, has sought to shrink the size of the NSC.
Matthews sat in on meetings with Ukraine President Volodymyr Zelensky while traveling with Bolton in Europe, Politico said. He also was present for Vice President Mike Pence’s Warsaw meeting with Zelensky, according to the report. After the meeting, a U.S. ambassador told a Zelensky aide that a hold on military assistance would not be lifted until the Ukraine public announced investigations into President Trump’s political rivals, the ambassador and others testified to Congress.
An administration official told Politico that Matthews had not been wrapped up in the House impeachment probe, for which other key witnesses having testified after resigning from their posts in Trump’s administration.
The House requested the voluntary testimony of Bolton, but doesn’t appear to be willing to go court to secure it.


Quick Start¶
If you have a Micro SD card preloaded with the PYNQ-Z1 image, you can follow the quick start instructions below. Otherwise go to the next section for the full getting started with PYNQ guide in section 3.
Set up the board¶
1 Set the boot jumper to SD, insert the Micro SD card into the board, and connect the USB cable (Micro-B), and Ethernet cable
2 Connect the other end of Ethernet cable to your laptop or router, and the USB cable to your laptop or a powered USB port
3 Power on the board, and wait ~30s for the board to boot (The LEDs will flash, and the yellow LEDs will stay on when the board is ready)
4 Open a browser and go to http://pynq:9090 or http://<IP_ADDRESS>:9090 (It may take some time for the network to resolve the board address.)
The Jupyter password is xilinx
Jupyter Portal¶
In the Jupyter portal, click on the Welcome to Pynq notebook to get started.
You can find some getting started, and example notebooks in the home area.
Problems¶
If you have problems setting up, or connecting to your board, see the full getting started guide in section 3 or check the Frequently asked questions in section 16.
Support¶
For issue, please go to the PYNQ support form on the main PYNQ Webpage


Testing the quality of wine
Enter the type
Enter the fixed acidity
Enter the volatile acidity
Enter the citric acid
Enter the chlorides
Enter the free sulfulr dioxide
Enter the total sulfur dioxide
Enter the density
Enter the PH number
Enter the sulphates
Enter the fixed alcohol
Calculating