This tutorial will demonstrate Moneysocket through hands-on experience using applications built upon the protocol libraries. This includes the Moneysocket Chat App, the Costanza Wallet and the Custodial Provider Portal. By following these steps, you should gain knowledge of how these pieces interoperate through the protocol and should hopefully stoke your imagination for what kinds of apps could be developed in the Moneysocket ecosystem.
Moneysocket Chat:
Costanza Wallet:
Instead of reading this, this tutorial can be watched on YouTube:
Moneysocket works on an account model for holding an balance assigned authorized to a socket connection. This account with the ability to transact on the Lightning Network must be provided at the "Terminus".
For advanced users that wants to self-custody, you can run the Terminus application with your Lightning Network node. However, this tutorial is to show you a quicker path using a custodial account.
Go to the Custodial Portal and register:
Please acknowledge the warning for you to not leave satoshis in the custodial accounts that you are not comfortable leaving as a donation to the project. The portal does not verify your email address, but if you leave a real address, we can contact you in the event the accounts are reset.
Once you are logged in to the account, you will see a greeting screen that is mostly blank, but with a New Account button. You can create up to five accounts with the portal, but you will only need one:
This account starts with zero satoshis, which you will have to deposit later. It also has a cap, since we do not desire to hold significant sums of Bitcoin for you.
You will need to press the Generate Beacon button to generate a beacon string. You can generate up to three beacons per account, but you will only need one. The information in the string is the means by which the wallet connects to this account.
The string can be copy-pasted or rendered into a QR Code by pressing the button to make it easy to scan with a phone.
The project provides a wallet application that uses Moneysocket, named Costanza Wallet that is meant to be a prototype for future wallet-like apps that take advantage of the protocol. It needs no installation and simply runs in your web browser. It works great in a smartphone browser as well.
To run, you simply point your browser at the URL: socket.money/wallet
It stores the information it needs to store in the browser's local storage, so when it comes back, it can remember your data which do not leave your computer. You should see a screen that looks like this:
You will need to press the Connect Wallet Provider button at the top to open the dialog for setting up a provider connection:
This is where you can paste or scan the QR of the beacon string generated in step 2 above. When you do, you should see it establishing a connection to the provider, but then automatically return to the home screen with the zero satoshi balance of the account:
The wallet is built for sending and receiving satoshis via socket connections to an application, however it allows you to send and receive manually like other Lightning Network wallets too.
If you click on the zero satoshi balance on the main screen, you will be given those options.
The Manual Receive button will take you to a screen where you can request a bolt11 invoice of a chosen amount of satoshis. For this tutorial, just a small amount of satoshis is sufficient.
Upon requesting the invoice, a QR code will display the bolt11 and also give you the option to copy the bolt11. Paying the bolt11 will result in the balance appearing on the main screen.
We are now ready to create a socket connection to an app.
The Moneysocket chat app can be accessed at socket.money/chat
In this chat app, each chat message costs 1 satoshi. However, this would be awkward to pay with conventional Lightning Network wallets, since each payment requires manual actions. With Moneysocket, we can automate the payment and proceed to chat the way we expect in chat apps.
On the side panel of the chat app, click the Generate New Beacon button to start the connection process. It will display a QR code, but pause at the "Waiting For Rendezvous" stage.
We must copy or scan this beacon value into the wallet to make a connection. On the wallet, click the App button in the top-left corner.
Either scan in or paste in the beacon value from the chat app. When the connection completes, the chat app should show a balance of 0.000 sats
The wallet should present the authorization dialog. We need to authorize a balance to be spendable through the connection. This prevents exposing your entire wallet balance.
Select 50% and then press the Set button to authorize half of the available wallet balance.
This authorized balance will also appear on the chat app on the side panel.
Now that we are connected, we can type messages into the chat box and see the invoices paid automatically and the satoshis deducted.
Likewise, you can see these actions automatically update on the wallet interface.
By setting up the socket connection, we have enabled the chat application to drive payments. The Enter press to send a chat message also sends a payment. This is done without a browser plugin and isn't limited to applications that use a web browser (though that's the easiest way to deploy software). The permission over access to the user's funds are enforced by the user's wallet application.
The beacon string provided a simple way of connecting two different applications together for the purposes of these payments. This tutorial had you manually setting up the connection by transferring the beacon, however it can easily be imagined how the beacon can be we membered by applications for automatic setup the next time the user returns to the application.
Thanks for following this tutorial. IF you have any questions or comments, please join us in our Telegram group.


{% extends 'base.html' %} {% block addTitle %}
Error: There was an error while handling your request.


Most common:
CN I (olfactory n.), CN VII (facial n.), CN VIII (vestibulocochlear n.)
Intermediately common:
CN II (optic n.), CN IV>III>VI (oculomotor nn.)
-
CN I
due to tearing of olfactory n. filaments in/near cribiform plate through which they traverse
Associated with: CSF rhinorrhea, an/hyposmia, dysnosmia, parosmia, cacosmia
In higher level patients: decreased appetite, weight loss, altered feeding pattern
-
CN VII
vulnerable due to its long tortuous course through the temporal bone
- Tactile sensation to parts of the external ear
- Taste sensation to the anterior 2/3s of the tongue
- Muscles of facial expression
- Salivary and lacrimal glands
-
CN VII
loss of hearing or postural vertigo and nystagmus immediately after trauma
-
CN II
partial damage can result in scotomas, blurry vision or homonymous hemianopsia
-
References
Elovic E, Baerga E, Galang GF, Cuccurullo SJ, Reyna M, Malone RJ. Physical Medicine and Rehabilitation Board Review. 3rd ed. New York, NY: Demos Medical; 2015. Chapter 2, Traumatic Brain Injury. P.96-146.


Adapted from code by Chaoqun Ni. Modified by Vicky Steeves for Spring 2018 LIS-458-OL at Simmons SLIS. CSS and JS from Bootstrap. Theme is Readable from Bootswatch.


[Resx:{key:"MailCatchDescription"}]
[Resx:{key:"SmtpError"}]
[Resx:{key:"DnnEventTraceDescription"}]
[Resx:{key:"LogMessageTraceDescription"}]
When enabling "mail catch" a confirm dialog should be shown to make sure the user knows what he does (mails are no longer send to recipients).


Catan
Ready
Roll
Build
Play Development Card
Trade
End Turn
Settlement
Road
City
Development Card
Submit Trade
Confirm Trade
Send


<EMAIL_ADDRESS>+6011 1147 5816
Instagram phco.pcdepot
Facebook phco.my
Copyright © 2019 ph&co | PC Depot. All right reserved.


For any given "Type", the list of "Choices" that the system uses to attempt to answer "Did you mean this?" is listed below. You may edit the available Choices to add, remove, or modify any of them. Changing an available Choice will not modify any Listings. If/When an ONC-ACB uploads or edits a Listing in such a way as to create a new possible Choice, it will be automatically added to the available Choices.


class: center, middle, inverse, title-slide # Data viz in the Wild ### Maria Schweer-Collins --- background-image: url(https://media.giphy.com/media/3oxRmGNqKwCzJ0AwPC/giphy.gif) --- class: inverse, left, middle # Visualization One [National Park Attendance by Year and Park](https://samveverka.shinyapps.io/NationalParksAttendance/) - Desgined for anyone - Particularly for those interested in R visualization with shiny apps - Purpose is to describe changes in national park attendance over the past century --- #Uses the following packages: ```r # library(shiny) # library(reshape2) # library(ggvis) # library(dplyr) # library(DescTools) ``` --- ##Strengths ![strength](strengths.JPG) - Interactive: can change the dates, attendance rate, and park - Synthesizes a large amount of data - Simple --- ##Improvements - Create a drop-down menu for national park names - Use scale_y_log() to improve visibility of data from parks with lower attendance - Make it color blind friendly: make all park lines in gray, color or highlight selected park lines - An option to highlight one park in relation to all others; as it is, only the selected park line shows up - An option to select multiple parks for comparison (example: National Parks in the Northwest) [Link](https://samveverka.shinyapps.io/NationalParksAttendance/) --- class: left, middle, inverse #Visualization Two: Parent-Child Relationships - Academic Audience - Communicates that parents are *most* likely to respond to negative child behavior with positive skills; whereas parents are *equally* likely to respond to appropriate child behavior with positive or negative skills. -- --- class: center, middle ![](hackman.JPG) Source: Hakman, M., Chaffin, M., Funderburk, B., & Silovsky, J. F. (2009). Change trajectories for parent-child interaction sequences during parent-child interaction therapy for child physical abuse. Child Abuse & Neglect, 33(7), 461-470. --- ![](hackman.JPG) ##Strength - The side by side comparison; visualization would be less effective with only one comparison --- ![](hackman.JPG) ##Improvements - Take out neutral child behavior, maybe even neutral parent behavior - Add color to the bars for positive and negative parent responses - Relabel y-axis - percent is confusing - perhaps total number? - Reorder so that positive parent responses (i.e., highest bar) is first - Relabel the figure --- class: center, middle, inverse # Thanks! Slides created via the R package [**xaringan**](https://github.com/yihui/xaringan).


{% include navigation.html %}
{% include get-tags.html %}
{{ page.title }}
{% include blog_nav.html %}
{% comment %}
=======================
The purpose of this snippet is to list all the tags you have in your site.
=======================
{% endcomment %}


You will never know until you try.
Home
23
Python
3
Mongodb
1
Spark
1
Algorithm
4
Deep learning
1
OpenCL
1
Operating system
1
Lecture
8
HPC
1
Docker
2
Yu's Tech 블로그
프로그래밍 이야기
Introduction to Spark
22 Mar 2021
Distributed programming
Spark
Apache spark에 대한 기본적인 지식을 다룬다.
New
Old


Social Security Unveils Online Form For Seniors To Report Contacts From Impostors
by Ted KnutsonThe Social Security Administration published an online form today for seniors to report they have been contacted by persons fraudulently claiming the scammers work for the agency.
.
.
“I am deeply troubled that our country has not been able to stop these crooks from deceiving some of the most vulnerable members of our society,” said Social Security Commissioner Andrew Saul.
The unveiling of the form came barely a month after Senate Aging Committee Chair Maine Republican Susan Collins complained to Saul in a letter Social Security’s response to impostor scams was lagging.
She urged the Social Security chief to add staffers in regional offices to handle the increasing number of calls and in-person visits from seniors complaining about the scammers.
In announcing the form, the agency noted Social Security phone scams are the #1 type of fraud reported to the Federal Trade Commission and Social Security.
“Over the past year, these scams—misleading victims into making cash or gift card payments to avoid arrest for Social Security number problems—have skyrocketed,” the agency alerted.
The announcement of the form stressed a real Social Security employee will never tell a senior his or her Social Security number has been suspended and never ask for credit or debit card numbers over the phone.
The agency also assured Social Security employees will never threaten seniors.
“If there’s a problem with your Social Security record, Social Security will mail you a letter. If Social Security needs you to submit payments, the agency will provide instructions in the letter, including options to make those payments,” the announcement explained.
The link to the form is:
.


2 Thessalonians 3:8
Neither did we eat any man's bread for nought; but wrought with labour and travail night and day, that we might not be chargeable to any of you:


— jscodeshift API
node of root webpack configuration
key of an Object webpack configuration property
key within the configuration object to update
the value to set for the key
Recursively adds an object/property to a node
— jscodeshift API
AST node
key of a key/val object
Any type of object
Action to be done on the given ast
Creates an appropriate identifier or literal property
— jscodeshift API
Creates an appropriate literal property
— jscodeshift API
Finds or creates a node for a given plugin name string with options object If plugin declaration already exist, options are merged.
— jscodeshift API
plugins: []
NodePath where plugin should be added.
See https://github.com/facebook/jscodeshift/wiki/jscodeshift-Documentation#nodepaths
ex. webpack.LoaderOptionsPlugin
plugin options
Creates an Object's property with a given key and value
— jscodeshift API
Property key
Property value
Finds and removes a node for a given plugin name. If the plugin is the last in the plugins array, the array is also removed.
— jscodeshift API
node to start search from
name of the plugin to remove
It lookouts for the plugins property and, if the array is empty, it removes it from the AST
jscodeshift API
node to start search from
rootNode modified AST.
Find paths that match new name.space.PluginName()
for a
given array of plugin names
— jscodeshift API
Node to start search from
Array of plugin names like webpack.LoaderOptionsPlugin
Node that has the pluginName
Finds the path to the name: []
node
— jscodeshift API
Node to start search from
property to search for
found node and
Finds the variable to which a third party plugin is assigned to
— jscodeshift API
plugins: []
Root Node.
See https://github.com/facebook/jscodeshift/wiki/jscodeshift-Documentation#nodepaths
ex. extract-text-plugin
variable name - ex. 'const s = require(s) gives "s"`
Returns constructed require symbol
— jscodeshift API
Name of require
path of required package
Returns true if type is given type
AST node
node type
Convert nested MemberExpressions to strings like webpack.optimize.DedupePlugin
AST node
member expression string.
Transform for merge. Finds the merge property from yeoman and creates a way for users to allow webpack-merge in their scaffold
— jscodeshift API
jscodeshift API
transformation object to scaffold
action that indicates what to be done to the AST
ast - jscodeshift API
Get an property named topScope from yeoman and inject it to the top scope of the config, outside module.exports
— jscodeshift API
jscodeshift API
transformation object to scaffold
action that indicates what to be done to the AST
ast - jscodeshift API
Removes an object/property from the config
— jscodeshift API
AST node
key of a key/val object
Any type of object
Traverse safely and return type
for path object with value.value property
AST node
type at given path.
Generated using TypeDoc
Adds or updates the value of a key within a root webpack configuration property that's of type Object.


Privacy Policy
This Privacy Policy governs the manner in which mp4upload collects, uses, maintains and discloses information collected from users (each, a "User") of the www.mp4upload.com website ("Site"). This privacy policy applies to the Site and all products and services offered by mp4upload.
- Personal identification information
We may collect personal identification information from Users in a variety of ways, including, but not limited to, when Users visit our site, register on the site, and in connection with other activities, services, features or resources we make available on our Site. Users may be asked for, as appropriate, name, email address. Users may, however, visit our Site anonymously. We will collect personal identification information from Users only if they voluntarily submit such information to us. Users can always refuse to supply personally identification information, except that it may prevent them from engaging in certain Site related activities.
- Non-personal identification information
We may collect non-personal identification information about Users whenever they interact with our Site. Non-personal identification information may include the browser name, the type of computer and technical information about Users means of connection to our Site, such as the operating system and the Internet service providers utilized and other similar information.
- Web browser cookies
Our Site may use "cookies" to enhance User experience. User's web browser places cookies on their hard drive for record-keeping purposes and sometimes to track information about them. User may choose to set their web browser to refuse cookies, or to alert you when cookies are being sent. If they do so, note that some parts of the Site may not function properly.
- How we use collected information
mp4upload may collect and use Users personal information for the following purposes:
- To improve our Site
We may use feedback you provide to improve our products and services.
- To improve customer service
Your information helps us to more effectively respond to your customer service requests and support needs.
- How we protect your information
We adopt appropriate data collection, storage and processing practices and security measures to protect against unauthorized access, alteration, disclosure or destruction of your personal information, username, password and data stored on our Site.
- Sharing your personal information
We do not sell, trade, or rent Users personal identification information to others. We may share generic aggregated demographic information not linked to any personal identification information regarding visitors and users with our business partners, trusted affiliates and advertisers for the purposes outlined above.
- Third party websites
Users may find advertising or other content on our Site that link to the sites and services of our partners, suppliers, advertisers, sponsors, licensors and other third parties. We do not control the content or links that appear on these sites and are not responsible for the practices employed by websites linked to or from our Site. In addition, these sites or services, including their content and links, may be constantly changing. These sites and services may have their own privacy policies and customer service policies. Browsing and interaction on any other website, including websites which have a link to our Site, is subject to that website's own terms and policies.
- Advertising
Ads appearing on our site may be delivered to Users by advertising partners, who may set cookies. These cookies allow the ad server to recognize your computer each time they send you an online advertisement to compile non personal identification information about you or others who use your computer. This information allows ad networks to, among other things, deliver targeted advertisements that they believe will be of most interest to you. This privacy policy does not cover the use of cookies by any advertisers.
- Changes to this privacy policy
mp4upload has the discretion to update this privacy policy at any time. When we do, we will post those changes on this page. You acknowledge and agree that it is your responsibility to review this privacy policy periodically and become aware of modifications.
- Your acceptance of these terms
By using this Site, you signify your acceptance of this policy. If you do not agree to this policy, please do not use our Site. Your continued use of the Site following the posting of changes to this policy will be deemed your acceptance of those changes.
- Contacting us
If you have any questions about this Privacy Policy, the practices of this site, or your dealings with this site, please contact us.
© 2014 mp4upload, All Rights Reserved


Samsung Galaxy Note9 gets One UI 2 beta (based on Android 10)
by PeterThe Samsung Galaxy Note9 may be a year older than the Note10, but it is not far behind – just a couple of days after the new model got the second beta One UI 2, the first Note9 units are joining the program as well.
Besides the revamped Samsung UI, this update also brings Android 10 with it. If you’re not already in, you’ll need to download the Samsung Members app and join the One UI beta program if you want to receive this update.
Here are a few screenshots from a user that already updated:
As Samsung warns, beta software is liable to have bugs in it, so that’s something to keep in mind before making the jump. Also note that there are a limited number of spots for beta testers.
The Galaxy S9 and S9+ are next in line for the Android 10 beta, it should become available next week to users in South Korea, Germany and the US.


Display Inline vs. Inline Blocks in CSS
HTML elements are catergorized as either block-level elements or inline elements.
Inline elements do not start on a new line, they displays on the same line to the other contents.
While block elements always starts on a new line and takes up the full width available on that section.
This blog will show you how the display: Inline and display: Inline-blocks
properties in CSS changesthe layout of those elements.
Inline Elements:
Inline elements do not take up all the space
of its container. It usually sits within other elements and only takes as much space as it’s content needs. And thus, you can have
multiple Inline elements in the same line. However, you can not have a width and height set for an inline element. Examples of inline
elements are <span> <em> <img> :
Block Elements:
The behavior of Block level element is that it takes
up all the space of its rectangle anyway. Which means, it doesn’t let other elements use the empty space of its own rectangle, by
default it takes the full width of the page. The block element forces a line break after itself. Examples of block elements
are: <div> <p> <fig>:
Display: Properties
The display property specifies the display
behaviour of the elements. By default, the display behaviour is defined by the tags of the content, as states above, there are inline
elements and block elements. The display property can override the display behaviour regardless to the element type, here are some
examples:
In the CSS file I have added the display: inline property, we can see that the the block element
<div> has now displayed like an inline element. There is no line breaks between each contents and it only takes the space that is needed
for the content itself. The display: inline property overrides the default setting and redefines the display behaviour of the elements.
In this case I have chagnged the CSS file to display: inline-block,
we can see that the elements are still inline, but they are showing like a box. The basic difference between the two properties is that,
display: inline completely ignores the width and hight set, display: inline-block
does not ignore height and width and developer can set width and height for each elements.


##TITLE2##
Method 1:
Method 2:
Select an image:
Help
Hold the mouse down to activate the zoom and see the images in more detail.


| DOSE: T+ 0:00 |
10 mg |
oral |
2C-I |
(powder / crystals) |
| T+ 0:00 |
1 bowl |
smoked |
Cannabis |
|
| T+ 0:45 |
1 bowl |
smoked |
Cannabis |
|
| T+ 4:45 |
5.0 mg |
oral |
Hydrocodone |
(pill / tablet) |
| T+ 4:45 |
1 tablet |
oral |
Pharms - Metaxalone |
|
| T+ 4:45 |
1 bowl |
smoked |
Cannabis |
|
| T+ 7:45 |
5.0 mg |
oral |
Hydrocodone |
(pill / tablet) |
For a while now I've believed my days of experimenting with psychedelics were behind me. For the last couple years I've been content to smoking my weed, and I've been considering giving that up.(Right) I've done my share of drugs. Believe me when I tell you I have experience with drugs of all types. I've always been curious, and when I found out how wonderful drugs could be, when done in the proper ways, my curiosity naturally drew me towards a life I once promised myself I would never participate in. But that time in my life ran its course, so I thought.
Poking around on-line one day I came across one of those 'legal' weed sites.  Sure, I've heard of
this shit, but I've always thought it was for old hippies who can't score any real stuff anymore, or college kids who donít want to get caught smoking weed in their dorm. But this site perked my curiosity and I started searching around for other legal ways to get high. That's when I found some random discussion board where people were talking about 2C-I. 'Hmmmm. This sounds interesting.' This is the first time I've heard about research chemicalsI promptly ordered some before I could talk myself out of it.
That's when I started reading about people's experiences posted online. I learned an extraordinary amount about this substance just from reading, and I'd recommend that everyone thinking about trying this or any other substance do the same. For starters, I realized I needed to get a scale, and I actually found a pretty descent one; accurate down to 10mg.
[Erowid Note: For substances active at such a small dose, scales accurate to 10 mg are insufficient measuring devices. See related article]
The other extremely valuable thing I learned from reading experiences with 2C-I is this drug has a tendency to sneak up, and even though I may think I need more, I don't. Now to the actual trip report.
My package arrived via express mail early in the afternoon, and as luck would have it, my scale was to be delivered later that same day. I hurried excitedly to my room, shut the door, and ripped open the envelope. There it was, my own little bag, clearly labeled 2C-I, 100mg. Upon close inspection of the bag I noticed the off white colored flakes looked crystalline in appearance and tended to clump together. I compared my little baggie of dust to pictures posted online, and I decided this was 2C-I.
At this point I'm getting excited, and I can't wait for my scale to get here. I was alone for the day, and after much deliberation that week I decided to try 10mg, a small dose, and see what it does. But I wanted to be safe, so I waited for my scale to arrive.
After smoking a couple bowls I grew tired of waiting. I knew I could eyeball a safe amount if this was indeed 100mg, but I was a little scared after reading about one person's experience in which he got double what he ordered.
[Erowid Note: A volume amount of one powder doesn't necessarily weigh the same as the same volume of another powder. For substances active at such a small dose, eyeballing is particularly unwise. See related article]
I dump out the bag, and pretend I have 100mg, even though a little was stuck to the inside of the bag. I carefully split this pile in half. I then split one of the piles in half, and then in half again. If I was exact, I would have exactly 12.5mg, but in reality, it was closer to 9 or 10. I took this small amount and put it under my tongue. It tasted the way I expected, slightly bitter, but easy to handle. I let it dissolve, and then washed it down with water. Now I wait.
I already knew that this drug could take anywhere from 45 minutes to 2 hours to kick in. It was 3:15 when I took the stuff. I smoked another bowl, and realized I should prepare myself for the trip I'm about to take so I dimmed the lights, put on some nice ambient trance, and just meditated for a few minutes. I've always known of the importance of being in a positive frame of mind before I do psychedelics, and I wasn't about to take any chances with this drug. I wasn't quite sure of where this trip would take me, but I was definitely prepared.
Calm, yet excited, I was already feeling good from the weed. I noticed it slowly start to change my perceptions about fifteen minutes after swallowing, and by 4:00 I already had an idea of where this trip was heading. It starts subtle, I have a black subwoofer that started to shift suddenly to shades of gray, then back to black, and the body load at this point was also already noticeable. But the effects are light and pleasant and very easy to handle. I'm enjoying myself so I smoke another bowl.
By 5:00 I feel like I'm feeling the full effects and I start to wonder how much I've taken. The body load and visuals are getting intense, but despite a little confusion I still feel pretty much together mentally. The visuals at this point are amazing. Full CEV's and OEV's. Beautiful patterns crawling all over everything. Things seem distorted, then suddenly come back to normal. This drug has an amazing effect on shadows, and light, my mind was creating a vast array of objects out of the shapes of shadows.
Also, I can't leave this out, this drug makes sex amazing. Granted, my experiences were autoerotic, but it doesn't change the fact that it was comparable to MDMA in the sex department. And I have had sex on MDMA. One thing to note about that, I've only ever cum once one MDMA, I had no trouble cumming on 2C-I. And trust me, it was sweet. Moving on.
 It's safe to say I'm tripping balls at this point, but I still feel more in control than on acid, and less in heaven than on MDMA. I'm also feeling a little speedy, but I expect this from my past experience with psychedelics. I remember having some deep introspective thoughts at this point as well, which I wonít get into, but they were perfectly rational and insightful.
Similar to acid this drug offers the whole range of emotions while my mind is in its grasp. Its effects come at me in waves, building to a point that will make me feel lost, then suddenly dropping me, and making me feel normal again. The body load and overall experience was almost overwhelming at the peak which was a little after 7:00. This is ironically the same time my scale arrived. I had a little trouble signing for it, and I knew it did me no good that night, but I was still glad I got it, because I can definitely use it for other things. I had fun playing with it for a little while, and figured out I had done a decent job measuring out my dose. Yes, I could operate, and read the scale.
By 8:00 I feel like Iím starting to come down. The waves are still tossing me about but not as strongly at this point. The visuals are still amazing. This is when I take my muscle relaxant, for back pain due to a car accident, I take a vicadin, and I smoke another bowl. I lay in bed listening to music, and watching the ceiling dance with colors and abstract shapes. I could do without the body load though. Thatís really my only complaint with this drug, it can make me uncomfortable, luckily I was able to handle it by meditating a little, and by 9:00 I was in heaven.
Iím not sure if it was the muscle relaxant, or if itís normal for the come down for this drug, but I remember thinking this was better than the ride up. The body load had turned into a pleasant tingle, and the visuals were absurd. I was also feeling very at peace and honest, and again, very introspective.
About 11:00 I popped another vicadin, and got in bed. One of the last things I remember before falling asleep was watching the sky change color outside my window. I remember realizing this was caused by the shifting patterns of the winamp visual I had running, but it was still amazing, none the less.
All in all this was a gratifying experience, with a very nice come down, and I plan on experimenting with this RC a little more. I was thinking about insufflating 1mg, and seeing what it does. I might also smoke a tiny amount, but I havenít yet decided if I will buy more after this 100mg is gone. Iím leaning towards no because I like to experiment, not get addicted.
In parting, if youíve taken the time to read this, thank you. I always treat 2C-I, and all other psychedelics with respect. This is a powerful chemical. I took a small dose and had a pretty intense trip.  Be smart, and be safe.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


Micro-Library Facades and Dependency Management using RequireJS
2012 March 6th by todd anderson
I recently have been evaluating some JavaScript micro-libraries mainly to see what the community has put out there, read through some code and see what might be appropriate for any upcoming projects, but also to break a dependency on loading libraries that include code that largely goes unused in an application.
As of late, I have been a pretty strong proponent of AMD (with a favor toward RequireJS) largely with the intent of modularized development but also with an ideal of downloading only what is required by the application. Introducing a dependence (and unnecessary download time) on a library that is only fractionally used seems contradictory in the goal of deploying a compact and stream-lined application. That is not to say that such libraries aren’t useful or have a place; and more often than not, such libraries have a great history, a number of brilliant engineers behind it and proven track record with production-level applications. There is definitely a give and take, and options do need to be weighed on a per-application basis, yet I feel there can be a great benefit in using a collection of libraries that each serve a single purpose.
So with that determination, I have been investigating some JavaScript micro-libraries that are out there in the wild – from DOM accessors, to routers, to observers. I haven’t settled on anything to definitively give the OK on using one library over another; just having a bit of fun discovering what the community has to offer – and hopefully one day can contribute and give back to.
The Problem
While test-driving some micro-libraries it quickly became apparent how inefficient my process was. I would start creating a new project to test out a library and copy over numerous files or worse just fill up a directory with files targeting and named after the library I was including. This grew out of control and weakened a proper evaluation of a library with all the clutter; which one was it? where did i use it? why am i so hungry?
Out of a desire to mitigate this confusion, I settled on an approach to provide a consistent API for development of an application through facades that affords the ability to test-drive different micro-libraries with similar responsibilities. The basic premise is to define a common API that I can develop against contextually, and define and swap out abstracted adaptations of different micro-libraries. As such, I can amass a directory of modules that define this API and declare the library I am currently working within a require statement using RequireJS. I believe it is more of a poor-man’s, less-robust and perhaps not production ready approach that Addy Osmani is working on with Aura – a library I am very excited to checkout.
I have some basic examples of the solution I am using at http://github.com/bustardcelly/requirejs-microlib-facade.
Facades
As mentioned previously, the largest part of this solution is to provide a common API to develop against. I want to have my scripts that interact with an API to pass tests regardless of the dependency passed in – with the dependence being the facade module that is adapted to the target micro-library. This area is possibly the crux of the whole argument. Which API do you adapt to? Or rather, which implementation of a micro-library should you favor in exposing an API for multiple micro-libraries? A lot of them have similar methods, but the delegate response signatures can vary. It’s all at the whim of the developer of the micro-library and their vision of the cleanest solution. I don’t have an answer to this, by the way Just bringing it up. I lean towards providing an API that is similar to the most widely-used solution.
Recently I have been evaluating client-side routing libraries that fit perfectly into this modularized facading concept. Particularly, the first library I wanted to test was PathJS which provided support for HTML5 history as well as fall-back to hash tags (plus niceties like parameterized routes, roots, and others). However, as it provided these capabilities, it also provided two different APIs for them. We could go into a discussion of whether this is good practice and whether it should be abstracted away from the front-end developer, but that isn’t my biggest concern at the moment – especially as we can mitigate that concern by abstracting each approach into facades that share a common API. The following are examples of the implementations that adapt to the hash tag implementation and the History implementation respectively:
/script/router/PathHashTagFacade.js
define( ['../../lib/path.min.js'], function() {
return {
map: function( fragment, delegate ) {
Path.map( '#'+fragment ).to( function() {
var paramProperty,
paramArray = [];
for( paramProperty in this.params ) {
paramArray[paramArray.length] = this.params[paramProperty];
}
delegate.apply( this, paramArray )
});
},
root: function( fragment ) {
Path.root( '#'+fragment );
},
init: function( useHistory ) {
Path.listen();
}
};
});
/script/router/PathHistoryFacade.js
define( ['../selector/SimpleSelectorFacade', '../../lib/path.min.js'], function( $ ) {
var links = $('a'),
i = 0, length = links.length;
for( i; i < length; i++ ) {
links[i].onclick = function( event ){
event.preventDefault();
var location = this.attributes['href'].value;
location = location.split( '#' ).join( '' );
Path.history.pushState( {}, '', location );
return false;
};
}
return {
map: function( fragment, delegate ) {
Path.map( fragment ).to( function() {
var paramProperty,
paramArray = [];
for( paramProperty in this.params ) {
paramArray[paramArray.length] = this.params[paramProperty];
}
delegate.apply( this, paramArray )
});
},
root: function( fragment ) {
Path.history.pushState( {}, '', fragment );
},
init: function( useHistory ) {
Path.history.listen( true );
}
};
});
Within the definition of each module, a dependency on the PathJS library is declared and loaded prior to entering the load delegate. PathJS is not provided as an AMD module, so it is accessed using Path globally in both examples. The two differ, however, in their implementation of the their common API: map, root, and init. Let’s set aside the irony of the fact that I am now loading two files (path.js and either facade file) with the end goal being to minimize load times – this will be made clearer in the next example; I just wanted to show the possibility this solution provides in also testing implementation with the same library.
The implementations are very similar in the two examples. The former mostly takes input and prepends values with a hash (#). The latter uses the History API on Path, and intercepts click events on links to properly handle then in the context of Path.history.
Just as a quick example of how I would then employ this:
require( ['script/router/PathHashTagFacade'], handleRouterDependency );
function handleRouteDependency( router ) {
require( ['script/RouterDependentClient'], function( client ) {
client.setRouter( router );
});
};
If HTML5 History API was okay’d for the project and we wanted to utilize the History API on PathJS, then we just change the loaded dependency in the first require() statement.
If we look back at the two facade examples for the Path library, both map implementations change the way in which a mapped delegate is handed state with regards to how Path is designed to forward along parameterized values. Usually the parameter key/value pairs are filled on a params Object which is then inspected within the delegate method for the mapped URL. In those examples, I have changed the invocation on the delegate to actually provide the parameterized values as arguments. The reason is because another library I am evaluating does such, and I much prefer it.
Another popular routing library is Director. We can now provide a facade for that library that adheres to the same API as the other examples and not have to modify any scripts that interact with the routing dependency (aside from the original require() call):
/script/router/DirectorFacade.js
define( ['../../lib/director-1.0.7.min.js'],function() {
var router, root,
routes = {},
adapter = {
map: function( fragment, delegate ) {
routes[fragment] = delegate;
},
root: function( fragment ) {
if( router === undefined ) {
root = fragment;
}
else {
router.setRoute( fragment );
}
},
init: function( useHistory ) {
router = new Router( routes );
router.init();
if( root !== undefined ) {
router.setRoute( root );
}
}
};
return adapter;
});
Now I can swap out the preferred facade at any time during the development cycle of my project and not have to change any application code that depends on the one chosen.
You can checkout the code and an example at https://github.com/bustardcelly/requirejs-microlib-facade.
Evaluation
This isn’t going to be an evaluation of the micro-libraries I am currently testing. Perhaps I will do that in another post, but usually I reserve stating my preference on libraries through annoying tweets. Rather, I wanted to provide my running list of Pro’s and Con’s with regards to this approach of developing an application against a common API that is defined in AMD modules that provide access similarly to underlying micro-libraries that implement the same contextual task differently. I like starting with Con’s.
Cons:
Adapting to each libraries implementation.
- With the glut of micro-libraries out there, it can be a daunting task to simply say that I can fit each one into a similar interface – much less provide the same outgoing signature on any delegate responders.
Facading to a single task.
- There are many libraries that are well-suited for a task, but provide implementations for multiple tasks.
- Typically, I think of a facade as providing one API for multiple composited pieces that may or may not interact with each other. I can get over the nomenclature, but what if a the same library provides a well-suited implementation for multiple tasks and is not provided as an AMD? I have not addressed cutting down multiple requests for the same library that may be used across multiple facade modules.
JavaScript itself.
- In JavaScript we can not define an Object as being an implementation of a specific Interface nor, consequently, run any tools to ensure that it adheres to one. I am sure there are libraries and ‘tools’ out there that can provide a way that makes it appear that an Object needs to or is adhering to an Interface, I am speaking more out-of-the-box: JavaScript doesn’t have interfaces. Not arguing whether that is right or wrong.
- The main advantage of this approach to facade modules is to develop against a consistent API. As such, it is far too easy – because of the dynamicism of JavaScript – to lose that across multiple modules, even just in simple spelling mistakes. This calls for more unit testing, which you should be doing anyway (yes, I am glaring at myself right now).
Pros:
- Developing an application against a dependency whose API will not change based on the required underlying micro-library.
- Ability to inject, at runtime, a different dependency if required (say, for instance, after having checked browser capabilities).
- The use of high-falootin’ buzzwords when describing your approach to colleagues.
Does one outweigh the other? In as far as development, I am leaning toward the Pro’s, but I do worry that some the Con’s may deter me from really evaluating a library that may be best-suited, simply because it is too difficult at the time to fit into the defined API.
Conclusion
Will I recommend this approach for production-level application deployment?
That is yet to be determined. I still subscribe to the practice that you should compile in (concatenate and minify) all the sources required by an application. So, having the ability to switch the target facade at runtime or on the server by just modifying a line in some script file doesn’t seem to be the right approach in delivering a web-based application at the moment for me. I would evaluate a handful of libraries, determine the best suited one for the application and include that one (along with the accompanying facade) in my r.js build. But I reserve the right to be proven wrong and/or change my mind
Posted in AMD, JavaScript, RequireJS, micro-library.


CodeFlower Source code visualization
This codeflower visualizes the Zooniverse GitHub source repositories using an interactive tree. Each disc represents a file, with a radius proportional to the number of lines of code (loc). All rendering is done client-side, in JavaScript. Try hovering on nodes to see the loc number, clicking on directory nodes to fold them, dragging nodes to rearrange the layout, and changing project to see different tree structures. Built with d3.js. Inspired by Code Swarm and Gource.
Making your own CodeFlower
The best way to make your own CodeFlowers is to use GitHub Pages, just like this very page. So just fork the fzaninotto/CodeFlower
repository, add your own JSON data under the data
directory, update the options of the dropdown list in the index.html
file accordingly, commit the code, and push to the gh-pages
branch. GitHub will publish the result for you.


NimBLE Host GATT Client Reference¶
Introduction¶
The Generic Attribute Profile (GATT) manages all activities involving services, characteristics, and descriptors. The client half of the GATT API initiates GATT procedures.
API¶
-
typedef int
ble_gatt_mtu_fn
(uint16_t conn_handle, const struct ble_gatt_error *error, uint16_t mtu, void *arg)¶
-
typedef int
ble_gatt_disc_svc_fn
(uint16_t conn_handle, const struct ble_gatt_error *error, const struct ble_gatt_svc *service, void *arg)¶
-
typedef int
ble_gatt_attr_fn
(uint16_t conn_handle, const struct ble_gatt_error *error, struct ble_gatt_attr *attr, void *arg)¶ The host will free the attribute mbuf automatically after the callback is executed.
The application can take ownership of the mbuf and prevent it from being freed by assigning NULL to attr->om.
-
typedef int
ble_gatt_reliable_attr_fn
(uint16_t conn_handle, const struct ble_gatt_error *error, struct ble_gatt_attr *attrs, uint8_t num_attrs, void *arg)¶ The host will free the attribute mbufs automatically after the callback is executed.
The application can take ownership of the mbufs and prevent them from being freed by assigning NULL to each attribute’s om field.
-
typedef int
ble_gatt_chr_fn
(uint16_t conn_handle, const struct ble_gatt_error *error, const struct ble_gatt_chr *chr, void *arg)¶
-
typedef int
ble_gatt_dsc_fn
(uint16_t conn_handle, const struct ble_gatt_error *error, uint16_t chr_val_handle, const struct ble_gatt_dsc *dsc, void *arg)¶
-
typedef int
ble_gatt_access_fn
(uint16_t conn_handle, uint16_t attr_handle, struct ble_gatt_access_ctxt *ctxt, void *arg)¶
-
typedef uint16_t
ble_gatt_chr_flags
¶
-
typedef void
ble_gatt_register_fn
(struct ble_gatt_register_ctxt *ctxt, void *arg)¶
-
typedef void
(* ble_gatt_svc_foreach_fn)
(const struct ble_gatt_svc_def *svc, uint16_t handle, uint16_t end_group_handle, void *arg)¶
-
int
ble_gattc_exchange_mtu
(uint16_t conn_handle, ble_gatt_mtu_fn * cb, void * cb_arg)¶ Initiates GATT procedure: Exchange MTU.
- Return
- 0 on success; nonzero on failure.
- Parameters
conn_handle
: The connection over which to execute the procedure.cb
: The function to call to report procedure status updates; null for no callback.cb_arg
: The optional argument to pass to the callback function.
-
int
ble_gattc_disc_all_svcs
(uint16_t conn_handle, ble_gatt_disc_svc_fn * cb, void * cb_arg)¶ Initiates GATT procedure: Discover All Primary Services.
- Parameters
conn_handle
: The connection over which to execute the procedure.cb
: The function to call to report procedure status updates; null for no callback.cb_arg
: The optional argument to pass to the callback function.
-
int
ble_gattc_disc_svc_by_uuid
(uint16_t conn_handle, const ble_uuid_t * uuid, ble_gatt_disc_svc_fn * cb, void * cb_arg)¶ Initiates GATT procedure: Discover Primary Service by Service UUID.
- Return
- 0 on success; nonzero on failure.
- Parameters
conn_handle
: The connection over which to execute the procedure.service_uuid128
: The 128-bit UUID of the service to discover.cb
: The function to call to report procedure status updates; null for no callback.cb_arg
: The optional argument to pass to the callback function.
-
int
ble_gattc_find_inc_svcs
(uint16_t conn_handle, uint16_t start_handle, uint16_t end_handle, ble_gatt_disc_svc_fn * cb, void * cb_arg)¶ Initiates GATT procedure: Find Included Services.
- Return
- 0 on success; nonzero on failure.
- Parameters
conn_handle
: The connection over which to execute the procedure.start_handle
: The handle to begin the search at (generally the service definition handle).end_handle
: The handle to end the search at (generally the last handle in the service).cb
: The function to call to report procedure status updates; null for no callback.cb_arg
: The optional argument to pass to the callback function.
-
int
ble_gattc_disc_all_chrs
(uint16_t conn_handle, uint16_t start_handle, uint16_t end_handle, ble_gatt_chr_fn * cb, void * cb_arg)¶ Initiates GATT procedure: Discover All Characteristics of a Service.
- Return
- 0 on success; nonzero on failure.
- Parameters
conn_handle
: The connection over which to execute the procedure.start_handle
: The handle to begin the search at (generally the service definition handle).end_handle
: The handle to end the search at (generally the last handle in the service).cb
: The function to call to report procedure status updates; null for no callback.cb_arg
: The optional argument to pass to the callback function.
-
int
ble_gattc_disc_chrs_by_uuid
(uint16_t conn_handle, uint16_t start_handle, uint16_t end_handle, const ble_uuid_t * uuid, ble_gatt_chr_fn * cb, void * cb_arg)¶ Initiates GATT procedure: Discover Characteristics by UUID.
- Return
- 0 on success; nonzero on failure.
- Parameters
conn_handle
: The connection over which to execute the procedure.start_handle
: The handle to begin the search at (generally the service definition handle).end_handle
: The handle to end the search at (generally the last handle in the service).chr_uuid128
: The 128-bit UUID of the characteristic to discover.cb
: The function to call to report procedure status updates; null for no callback.cb_arg
: The optional argument to pass to the callback function.
-
int
ble_gattc_disc_all_dscs
(uint16_t conn_handle, uint16_t start_handle, uint16_t end_handle, ble_gatt_dsc_fn * cb, void * cb_arg)¶ Initiates GATT procedure: Discover All Characteristic Descriptors.
- Return
- 0 on success; nonzero on failure.
- Parameters
conn_handle
: The connection over which to execute the procedure.chr_val_handle
: The handle of the characteristic value attribute.chr_end_handle
: The last handle in the characteristic definition.cb
: The function to call to report procedure status updates; null for no callback.cb_arg
: The optional argument to pass to the callback function.
-
int
ble_gattc_read
(uint16_t conn_handle, uint16_t attr_handle, ble_gatt_attr_fn * cb, void * cb_arg)¶ Initiates GATT procedure: Read Characteristic Value.
- Return
- 0 on success; nonzero on failure.
- Parameters
conn_handle
: The connection over which to execute the procedure.attr_handle
: The handle of the characteristic value to read.cb
: The function to call to report procedure status updates; null for no callback.cb_arg
: The optional argument to pass to the callback function.
-
int
ble_gattc_read_by_uuid
(uint16_t conn_handle, uint16_t start_handle, uint16_t end_handle, const ble_uuid_t * uuid, ble_gatt_attr_fn * cb, void * cb_arg)¶ Initiates GATT procedure: Read Using Characteristic UUID.
- Return
- 0 on success; nonzero on failure.
- Parameters
conn_handle
: The connection over which to execute the procedure.start_handle
: The first handle to search (generally the handle of the service definition).end_handle
: The last handle to search (generally the last handle in the service definition).cb
: The function to call to report procedure status updates; null for no callback.cb_arg
: The optional argument to pass to the callback function.
-
int
ble_gattc_read_long
(uint16_t conn_handle, uint16_t handle, uint16_t offset, ble_gatt_attr_fn * cb, void * cb_arg)¶ Initiates GATT procedure: Read Long Characteristic Values.
- Return
- 0 on success; nonzero on failure.
- Parameters
conn_handle
: The connection over which to execute the procedure.handle
: The handle of the characteristic value to read.cb
: The function to call to report procedure status updates; null for no callback.cb_arg
: The optional argument to pass to the callback function.
-
int
ble_gattc_read_mult
(uint16_t conn_handle, const uint16_t * handles, uint8_t num_handles, ble_gatt_attr_fn * cb, void * cb_arg)¶ Initiates GATT procedure: Read Multiple Characteristic Values.
- Return
- 0 on success; nonzero on failure.
- Parameters
conn_handle
: The connection over which to execute the procedure.handles
: An array of 16-bit attribute handles to read.num_handles
: The number of entries in the “handles” array.cb
: The function to call to report procedure status updates; null for no callback.cb_arg
: The optional argument to pass to the callback function.
-
int
ble_gattc_write_no_rsp
(uint16_t conn_handle, uint16_t attr_handle, struct os_mbuf * om)¶ Initiates GATT procedure: Write Without Response.
This function consumes the supplied mbuf regardless of the outcome.
- Return
- 0 on success; nonzero on failure.
- Parameters
conn_handle
: The connection over which to execute the procedure.attr_handle
: The handle of the characteristic value to write to.txom
: The value to write to the characteristic.
-
int
ble_gattc_write_no_rsp_flat
(uint16_t conn_handle, uint16_t attr_handle, const void * data, uint16_t data_len)¶ Initiates GATT procedure: Write Without Response.
This function consumes the supplied mbuf regardless of the outcome.
- Return
- 0 on success; nonzero on failure.
- Parameters
conn_handle
: The connection over which to execute the procedure.attr_handle
: The handle of the characteristic value to write to.value
: The value to write to the characteristic.value_len
: The number of bytes to write.
-
int
ble_gattc_write
(uint16_t conn_handle, uint16_t attr_handle, struct os_mbuf * om, ble_gatt_attr_fn * cb, void * cb_arg)¶ Initiates GATT procedure: Write Characteristic Value.
This function consumes the supplied mbuf regardless of the outcome.
- Return
- 0 on success; nonzero on failure.
- Parameters
conn_handle
: The connection over which to execute the procedure.attr_handle
: The handle of the characteristic value to write to.txom
: The value to write to the characteristic.cb
: The function to call to report procedure status updates; null for no callback.cb_arg
: The optional argument to pass to the callback function.
-
int
ble_gattc_write_flat
(uint16_t conn_handle, uint16_t attr_handle, const void * data, uint16_t data_len, ble_gatt_attr_fn * cb, void * cb_arg)¶ Initiates GATT procedure: Write Characteristic Value (flat buffer version).
- Return
- 0 on success; nonzero on failure.
- Parameters
conn_handle
: The connection over which to execute the procedure.attr_handle
: The handle of the characteristic value to write to.value
: The value to write to the characteristic.value_len
: The number of bytes to write.cb
: The function to call to report procedure status updates; null for no callback.cb_arg
: The optional argument to pass to the callback function.
-
int
ble_gattc_write_long
(uint16_t conn_handle, uint16_t attr_handle, uint16_t offset, struct os_mbuf * om, ble_gatt_attr_fn * cb, void * cb_arg)¶ Initiates GATT procedure: Write Long Characteristic Values.
This function consumes the supplied mbuf regardless of the outcome.
- Return
- 0 on success; nonzero on failure.
- Parameters
conn_handle
: The connection over which to execute the procedure.attr_handle
: The handle of the characteristic value to write to.txom
: The value to write to the characteristic.cb
: The function to call to report procedure status updates; null for no callback.cb_arg
: The optional argument to pass to the callback function.
-
int
ble_gattc_write_reliable
(uint16_t conn_handle, struct ble_gatt_attr * attrs, int num_attrs, ble_gatt_reliable_attr_fn * cb, void * cb_arg)¶ Initiates GATT procedure: Reliable Writes.
This function consumes the supplied mbufs regardless of the outcome.
- Parameters
conn_handle
: The connection over which to execute the procedure.attrs
: An array of attribute descriptors; specifies which characteristics to write to and what data to write to them. The mbuf pointer in each attribute is set to NULL by this function.num_attrs
: The number of characteristics to write; equal to the number of elements in the ‘attrs’ array.cb
: The function to call to report procedure status updates; null for no callback.cb_arg
: The optional argument to pass to the callback function.
-
int
ble_gattc_notify_custom
(uint16_t conn_handle, uint16_t att_handle, struct os_mbuf * om)¶ Sends a “free-form” characteristic notification.
This function consumes the supplied mbuf regardless of the outcome.
- Return
- 0 on success; nonzero on failure.
- Parameters
conn_handle
: The connection over which to execute the procedure.chr_val_handle
: The attribute handle to indicate in the outgoing notification.txom
: The value to write to the characteristic.
-
int
ble_gattc_notify
(uint16_t conn_handle, uint16_t chr_val_handle)¶ Sends a characteristic notification.
The content of the message is read from the specified characteristic.
- Return
- 0 on success; nonzero on failure.
- Parameters
conn_handle
: The connection over which to execute the procedure.chr_val_handle
: The value attribute handle of the characteristic to include in the outgoing notification.
-
int
ble_gattc_indicate_custom
(uint16_t conn_handle, uint16_t chr_val_handle, struct os_mbuf * txom)¶ Sends a “free-form” characteristic indication.
The provided mbuf contains the indication payload. This function consumes the supplied mbuf regardless of the outcome.
- Return
- 0 on success; nonzero on failure.
- Parameters
conn_handle
: The connection over which to execute the procedure.chr_val_handle
: The value attribute handle of the characteristic to include in the outgoing indication.txom
: The data to include in the indication.
-
int
ble_gattc_indicate
(uint16_t conn_handle, uint16_t chr_val_handle)¶ Sends a characteristic indication.
The content of the message is read from the specified characteristic.
- Return
- 0 on success; nonzero on failure.
- Parameters
conn_handle
: The connection over which to execute the procedure.chr_val_handle
: The value attribute handle of the characteristic to include in the outgoing indication.
-
int
ble_gattc_init
(void)¶
-
int
ble_gatts_add_svcs
(const struct ble_gatt_svc_def * svcs)¶ Queues a set of service definitions for registration.
All services queued in this manner get registered when ble_gatts_start() is called.
- Return
- 0 on success; BLE_HS_ENOMEM on heap exhaustion.
- Parameters
svcs
: An array of service definitions to queue for registration. This array must be terminated with an entry whose ‘type’ equals 0.
-
int
ble_gatts_svc_set_visibility
(uint16_t handle, int visible)¶ Set visibility of local GATT service.
Invisible services are not removed from database but are not discoverable by peer devices. Service Changed should be handled by application when needed by calling ble_svc_gatt_changed().
- Return
- 0 on success; BLE_HS_ENOENT if service wasn’t found.
- Parameters
handle
: Handle of servicevisible
: non-zero if service should be visible
-
int
ble_gatts_count_cfg
(const struct ble_gatt_svc_def * defs)¶ Adjusts a host configuration object’s settings to accommodate the specified service definition array.
This function adds the counts to the appropriate fields in the supplied configuration object without clearing them first, so it can be called repeatedly with different inputs to calculate totals. Be sure to zero the GATT server settings prior to the first call to this function.
- Return
- 0 on success; BLE_HS_EINVAL if the svcs array contains an invalid resource definition.
- Parameters
defs
: The service array containing the resource definitions to be counted.
-
void
ble_gatts_chr_updated
(uint16_t chr_val_handle)¶ Send notification (or indication) to any connected devices that have subscribed for notification (or indication) for specified characteristic.
- Parameters
chr_val_handle
: Characteristic value handle
-
int
ble_gatts_find_svc
(const ble_uuid_t * uuid, uint16_t * out_handle)¶ Retrieves the attribute handle associated with a local GATT service.
- Return
- 0 on success; BLE_HS_ENOENT if the specified service could not be found.
- Parameters
uuid
: The UUID of the service to look up.out_handle
: On success, populated with the handle of the service attribute. Pass null if you don’t need this value.
-
int
ble_gatts_find_chr
(const ble_uuid_t * svc_uuid, const ble_uuid_t * chr_uuid, uint16_t * out_def_handle, uint16_t * out_val_handle)¶ Retrieves the pair of attribute handles associated with a local GATT characteristic.
- Return
- 0 on success; BLE_HS_ENOENT if the specified service or characteristic could not be found.
- Parameters
svc_uuid
: The UUID of the parent service.chr_uuid
: The UUID of the characteristic to look up.out_def_handle
: On success, populated with the handle of the characteristic definition attribute. Pass null if you don’t need this value.out_val_handle
: On success, populated with the handle of the characteristic value attribute. Pass null if you don’t need this value.
-
int
ble_gatts_find_dsc
(const ble_uuid_t * svc_uuid, const ble_uuid_t * chr_uuid, const ble_uuid_t * dsc_uuid, uint16_t * out_dsc_handle)¶ Retrieves the attribute handle associated with a local GATT descriptor.
- Return
- 0 on success; BLE_HS_ENOENT if the specified service, characteristic, or descriptor could not be found.
- Parameters
svc_uuid
: The UUID of the grandparent service.chr_uuid
: The UUID of the parent characteristic.dsc_uuid
: The UUID of the descriptor ro look up.out_handle
: On success, populated with the handle of the descriptor attribute. Pass null if you don’t need this value.
-
void
ble_gatts_show_local
(void)¶ Prints dump of local GATT database.
This is useful to log local state of database in human readable form.
-
int
ble_gatts_reset
(void)¶ Resets the GATT server to its initial state.
On success, this function removes all supported services, characteristics, and descriptors. This function requires that: o No peers are connected, and o No GAP operations are active (advertise, discover, or connect).
- Return
- 0 on success; BLE_HS_EBUSY if the GATT server could not be reset due to existing connections or active GAP procedures.
-
int
ble_gatts_start
(void)¶ Makes all registered services available to peers.
This function gets called automatically by the NimBLE host on startup; manual calls are only necessary for replacing the set of supported services with a new one. This function requires that: o No peers are connected, and o No GAP operations are active (advertise, discover, or connect).
- Return
- 0 on success; A BLE host core return code on unexpected error.
-
BLE_GATT_REGISTER_OP_SVC
¶
-
BLE_GATT_REGISTER_OP_CHR
¶
-
BLE_GATT_REGISTER_OP_DSC
¶
-
BLE_GATT_SVC_UUID16
¶
-
BLE_GATT_DSC_CLT_CFG_UUID16
¶
-
BLE_GATT_CHR_PROP_BROADCAST
¶
-
BLE_GATT_CHR_PROP_READ
¶
-
BLE_GATT_CHR_PROP_WRITE_NO_RSP
¶
-
BLE_GATT_CHR_PROP_WRITE
¶
-
BLE_GATT_CHR_PROP_NOTIFY
¶
-
BLE_GATT_CHR_PROP_INDICATE
¶
-
BLE_GATT_CHR_PROP_AUTH_SIGN_WRITE
¶
-
BLE_GATT_CHR_PROP_EXTENDED
¶
-
BLE_GATT_ACCESS_OP_READ_CHR
¶
-
BLE_GATT_ACCESS_OP_WRITE_CHR
¶
-
BLE_GATT_ACCESS_OP_READ_DSC
¶
-
BLE_GATT_ACCESS_OP_WRITE_DSC
¶
-
BLE_GATT_CHR_F_BROADCAST
¶
-
BLE_GATT_CHR_F_READ
¶
-
BLE_GATT_CHR_F_WRITE_NO_RSP
¶
-
BLE_GATT_CHR_F_WRITE
¶
-
BLE_GATT_CHR_F_NOTIFY
¶
-
BLE_GATT_CHR_F_INDICATE
¶
-
BLE_GATT_CHR_F_AUTH_SIGN_WRITE
¶
-
BLE_GATT_CHR_F_RELIABLE_WRITE
¶
-
BLE_GATT_CHR_F_AUX_WRITE
¶
-
BLE_GATT_CHR_F_READ_ENC
¶
-
BLE_GATT_CHR_F_READ_AUTHEN
¶
-
BLE_GATT_CHR_F_READ_AUTHOR
¶
-
BLE_GATT_CHR_F_WRITE_ENC
¶
-
BLE_GATT_CHR_F_WRITE_AUTHEN
¶
-
BLE_GATT_CHR_F_WRITE_AUTHOR
¶
-
BLE_GATT_SVC_TYPE_END
¶
-
BLE_GATT_SVC_TYPE_PRIMARY
¶
-
BLE_GATT_SVC_TYPE_SECONDARY
¶
-
struct
ble_gatt_chr_def
¶ - #include <ble_gatt.h>
Public Members
-
const ble_uuid_t*
uuid
¶ Pointer to characteristic UUID; use BLE_UUIDxx_DECLARE macros to declare proper UUID; NULL if there are no more characteristics in the service.
-
ble_gatt_access_fn*
access_cb
¶ Callback that gets executed when this characteristic is read or written.
-
void*
arg
¶ Optional argument for callback.
-
struct ble_gatt_dsc_def*
descriptors
¶ Array of this characteristic’s descriptors.
NULL if no descriptors. Do not include CCCD; it gets added automatically if this characteristic’s notify or indicate flag is set.
-
ble_gatt_chr_flags
flags
¶ Specifies the set of permitted operations for this characteristic.
-
uint8_t
min_key_size
¶ Specifies minimum required key size to access this characteristic.
-
uint16_t*
val_handle
¶ At registration time, this is filled in with the characteristic’s value attribute handle.
-
const ble_uuid_t*
-
struct
ble_gatt_svc_def
¶ - #include <ble_gatt.h>
Public Members
-
uint8_t
type
¶ One of the following: o BLE_GATT_SVC_TYPE_PRIMARY - primary service o BLE_GATT_SVC_TYPE_SECONDARY - secondary service o 0 - No more services in this array.
-
const ble_uuid_t*
uuid
¶ Pointer to service UUID; use BLE_UUIDxx_DECLARE macros to declare proper UUID; NULL if there are no more characteristics in the service.
-
const struct ble_gatt_svc_def**
includes
¶ Array of pointers to other service definitions.
These services are reported as “included services” during service discovery. Terminate the array with NULL.
-
const struct ble_gatt_chr_def*
characteristics
¶ Array of characteristic definitions corresponding to characteristics belonging to this service.
-
uint8_t
-
struct
ble_gatt_dsc_def
¶ - #include <ble_gatt.h>
Public Members
-
const ble_uuid_t*
uuid
¶ Pointer to descriptor UUID; use BLE_UUIDxx_DECLARE macros to declare proper UUID; NULL if there are no more characteristics in the service.
-
uint8_t
att_flags
¶ Specifies the set of permitted operations for this descriptor.
-
uint8_t
min_key_size
¶ Specifies minimum required key size to access this descriptor.
-
ble_gatt_access_fn*
access_cb
¶ Callback that gets executed when the descriptor is read or written.
-
void*
arg
¶ Optional argument for callback.
-
const ble_uuid_t*
-
struct
ble_gatt_access_ctxt
¶ - #include <ble_gatt.h>
Context for an access to a GATT characteristic or descriptor.
When a client reads or writes a locally registered characteristic or descriptor, an instance of this struct gets passed to the application callback.
Public Members
-
uint8_t
op
¶ Indicates the gatt operation being performed.
This is equal to one of the following values: o BLE_GATT_ACCESS_OP_READ_CHR o BLE_GATT_ACCESS_OP_WRITE_CHR o BLE_GATT_ACCESS_OP_READ_DSC o BLE_GATT_ACCESS_OP_WRITE_DSC
-
struct os_mbuf*
om
¶ A container for the GATT access data.
o For reads: The application populates this with the value of the characteristic or descriptor being read. o For writes: This is already populated with the value being written by the peer. If the application wishes to retain this mbuf for later use, the access callback must set this pointer to NULL to prevent the stack from freeing it.
-
union ble_gatt_access_ctxt::@45 ble_gatt_access_ctxt::@
46
¶ The GATT operation being performed dictates which field in this union is valid.
If a characteristic is being accessed, the chr field is valid. Otherwise a descriptor is being accessed, in which case the dsc field is valid.
-
uint8_t
-
struct
ble_gatt_register_ctxt
¶ - #include <ble_gatt.h>
Context passed to the registration callback; represents the GATT service, characteristic, or descriptor being registered.
Public Members
-
uint8_t
op
¶ Indicates the gatt registration operation just performed.
This is equal to one of the following values: o BLE_GATT_REGISTER_OP_SVC o BLE_GATT_REGISTER_OP_CHR o BLE_GATT_REGISTER_OP_DSC
-
union ble_gatt_register_ctxt::@47 ble_gatt_register_ctxt::@
48
¶ The value of the op field determines which field in this union is valid.
-
uint8_t


@*
* Copyright 2021 HM Revenue & Customs
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*@
@import config.AppConfig
@import views.html.helper._
@import uk.gov.hmrc.play.views.html.helpers.{form, input}
@(searchForm: Form[SearchQuery], results: Seq[SearchResult])(implicit request: Request[_], messages: Messages, appConfig: AppConfig)
@notableEvent = @{
appConfig.notableEvents(searchForm.get.notableEventType)
}


This is an open-source client for Fast Interoperability Healthcare Resources (FHIR) ® services. It is based on the current DSTU2 ballot draft, and while the client can target any DSTU2-compliant FHIR server, the particular focus is for testing interoperability of servers implementing the FHIR DAF Profiles.
To get started, choose a FHIR server. One of the design goals of this application is to provide a common interface for trying out different servers. With the rapid pace of evolution of both the FHIR specification and its related implementations, there's a chance certain functionality may not be available in a given implementation.
This application uses expandable value sets provided by a FHIR-based terminology service. Most FHIR servers don't currently provide terminology services. Choose from a list of publicly available terminology services to support data entry and concept detail lookup.
You will need to log in to get beyond this home page. If a server implements SMART on FHIR security, you will authenticate against their associated OpenID identity provider. Otherwise, you'll authenticate using your Google or LinkedIn account.
Use the left menu to explore the specification and try out different work flows. The visibility icon provides an under-the-covers look at the the JSON data returned in a particular interaction. And, of course, you can always use the developer tools of your browser-of-choice for an even deeper look at the interactions between this client and a particular FHIR server.
Report issues or any other feedback on the github repository site for this project.


Page One
28 May 2014
Hello world!
This is my first blog on GitHub! \( f(x_i, W) = W x_i \)
Concretely, recall that the linear function had the form \( f(x_i,W) = W x_{ {i_1} ^2} \) and the SVM we developed was formulated as:
Hello world!
This is my first blog on GitHub! \( f(x_i, W) = W x_i \)
Concretely, recall that the linear function had the form \( f(x_i,W) = W x_{ {i_1} ^2} \) and the SVM we developed was formulated as:


This document is the API specification for the Tablesaw for DJL.
The tablesaw module contains classes for DJL to support tabular datasets in Tablesaw format.


[CHAPTER 420D]
SUSTAINABLE BUSINESS CORPORATIONS
Section
420D-1 Purpose and findings
420D-2 Definitions
420D-3 Election of a domestic corporation to become a
sustainable business corporation
420D-4 Termination of sustainable business corporation status
420D-5 Corporate purposes
420D-6 Standard of conduct for directors
420D-7 Benefit director
420D-8 Standard of conduct for officers
420D-9 Benefit officer
420D-10 Right of action
420D-11 Annual benefit report
420D-12 Third-party standard
420D-13 Ministerial role of department director
Law Journals and Reviews
The "Aloha Corporation:" Infusing the Culture of Hawaii to Broaden the Perspective of Business and Return to Community. 34 UH L. Rev. 221 (2012).


| Design and Implementation of a validating XML parser in Haskell: Master's thesis; University of Applied Sciences Wedel | ||
|---|---|---|
| Prev | Appendix A. User handbook | Next |
The Haskell XML Toolbox comes with a command line tool for checking if XML documents are well-formed and valid. To build this tool with GHC, run make HXmlParser in the root directory of the Haskell XML Toolbox. This will produce the binary file HXmlParser that will be stored in the root directory. The sources of this tool are located in the directory examples.
When checking an invalid XML file, HXmlParser will report errors to stderr and quit with an exit code of "-1". If there are no errors in the document, the tool will just quit without any message.
If you run HXmlParser without any arguments, the usage information is displayed:
Usage: --source "filename" - source file (required) --encoding "charset" - document encoding --trace "level" - trace level (0-4) -h - this help -v - display a message if document is well-formed or valid -w - well-formed check only -op - output parsed document -opt - output XmlTree of parsed document -oph - output Haskell type of parsed document Only for validity checks: -ot - output transformed document -ott - output XmlTree of transformed document -oth - output Haskell type of transformed document -oc - output canonicalized document -oct - output XmlTree of canonicalized document -och - output Haskell type of canonicalized document |


Sed adipiscing varius accumsan. Fusce placerat neque sed sapien rutrum laoreet justo ultrices. In pellentesque lorem condimentum dui consequat adipiscing nisi tincidunt. Morbi pulvinar dui non quam pretium ut lacinia tortor.
Error! Please fill in all the fields required.
Success! You did it, now relax and enjoy it.
Warning! Change this and that and try again.
Notice! Please edit the information below.
Mauris aliquet ultricies ante, non faucibus ante gravida sed. Sed ultrices pellentesque purus, vulputate volutpat ipsum hendrerit sed.
Clean, professional bespoke website produced for clients all over the world.
Website development with the latest technologies and trends.
Dedicated site built specifically for Mobile to increase functionality.
Increase your visibility within search engines such as Google and be the first.
Need help with words? Our public relations guru can guide you through content.
Our public relations guru can update your Twitter / Facebook on a regular basis.
This is a example of style component for calling extra attention to featured content or information. Adipiscing elit. Cras eu nisl quam. Cras in elit a massa fermentum bibendum.
Read More| Header 1 | Header 2 | Header 3 | Header 4 |
|---|---|---|---|
| Item #1 | Description | 100 GB | 100 GB |
| Item #2 | Description | 200 GB | 200 GB |
| Item #3 | Description | 300 GB | 300 GB |
| Item #4 | Description | 400 GB | 400 GB |
| Item #5 | Description | 500 GB | 500 GB |


-*- html -*-
@title dnssd_erlang
@copyright 2011 Andrew Tunnell-Jones
@author Andrew Tunnell-Jones [http://andrew.tj.id.au/]
@doc
dnssd_erlang provides an interface to Apple's DNS Service Discovery API. DNS
Service Discovery enables applications to advertise and discover services both
peer to peer on the local network using multicast DNS and over the internet
using traditional unicast DNS and if needed NAT-PMP or uPNP for port forwarding.
Bonjour and the DNSSD API are bundled with OS X. On Windows Bonjour is bundled
with some Apple applications and is also available standalone in the form of
Bonjour Print Services for Windows
. The DNSSD API is made available via
Bonjour SDK for Windows (free registration requred).
On other UNIX like platforms the DNSSD API can be made available via either
Apple
mDNSResponder or Avahi with it's optional
Bonjour compatibilty layer. The former tends to be more commonly used on BSD
and embedded platforms while the later is a mainstay of most Linux desktop
operating systems. They are mostly functionally equivalent except in the area of
wide-area service discovery where Avahi does not support registering in
wide-area domains or DNS-LLQ for real-time updates.
Note: Problems will ensue should multiple daemons be run on one machine.
For further information on the DNS Service Discovery API or Bonjour itself, see
[http://developer.apple.com/networking/bonjour].


|
DRDSP
Dimensionality Reduction for Dynamical Systems with Parameters
|
Public Member Functions | |
| Degrees (T rhs) | |
| Degrees (const Radians< T > &rhs) | |
| Degrees< T > & | operator= (const Radians< T > &rhs) |
| Degrees< T > | operator+ (const Degrees< T > &rhs) const |
| Degrees< T > | operator- (const Degrees< T > &rhs) const |
| Degrees< T > | operator* (T x) const |
| Degrees< T > | operator/ (T x) const |
| Degrees< T > & | operator+= (const Degrees< T > &rhs) |
| Degrees< T > & | operator-= (const Degrees< T > &rhs) |
| Degrees< T > & | operator*= (T x) |
| Degrees< T > & | operator/= (T x) |
| Degrees< T > | operator- () const |
| bool | operator> (const Degrees< T > &rhs) const |
| bool | operator< (const Degrees< T > &rhs) const |
| bool | operator>= (const Degrees< T > &rhs) const |
| bool | operator<= (const Degrees< T > &rhs) const |
| operator T () const | |
Public Attributes | |
| T | value |


One of the biggest problems developers have to handle nowadays is on how to cope with the enormous size and complexity of an increasing number of current projects. These projects involve several people, possibly, in different teams and locations, developing an heterogeneous software where the different parts have to interact consistently, thus requiring a perfect agreement between teams. The problem gets worst when considering that the product will have to be maintained afterwards or even extended.
It is common knowledge that from a certain point it is impossible to have the application as a monolithic block. It is necessary to divide the project in different parts, as independent as possible, so that joining the work of two teams is as easy and consistent as possible. Dividing the project is also necessary to limit the scope of the problem being handled, enabling easier and clearer development and maintenance. For example, consider a product that captures, evaluates and stores some type of data. Now, consider that the way the data is stored is changed or there is a bug somewhere. Having clear distinctions between the different functionalities clearly makes this task easier and protects the rest of the product. But having a project divided in different parts brings the problem of architecting the parts, i.e., joining the different parts together. Teams are only familiar with their parts and communication between teams tends to be short. Also, it is very common to have the project spread in different platforms and locations.
On the other hand, it is also usually said that, if a certain functionality is needed and it is already available somewhere, one should reuse this implementation and not "reinvent the wheel". This should account also for using/developing products aside especially for a certain task instead of integrating that functionality in the main application. Besides the reusability of code, it also gives more flexibility (it is easier to add functionality this way than rebuilding the all application) and a simpler and clearer main application (instead of having a confusing, heterogeneous and heavy one). But this requires some conditions from both parts that should be considered before the development of either one. For instance, consider the last example. Imagine that in the evaluation stage, some graphics need to be generated. There are a big number of applications that draw graphics and are probably preferred than to add "from scratch" graphics functionality to the application. But the main problem is whether the graphic program is easily integrated which, most of the times, is not the case.
Continuing on the subject of adding/changing functionality and considering the same example, imagine that the data it handles is very heterogeneous and, thus, the way this data is evaluated, for example, is different according to the type of data. When the set of the types handled is small and doesn't change and the way they are handled is also static, the final product is a bit complex but handleable. But when this is not the case we come upon several problems:
Flexibility and consistency. How to add/change/remove functionality in a flexible manner without compromising the consistency of the application and, preferably, not having to rebuild all the application?
Efficiency. How to do this in a way that doesn't compromise to much the efficiency, e.g., there isn't a waste of resources since most will only be used for a certain period or not even used at all in a session?
Recently, two paradigms have evolved that are especially aimed at this type of problems: Plugins[1] and Components. But, in order to understand why the need for this technology arose, we can compile, from the above problems, a list of objectives we would like to fulfil. It is easy to see, looking at the nature of the problems and the following list, why these new paradigms have become so popular.
Modularity is one of the keywords. How to divide an utility in different parts that obey the rules of modularity (independence, encapsulation) and interact with each other in a desired way. A special case would be to divide an utility in its main part (management) and its several branches, thus, separating functionality.
In other words, to be able to add/change/remove functionality of an utility without touching the main part. As an add-on, to be able to do that on runtime. This implies that the application shouldn't be rebuild and, further more, compiled, each time these changes take place.
The development of each part of a project should be independent from the other ones. This obliges the communication between parts to be transparent and standard. Also, each part should be able to cope with the others being in different platforms and locations. Basically, each part shouldn't have to worry about how others are implemented and located.
This means being able to embed an application A that provides a desired functionality inside an application B thus reusing code and providing a lighter and simpler application B.
These are, of course, very different objectives which rarely are assembled together. This is not intended to find a unique solution that covers all of them. |
Using plugins and components enables us to fulfil this objectives in a clever and transparent way (when used correctly). How this is done is the subject of the next chapters. But first it is necessary to have a look at shared libraries.
| [1] | It is also very usual to write Plug-in instead of Plugin. |


This is an example of the Single Page App built with AngularJS.
{{article.content}}
{{comment.content}}
Write a comment


Description: Remove the set of matched elements from the DOM.
selector: String A selector expression that filters the set of matched elements to be removed.
Similar to .empty()
, the .remove()
method takes elements out of the DOM. Use .remove()
when you want to remove the element itself, as well as everything inside it. In addition to the elements themselves, all bound events and jQuery data associated with the elements are removed. To remove the elements without removing data and events, use .detach()
instead.
Consider the following HTML:

Hello

Goodbye

We can target any element for removal:
$('.hello').remove();
This will result in a DOM structure with the

element deleted:

Goodbye

If we had any number of nested elements inside

, they would be removed, too. Other jQuery constructs such as data or event handlers are erased as well.
We can also include a selector as an optional parameter. For example, we could rewrite the previous DOM removal code as follows:
$('div').remove('.hello');
This would result in the same DOM structure:

Goodbye

<!DOCTYPE html>

Hello

how are

you?

<button>Call remove() on paragraphs</button>

<!DOCTYPE html>

Hello

how are

you?

<button>Call remove(":contains('Hello')") on paragraphs</button>


Jenna Dewan Swears She Wasn’t Shading Camila Cabello & Shawn Mendes At The AMAs & Sure, Sis
by By Matt GaleaWitches of East End star Jenna Dewan has been forced to publicly deny throwing a heap of shade at Camila Cabello at the American Music Awards yesterday.
During Camila and Shawn Mendes’ ~steamy~ performance of ‘Señorita’, Dewan was reportedly spotted saying, “She’s always extra,” to stylist friend Brad Goreski while rolling her eyes, according to People.
Goreski later defended his friend, stating: “Guys, we were bumping and grinding so hard to ‘Señorita.’”
After the internet got into a major tizzy over the whole thing and Dewan was receiving loads of texts from her famous mates, she publicly shut down the rumours on Instagram.
“I’m getting a lot of text messages from people wondering if I was shading Camila. No! I love her, I love her so much.
“I don’t understand what that’s about but no, I love her, love her, love her.”
A bit of background on the girl in case you’re not as obsessed with her as I am: She’s the ex-wife of Channing Tatum.
The pair share a 6-year-old daughter Everly and finalised their divorce earlier this month.
In September, Dewan announced she and boyfriend Steve Kazee are expecting their first child together.
Dewan starred in Step Up alongside Tatum and also played the loveable witch Freya in the mystical series Witches of East End alongside Riverdale star Mädchen Amick.
It ran for two seasons before its shock cancellation. The series is currently streaming on Netflix, so go forth and binge, witches.


Raju Mavani loses battle to cancer
by Bangalore Mirror BureauActor-filmmaker Raju Mavani who launched Suniel Shetty in films with Balwaan in 1992, passed away on Thursday, at around 7:30pm. He was 62.
According to industry sources, Mavani was suffering from kidney ailments and was later diagnosed with cancer. He fought for three years before succumbing to the disease. Apart from producing films like Imtihaan, with Sunny Deol, Saif Ali Khan and Raveena Tandon, Mavani also acted in several movies like Sarkar, Wanted, Shootout At Wadala and Policegiri to name a few.
The funeral will be at the Oshiwara crematorium at 6 pm today.


The Theory of Conceptual Labor
Tenets of Conceptual Labor
- Labor can be modeled with fundamental components
- Individuals experience conceptual labor through a unique mental model
- Conceptual labor is required when all components of a model are dynamic and interdependent
- We tend towards models with static and well-defined components
- Models must be continuously updated
- Part of conceptual labor is understanding and explaining why it is necessary
- Conceptual labor tends towards abstraction but is rooted in specifics
Core Concepts
Tenets 1 & 2: Modeling Labor
- We work according to our ideas about work and labor
- Who we are is part of how we work
- An individual’s idea of work is their reality of work.
- Complex labor requires a model with many properties and rules for how they interact
- Conceptual labor changes as you do it
- Conceptual labor can be hard to see
- Comparing models is important, legitimate work
- Conceiving of work is real work
- Models must be revealed
- Models must be compared against reality
- Models may be applied without being understood
Tenets 3 & 4: Labor Changes
- Models embody beliefs
- We follow the conventional narrative if we believe that our model has as least one static component
- The conventional narrative is the default narrative of work.
- We have to do conceptual labor because the conventional narrative fails us all the time.
- We resist conceptual labor for many reasons
- It is difficult to redefine labor at the rate at which it changes
Tenets 5 & 6: Competing Narratives
- Doing work and changing the narrative of how you work must happen simultaneously
- Labor that modifies its own narrative is a conversation
- In this conversation, we must represent our experience
- The ideal state of this conversation is spontaneous, continuous agreement
- Labor that can change its own narrative is cyclical
- Successful conceptual labor cannot be fully planned, only cultivated
Tenet 7: Patterns and materials of conceptual labor
- Specific and relevant qualities of conceptual labor are embodied in the media in which it is performed
- Conceptual labor cannot be fully separated from its media
- To model labor is to abstract it
- Mental models of labor share methods of abstraction and can be measured on a fixed scale.
- Basic patterns of conceptual labor can be learned and developed as skills.


The blazingly fast open source microservices API gateway.
The next-generation API platform built on top of Kong.
Kong Enterprise innovation delivered at cloud speed.
End-to-end control of information exchange for hybrid and multi-cloud organizations.
Elegant visual interface for monitoring and managing Kong Enterprise.
Single source of truth for a unified developer experience.
Granular analytics to understand the health of Kong Enterprise.
Intelligent automation to streamline service development and management.
Advanced traffic anomaly detection to identify issues and threats.
Take control of your microservices traffic with the world's most popular API gateway.
Own your Kubernetes cluster by extending Kong functionality as an ingress controller.
Inject Kong as a sidecar for your services to go from mess to mesh.
Get started with Kong now.
Use the 5-minute quickstart and installation guide to deploy Kong now.
Use the quickstart and reference materials to launch Kong Enterprise today.
Learn how to implement Vitals and optimize it for your deployment.
Learn how to create and manage your Kong Dev Portal.


Return true if a value is a valid glob pattern or patterns.
Install with npm:
$ npm install --save is-valid-glob
This really just checks to make sure that a pattern is either a string or array, and if it's an array it's either empty or consists of only strings.
var isValidGlob = require('is-valid-glob');
isValidGlob('foo/*.js');
//=> true
Valid patterns
isValidGlob('a');
isValidGlob('a.js');
isValidGlob('*.js');
isValidGlob(['a', 'b']);
//=> all true
Invalid patterns
isValidGlob();
isValidGlob('');
isValidGlob(null);
isValidGlob(undefined);
isValidGlob(new Buffer('foo'));
isValidGlob(['foo', [[]]]);
isValidGlob(['foo', [['bar']]]);
isValidGlob(['foo', {}]);
isValidGlob({});
isValidGlob([]);
isValidGlob(['']);
//=> all false
true
if the given string looks like a glob pattern or an extglob pattern… more | homepagePull requests and stars are always welcome. For bugs and feature requests, please create an issue.
| Commits | Contributor |
|---|---|
| 9 | jonschlinkert |
| 2 | contra |
(This project's readme.md is generated by verb, please don't edit the readme directly. Any changes to the readme must be made in the .verb.md readme template.)
To generate the readme, run the following command:
$ npm install -g verbose/verb#dev verb-generate-readme && verb
Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command:
$ npm install && npm test
Jon Schlinkert
Copyright © 2017, Jon Schlinkert. Released under the MIT License.
This file was generated by verb-generate-readme, v0.6.0, on June 21, 2017.


PART I. INTRODUCTORY
§351-1 Purpose. The purpose of this chapter is to aid victims of criminal acts, by providing compensation for victims of certain crimes or dependents of deceased victims, and for indemnification of private citizens for personal injury or property damage suffered in prevention of crime or apprehension of a criminal. [L 1967, c 226, pt of §1; HRS §351-1]
Attorney General Opinions
No award to someone who suffers psychological or physical trauma in reaction to the death of a crime victim. Att. Gen. Op. 88-2.
Case Notes
In light of its purpose, chapter should be construed liberally in determining eligibility of applicants. 55 H. 514, 523 P.2d 311 (1974); 63 H. 254, 625 P.2d 372 (1981).


Geode’s Portable Data eXchange (PDX) is a cross-language data format that can reduce the cost of distributing and serializing your objects. PDX stores data in named fields that you can access individually, to avoid the cost of deserializing the entire data object. PDX also allows you to mix versions of objects where you have added or removed fields.
Geode PDX Serialization Features
Geode PDX serialization offers several advantages in terms of functionality.
High Level Steps for Using PDX Serialization
To use PDX serialization, you can configure and use Geode’s reflection-based autoserializer, or you can program the serialization of your objects by using the PDX interfaces and classes.
Using Automatic Reflection-Based PDX Serialization
You can configure your cache to automatically serialize and deserialize domain objects without having to add any extra code to them.
Serializing Your Domain Object with a PdxSerializer
For a domain object that you cannot or do not want to modify, use the
PdxSerializer
class to serialize and deserialize the object’s fields. You use onePdxSerializer
implementation for the entire cache, programming it for all of the domain objects that you handle in this way.Implementing PdxSerializable in Your Domain Object
For a domain object with source that you can modify, implement the
PdxSerializable
interface in the object and use its methods to serialize and deserialize the object’s fields.Programming Your Application to Use PdxInstances
A
PdxInstance
is a light-weight wrapper around PDX serialized bytes. It provides applications with run-time access to fields of a PDX serialized object.Adding JSON Documents to the Geode Cache
The
JSONFormatter
API allows you to put JSON formatted documents into regions and retrieve them later by storing the documents internally as PdxInstances.Using PdxInstanceFactory to Create PdxInstances
You can use the
PdxInstanceFactory
interface to create aPdxInstance
from raw data when the domain class is not available on the server.Persisting PDX Metadata to Disk
Geode allows you to persist PDX metadata to disk and specify the disk store to use.
Using PDX Objects as Region Entry Keys
Using PDX objects as region entry keys is highly discouraged.


Game setup
Player 1
Player 1 name is {{player.name}}.
Previous Player 1 name was {{player.previousName}}.
Player 2
Player 2 name is {{player.name}}.
Previous Player 2 name was {{player.previousName}}.
Player count across all service instances is {{playerCount}}.


You will be redirected once your report is generated.
Time to generate report depends on length of text.


Poems on Various Subjects, Religious and Moral
by Phillis Wheatley
"On the Death of the Rev. Dr. Sewell. 1769."
Additional Information
- Year Published: 1773
- Language: English
- Country of Origin: United States of America
- Source: Wheatley, P. (1773). Poems on Various Subjects, Religious and Moral.London, England: A. Bell.
-
Readability:
- Flesch–Kincaid Level: 2.5
- Word Count: 450
- Genre: Poetry
- Keywords: 18th century literature, american authors, poetry
- ✎ Cite This
Downloads
ERE yet the morn its lovely blushes spread,
See Sewell number'd with the happy dead.
Hail, holy man, arriv'd th' immortal shore,
Though we shall hear thy warning voice no more.
Come, let us all behold with wishful eyes
The saint ascending to his native skies;
From hence the prophet wing'd his rapt'rous way
To the blest mansions in eternal day.
Then begging for the Spirit of our God,
And panting eager for the same abode,
Come, let us all with the same vigour rise,
And take a prospect of the blissful skies;
While on our minds Christ's image is imprest,
And the dear Saviour glows in ev'ry breast.
Thrice happy faint! to find thy heav'n at last,
What compensation for the evils past!
Great God, incomprehensible, unknown
By sense, we bow at thine exalted throne.
O, while we beg thine excellence to feel,
Thy sacred Spirit to our hearts reveal,
And give us of that mercy to partake,
Which thou hast promis'd for the Saviour's sake!
"Sewell is dead." Swift–pinion'd Fame thus cry'd.

How oft for us the holy prophet pray'd!
How oft to us the Word of Life convey'd!
By duty urg'd my mournful verse to close,
I for his tomb this epitaph compose.
"Lo, here a man, redeem'd by Jesus's blood,
"A sinner once, but now a saint with God;
"Behold ye rich, ye poor, ye fools, ye wise,
"Not let his monument your heart surprise;
"Twill tell you what this holy man has done,
"Which gives him brighter lustre than the sun.
"Listen, ye happy, from your seats above.
"I speak sincerely, while I speak and love,
"He fought the paths of piety and truth,
"By these made happy from his early youth;
"In blooming years that grace divine he felt,
"Which rescues sinners from the chains of guilt.
"Mourn him, ye indigent, whom he has fed,
"And henceforth seek, like him, for living bread;
"Ev'n Christ, the bread descending from above,
"And ask an int'rest in his saving love.
"Mourn him, ye youth, to whom he oft has told
"God's gracious wonders from the times of old.
"I too have cause this mighty loss to mourn,
"For he my monitor will not return.
"O when shall we to his blest state arrive?
"When the same graces in our bosoms thrive."


Test blog post!
Here’s a sample blog post without any css styling
You’ll find this post in your _posts
directory. Go ahead and edit it and re-build the site to see your changes. You can rebuild the site in many different ways, but the most common way is to run jekyll serve
, which launches a web server and auto-regenerates your site when a file is updated.
To add new posts, simply add a file in the _posts
directory that follows the convention YYYY-MM-DD-name-of-post.ext
and includes the necessary front matter. Take a look at the source for this post to get an idea about how it works.
Jekyll also offers powerful support for code snippets:
Check out some of my other blog posts below!


Area Flooded: 11,133.14 km2
Population Exposed: 129,001
Daily Precipitation (inches)
Pan and zoom the map to view regional and local flooding, and mouseover hospitals ● to see their names.
Toggle Hospital Layer:


Top 5 Songs For J Pop
Rank
Artist
Title
Album
1
Kenshi Yonezu
Lemon
2
Kenshi Yonezu
Loser
3
Yorushika
Ghost in a flower
4
Yorushika
That's Why I Gave Up on Music
5
Gen Hoshino
Koi