{% extends "base.html" %} {% load widget_tweaks %} {% block content %} Product Management Product Management Product Details Product Details Product Name: {{ product.name }} {% endblock content %}


Open Tech Collaborative
Learn More
Latest News
Contact Us
2
Cart
Shipping information
Credit Card Information
There was an error processing your form. Please try again.
Your information is safe and it will not be stored in our system.
First Name
Last Name
Credit card number
Security Code
Expiration date
Checkout
or Pay with PayPal
Shipping Information
Name
Harvey Enrile
Email
<EMAIL_ADDRESS>Address
R. Duterte Street, Bentley Estate, Banawa, Cebu City
Shipping Speed
Express Delivery (2 to 4 days)
Edit shipping information
You have
2
items in your shopping cart
The Opensource Beehives Project
Quantity
Price
$120
remove
The Opensource Beehives Project
Quantity
Price
$120
remove
Shipping cost
$18.50
Sub Total
$258.50


Stoneham Fire Chief Matthew Grafton and state Fire Marshal Peter Ostroskey said Thursday a teenager in the home escaped through a second-floor window and a dog was treated for smoke inhalation. Damages to the single-family home in the Oct. 12 blaze are estimated at $200,000.
Investigators say the fire started on the first floor at the hoverboard left charging underneath the kitchen table.
The fire was ruled accidental, but it remains unclear whether there was a failure of the hoverboard itself, the charger, or if the hoverboard had been left plugged in for too long.
Grafton says hoverboards should never be left unattended or on a flammable surface while charging.


{% extends "portal/portal_base.html" %} {% block content %}
A significant number of venues first opened their doors in 1969. We have taken ‘newly opened’ venues to be those that explicitly advertise themselves as new. In other words a new venue can open within a building that has previously hosted performances. If a venue hasn’t declared itself to be ‘new’, we haven’t assumed it just opened (even if we’ve listed the first gig within TUGG for that venue).
In 1969 we listed 12 venues that had a ‘Grand Opening’ gig.
They are:
What’s immediately noticeable is that almost all of the venues tried to make a big splash by employing one of the ‘hot’ bands of the day for their Grand Opening. The effectiveness of this strategy is debatable with many of the new venues either discontinuing their gig listings in Go-Set after a few weeks or simply finishing up.
Two of the venues that did kick on were Traffik and Peppers. Traffik was a large club that occupied the building previously the home of the infamous ‘Catcher’. Peppers was held at the Box Hill Town Hall and had a unique setup where the younguns could go and rage downstairs where their favourite band played whilst mums and dads tripped upstairs to the ballroom (cool concept I reckon!)
What’s immediately noticeable is that almost all of the venues tried to make a big splash by employing one of the ‘hot’ bands of the day for their Grand Opening. The effectiveness of this strategy is debatable with many of the new venues either discontinuing their gig listings in Go-Set after a few weeks or simply finishing up.
Two of the venues that did kick on were Traffik and Peppers. Traffik was a large club that occupied the building previously the home of the infamous ‘Catcher’. Peppers was held at the Box Hill Town Hall and had a unique setup where the younguns could go and rage downstairs where their favourite band played whilst mums and dads tripped upstairs to the ballroom (cool concept I reckon!)
A notable exception to the rule that new venues splash out on big name acts was the Jam Factory. Its opening was a ‘musos only’ closed event where performers and spectacular dance magician Jeff Crozier appeared and jammed all night long. This place seemed to offer any punters attending something far more freeform than most of the dances of the time.
A quick summary of the highlights of 1969:
Total of 168 Gigs listed
Venues most played:The Victorian seaside was a popular place for gigs in the summertime of 1969. Hordes of teens got out of Melbourne and flocked to the waves of the seaside towns during the day and needed somewhere to dance the sand off their feet at night.
The Mornington Peninsula town Sorrento had a dance at the local RSL called Tom Katz. This dance had some popular bands play and had gigs most nights throughout January and weekend gigs right until March as well as the Easter break in early April.
Tootgarook (near Rye and Rosebud) had a dance called Itzagas which ran during the first week of 1969. In Rosebud at Peninsula Gardens a couple of large concerts were held where top rockers Masters Apprentices, Ronnie Burns, Johnny Farnham and The Zoot performed.
The town of Mornington (about 60 kms out of Melbourne) held a dance called Caesars, at its town hall throughout 1969. Its busiest time was during January where 10 gigs were held.
Further east, in Westernport Bay, the Phillip Island town of Cowes had a dance at the Cowes Old Post Office. Despite 16 gigs in January the venue wasn’t heard of again until 1970.
On the West Coast, there was a dance listed at Airey’s Inlet where hipster pop rockers The Groop, held a week long residency from New Years Eve into January 1969.
Way out west at Warrnambool 16 gigs were held from New Year’s Eve into mid January as some of the finest Melbourne based groups headed out to this regional city.
At years end a few more beachside regional towns featured gigs listed for December 69. The Wild Colonial Club at Lorne had held a dance for many summers since the late 1950s, though was only listed this year for December.
The Jan Juc Surf Lifesaving Club held some dances around Christmas time with the Town Criers and the New Dream providing the entertainment. On the eastern side of Melbourne at Cape Patterson, the Afghan dance hosted music from Christmas 1969 into early January 1970.


Innovations
sandwich, flying food, movement
Read More
bread, ham, tight max
Read Less
raspberry, berry, summer
Read More
eclair, strawberry cake, strawberries
Read More
food, kitchen, cook
Read Less
Template
created with
Static Website Generator
.


'The ABCs of Metallica': A book for children and fans alike
by Silke Wünsch (als)With nearly 40 years of history together, the group has a lot of stories to tell — especially for a new generation of fans: "The ABCs of Metallica" looks back at the highlights of the heavy metal band's journey.
The band announced back in July that there would be a children's book coming out. Published on November 26, The ABCs of Metallica is a project that's very close to the hearts of all the band's members. After all, they're family people and support charitable causes with their foundation All Within My Hands. Part of the book's proceeds are to flow into the non-profit organization as well.
Beyond the new generation of admirers, the group's die-hard fans will enjoy sharing the band'shistory in rhymes and illustrations with their children — perhaps hoping they will become the next generation of heavy metal talent.
Read more: Metallica and an Afghan project win 'Nobel Prize' for music
Each letter of the alphabet stands for a moment in the history of the band that was founded in 1981. For instance, the letter "K" stands for guitarist Kirk Hammett; as a teaser for the book, he introduces the entry himself on YouTube.
"G" is for Garage Days, referring to the EP of covers released by the band in 1987. The book includes anecdotes about other classic albums, such as Master of Puppets (1986) and St. Anger (2003) and songs — "E" is for Metallica's 1991 hit, "Enter Sandman." The colorful encyclopedia also reveals fun facts about the members of the band.
'C' for Cliff
The book also includes a tribute to bassist Cliff Burton, who died in 1986. The band was involved in a serious accident with their tour bus, which Burton did not survive. US magazine Revolver published the two pages of the book dedicated to "C" for Cliff:
"He played his bass like a master.
His music was a gift to all.
Among the greatest musicians in history,
Cliff Burton will forever stand tall."
Alongside the poem is a drawing of the musician, as always dressed entirely in denim, with a flowing red mane and angel's wings. The band still celebrates him today during their live concerts.
The lyrics in the book were written by Howie Abrams, who has published several music books. The illustrations are by graffiti artist Michael "Kaves" McLeer, who also worked on the 2012 exhibition "Obey Your Master," which showed how artists and musicians were inspired by Metallica.
Read more: Wacken your head: Is headbanging dangerous?
Master of merch
The book is another addition to the band's extensive merchandising selection. In addition to common accessories, there are also exceptional items like wetsuits for surfers, coolers, Christmas tree ornaments, camping chairs, and cufflinks that cost $250 (€227). The most expensive pieces are the limited edition "Enter Sandman" watches for a whopping $750.


The top level Facebook module.
The Facebook module is used for connecting your application with Facebook. This module supports the following features:
-
Logging in to Facebook and authorizing your application.
-
Making requests through the Facebook Graph API using requestWithGraphPath.
-
Making requests through the legacy Facebook REST API using request.
-
Posting Facebook dialogs.
Facebook Login and Authorization
To use Facebook, a user must log in to Facebook and explicitly authorize the application to perform certain actions, such as accessing profile information or posting status messages.
There are two ways to initiate the login process:
-
Call authorize prompt the user to login and authorize the application.
-
Create a Facebook LoginButton to allow the user to log in if desired.
Which approach you take depends on your UI and how central Facebook is to your application.
Before calling authorize
or creating a login button, you must set the
appid and permissions
properties.
To create a Facebook App ID, go to the Facebook Developer App:
For a complete list of permissions, see the official Facebook Permissions Reference
Facebook Graph API
The Facebook Graph API is the preferred method for getting information about a user's friends, news feed, and so on. Each object in the Facebook social graph is represented by a graph API object, such as a user, photo, or status message.
The Graph API allows you to make requests on behalf of the user, such as posting a picture or status message.
Use the requestWithGraphPath method to make a request to the Graph API.
For details on each of the Graph API objects and the supported operations, see the official Facebook Graph API documentation.
Facebook REST API
The Facebook REST API is in the process of being deprecated, and should not be used unless your application relies on an API that doesn't exist in the Graph API.
Use the request method to make a request to the REST API.
For details on the REST API, see the official Facebook REST API documentation.
Facebook Dialogs
Facebook dialogs are standard user-interface components for used to prompt users to interact with Facebook in a specific way, such as:
-
Sending an application request
-
Sending a status update
-
Adding a friend
Because dialogs require user interaction, they do not require Facebook permissions.
For details on different dialogs see the
official Facebook Dialogs documentation.
iOS Platform Implementation Notes
Due to how the facebook login process works on iOS, your app will need to have the following in your tiapp.xml if you target those platforms:
<property name="ti.facebook.appid">your_facebook_app_id_here</property >
You must still set Ti.Facebook.appid within your app itself to use the facebook module.
This property is used only for configuring your app to interface with the facebook
login process.
Previous Versions
Titanium Mobile SDK 1.6.0 marked a significant change for this module. Older versions of
the module were not compatible with the new Graph API. Applications written for the
pre-1.6.0 version of this module will not work with the 1.6.0 and higher versions.
Nor is the code shown in the examples here backwards-compatible with pre-1.6.0 Titanium
Mobile SDK.
| login | Fired at session login. | |
| logout | Fired at session logout. |
Adds the specified callback as an event listener for the named event.
Arguments
| name | [String] | Name of the event. |
| callback | [Callback<Object>] | Callback function to invoke when the event is fired. |
Applies the properties to the proxy.
Arguments
| props | [Dictionary] | A dictionary of properties to apply. |
Prompts the user to log in (if not already logged in) and authorize your application.
Creates and returns an instance of Titanium.Facebook.LoginButton
.
Arguments
| parameters | [Dictionary<Titanium.Facebook.LoginButton>] | Properties to set on a new object, including any defined by Titanium.Facebook.LoginButton except those marked not-creation or read-only. |
Opens a supported Facebook dialog.
Arguments
| action | [String] | Specifies which dialog to show, such as "feed". |
| params | [Object] | A dictionary object for pre-filling some of the dialog's fields. See Code Examples. |
| callback | [Callback<FacebookDialogResponse>] | Callback to invoke when the user completes or cancels the dialog. |
Fires a synthesized event to any registered listeners.
Arguments
| name | [String] | Name of the event. |
| event | [Dictionary] | A dictionary of keys and values to add to the Titanium.Event object sent to the listeners. |
Gets the value of the accessToken property.
Gets the value of the appid property.
Gets the value of the expirationDate property.
Gets the value of the forceDialogAuth property.
Gets the value of the loggedIn property.
Gets the value of the permissions property.
Gets the value of the uid property.
Removes the specified callback as an event listener for the named event.
Arguments
| name | [String] | Name of the event. |
| callback | [Callback<Object>] | Callback function to remove. Must be the same function passed to addEventListener. |
Makes a request to the legacy Facebook REST API.
Arguments
| method | [String] | The REST API method to call. |
| params | [Object] | A dictionary object for setting parameters required by the call, if any. See Code Examples. |
| callback | [Callback<FacebookRESTResponse>] | Callback to invoke when the request completes. |
Makes a Facebook Graph API request.
Arguments
| path | [String] | Graph API path to request. |
| params | [Dictionary] | A dictionary object for setting parameters required by the call, if any. See Code Examples. |
| httpMethod | [String] | The HTTP method (GET/POST/DELETE) to use for the call. |
| callback | [Callback<FacebookGraphResponse>] | Callback to invoke when the request completes. |
Sets the value of the accessToken property.
Arguments
| accessToken | [String] | New value for the property. |
Sets the value of the appid property.
Arguments
| appid | [String] | New value for the property. |
Sets the value of the expirationDate property.
Arguments
| expirationDate | [Date] | New value for the property. |
Sets the value of the forceDialogAuth property.
Arguments
| forceDialogAuth | [Boolean] | New value for the property. |
Sets the value of the loggedIn property.
Arguments
| loggedIn | [Boolean] | New value for the property. |
Sets the value of the permissions property.
Arguments
| permissions | [Array<String>] | New value for the property. |
Sets the value of the uid property.
Arguments
| uid | [String] | New value for the property. |
Event properties
| cancelled |
Indicates if the user canceled the login request by closing the dialog. |
| data |
Data returned by Facebook when we query for the UID (using graph path "me") after a successful login. Data is in JSON format, and includes information such as user name, locale and gender. |
| error |
Error message, if request failed. |
| source |
[Object] Source object that fired the event. |
| success |
[Boolean] Indicates if the login was successful. |
| type |
[String] Name of the event fired. |
| uid |
[String] User ID returned by Facebook if the login was successful. |


Received another request for this feature. Would like a means to apply the tags for "all countries" to a given resource. Right now we have a standard autocomplete widget in the record edit form.
Perhaps we could workout a toggle option on the "New" record form. Where the user choses between applying all countries or seeing the standard form element to apply a small number of country options.
labeled
by Kevin Reiss at 2023-01-05 14:51:23.labeled
by Kevin Reiss at 2023-01-05 14:51:24.referenced
by Christina Chortaria at 2023-01-04 22:02:49.merged
by Christina Chortaria at 2023-01-04 22:02:49.closed
by Christina Chortaria at 2023-01-04 22:02:49.head_ref_deleted
by Christina Chortaria at 2023-01-04 22:02:50.Fixed and deployed.
closed
by None at 2023-01-05 00:21:53.closed
by None at 2023-01-05 13:51:07.ready_for_review
by None at 2023-01-05 18:10:27.referenced
by Jane Sandberg at 2023-01-05 18:51:43.merged
by Jane Sandberg at 2023-01-05 18:51:43.closed
by Jane Sandberg at 2023-01-05 18:51:43.head_ref_deleted
by Jane Sandberg at 2023-01-05 18:51:44.@faithc Can you please attach a spreadsheet here containing the barcode and the the top_container uri?
(In case you didn't know, you can easily export the item records from Alma by going to the collection record > Items > export.)
Thanks!
Ohhh, I did NOT know that. Thanks! Spreadsheet attached. TC099_barcodes.xlsx
mentioned
by None at 2023-01-05 20:21:48.subscribed
by None at 2023-01-05 20:21:48.Closing for the moment as there has been a period of inactivity
Closing for the moment as there has been a period of inactivity
closed
by None at 2023-01-05 20:44:53.Please forgive long hiatus. Created other ticket 318 for merging containers. Please let me know if it looks at all like what you might need.
See #318
renamed
by None at 2023-01-05 20:48:05.assigned
by None at 2023-01-05 20:49:30.labeled
by None at 2023-01-05 20:46:24.assigned
by None at 2023-01-05 20:49:46.labeled
by None at 2023-01-05 20:45:19.closed
by None at 2023-01-05 20:47:07.reopened
by None at 2023-01-05 20:51:38.This is resolved. The 856|3 label is displayed
closed
by Christina Chortaria at 2023-01-05 14:01:56.We removed Hathi
closed
by Christina Chortaria at 2023-01-05 14:03:27.Resolved it displays Selected images https://catalog.princeton.edu/catalog/9938524743506421
closed
by Christina Chortaria at 2023-01-05 14:05:19.Marking as draft until we get stakeholder feedback
convert_to_draft
by Max Kadel at 2023-01-05 16:37:48.deployed
by None at 2023-01-05 18:53:54.referenced
by Jane Sandberg at 2023-01-05 18:58:20.merged
by Jane Sandberg at 2023-01-05 18:58:20.closed
by Jane Sandberg at 2023-01-05 18:58:20.head_ref_deleted
by Jane Sandberg at 2023-01-05 18:58:21.review_requested
by Cliff Wulfman at 2023-01-05 23:36:30.referenced
by Kevin Reiss at 2023-01-05 14:23:39.merged
by Kevin Reiss at 2023-01-05 14:23:39.closed
by Kevin Reiss at 2023-01-05 14:23:40.head_ref_deleted
by Kevin Reiss at 2023-01-05 14:23:41.Hi, I made a commit to main with this change right after the meeting https://github.com/pulibrary/dacs_handbook/commit/9a3faa28688d330452c5f937c8ecd25b2e05ac8a.
closed
by Kevin Reiss at 2023-01-05 14:24:46.We'll test this on staging, where there are 1441 Event objects with 1281 unique child ids. So after the migration is run there should be 1281 with that current attribute set to true.
VPN works!! :)
closed
by Robert-Anthony Lee-Faison at 2023-01-05 16:57:24.VPN works!! :)
closed
by Robert-Anthony Lee-Faison at 2023-01-05 16:57:34.referenced
by None at 2023-01-05 18:20:42.merged
by None at 2023-01-05 18:20:42.closed
by None at 2023-01-05 18:20:42.head_ref_deleted
by None at 2023-01-05 18:20:43.labeled
by None at 2023-01-05 18:21:50.@dependabot rebase
mentioned
by Dependabot at 2023-01-05 18:21:25.head_ref_force_pushed
by None at 2023-01-05 18:21:38.convert_to_draft
by Jane Sandberg at 2023-01-05 17:04:41.head_ref_force_pushed
by Jane Sandberg at 2023-01-05 17:14:41.deployed
by None at 2023-01-05 17:15:21.head_ref_force_pushed
by Jane Sandberg at 2023-01-05 17:17:12.deployed
by None at 2023-01-05 17:17:21.head_ref_force_pushed
by Jane Sandberg at 2023-01-05 17:23:56.deployed
by None at 2023-01-05 17:24:06.head_ref_force_pushed
by Jane Sandberg at 2023-01-05 17:29:38.deployed
by None at 2023-01-05 17:30:05.deployed
by None at 2023-01-05 17:35:30.deployed
by None at 2023-01-05 17:40:20.deployed
by None at 2023-01-05 17:45:20.deployed
by None at 2023-01-05 18:05:51.deployed
by None at 2023-01-05 18:10:06.duplicate of https://github.com/pulibrary/orangelight/issues/2995
closed
by Christina Chortaria at 2023-01-05 03:11:02.closed
by Kevin Reiss at 2023-01-05 14:23:41.labeled
by Kevin Reiss at 2023-01-05 14:36:27.deployed
by None at 2023-01-05 14:32:42.referenced
by Christina Chortaria at 2023-01-05 14:37:36.merged
by Christina Chortaria at 2023-01-05 14:37:36.closed
by Christina Chortaria at 2023-01-05 14:37:36.head_ref_deleted
by Christina Chortaria at 2023-01-05 14:37:37.labeled
by Kevin Reiss at 2023-01-05 14:41:49.labeled
by Kevin Reiss at 2023-01-05 15:09:26.assigned
by Max Kadel at 2023-01-05 17:45:18.Coverage: 94.522% (-0.02%) from 94.538% when pulling 11ba58e235bb3e1d6937d22173a715da3f57a26a on i3338-non-search-param into 7cea17bbabd50cb24fc6d26d071a8e9d0a0552a6 on main.
@christinach Thanks for catching this! Can you re-review?
head_ref_force_pushed
by Jane Sandberg at 2023-01-04 22:48:44.review_requested
by Jane Sandberg at 2023-01-05 16:12:09.mentioned
by Christina Chortaria at 2023-01-05 16:12:37.subscribed
by Christina Chortaria at 2023-01-05 16:12:37.deployed
by None at 2023-01-05 18:46:29.referenced
by Christina Chortaria at 2023-01-05 18:54:24.merged
by Christina Chortaria at 2023-01-05 18:54:24.closed
by Christina Chortaria at 2023-01-05 18:54:24.head_ref_deleted
by Christina Chortaria at 2023-01-05 18:54:25.closed
by Christina Chortaria at 2023-01-05 18:54:25.labeled
by Kevin Reiss at 2023-01-05 18:58:41.Coverage: 94.514% (-0.008%) from 94.522% when pulling f8d1d5234f91e72c808aebe53ddf820976a519a9 on facets-deprecation into dfa23faaf20917dbf6c7644048a8b58b910b8a91 on main.
head_ref_force_pushed
by Jane Sandberg at 2023-01-04 23:51:43.head_ref_force_pushed
by Jane Sandberg at 2023-01-05 19:28:10.head_ref_force_pushed
by Jane Sandberg at 2023-01-05 19:37:53.ready_for_review
by Jane Sandberg at 2023-01-05 19:46:45.review_requested
by Christina Chortaria at 2023-01-05 19:53:16.deployed
by None at 2023-01-05 19:53:49.Coverage: 94.522%. Remained the same when pulling 7ec3424b5d128b63256a879c3cfd1961d49a20a1 on addsolrdownloadtoignore into dfa23faaf20917dbf6c7644048a8b58b910b8a91 on main.
referenced
by Jane Sandberg at 2023-01-05 20:02:34.merged
by Jane Sandberg at 2023-01-05 20:02:34.closed
by Jane Sandberg at 2023-01-05 20:02:34.head_ref_deleted
by Jane Sandberg at 2023-01-05 20:02:35.Coverage: 94.522%. Remained the same when pulling 6f672baa7806d23f98606ca4c4cbd85ac064c730 on i3351-search-bar-on-advanced into da55df62057d65d0934b72e1526d462de2679167 on main.
deployed
by None at 2023-01-05 22:50:44.referenced
by Christina Chortaria at 2023-01-05 22:56:54.merged
by Christina Chortaria at 2023-01-05 22:56:54.closed
by Christina Chortaria at 2023-01-05 22:56:54.head_ref_deleted
by Christina Chortaria at 2023-01-05 22:56:55.labeled
by Christina Chortaria at 2023-01-05 22:09:27.assigned
by Jane Sandberg at 2023-01-05 22:09:41.assigned
by Christina Chortaria at 2023-01-05 22:48:24.closed
by Christina Chortaria at 2023-01-05 22:56:55.Deployed to staging & feature turned on in that environment for QA.
Coverage: 94.515% (-0.005%) from 94.52% when pulling 4214ee0043a60c887e62428fe34dd6e9769f7002 on i3328feedbackbar into f66bd1ccf442fed95c3c75ab4612f7ed0e2c0363 on main.
deployed
by None at 2023-01-05 17:24:15.review_requested
by Max Kadel at 2023-01-05 20:24:59.referenced
by Jane Sandberg at 2023-01-05 23:05:34.merged
by Jane Sandberg at 2023-01-05 23:05:34.closed
by Jane Sandberg at 2023-01-05 23:05:34.head_ref_deleted
by Jane Sandberg at 2023-01-05 23:05:35.closed
by Jane Sandberg at 2023-01-05 23:05:35.I searched again in scsb items with barcode:<PHONE_NUMBER>5035. This time they display 'out'.
This might be the reason but it needs more investigation so that we have a clear picture.
labeled
by Christina Chortaria at 2023-01-06 02:48:48.renamed
by Chuck McCallum at 2023-01-05 14:35:50.renamed
by Chuck McCallum at 2023-01-05 14:38:32.I know that we have had problems with jQuery... I think it was trying to wrap it as an ESM, but I'm not sure. - #761 will lessen our dependence on jQuery,
so it might make sense to tackle that first.
assigned
by Chuck McCallum at 2023-01-05 15:45:37.review_dismissed
by None at 2023-01-05 02:00:26.referenced
by Chuck McCallum at 2023-01-05 17:20:14.merged
by Chuck McCallum at 2023-01-05 17:20:14.closed
by Chuck McCallum at 2023-01-05 17:20:14.head_ref_deleted
by Chuck McCallum at 2023-01-05 17:20:15.assigned
by Chuck McCallum at 2023-01-05 17:26:53.renamed
by Chuck McCallum at 2023-01-05 20:02:08.@bess @Twade968 - I sort of automated the process to export/import the data from the tests based on your instructions in the docs folder. This is something that I am using as I work on https://github.com/pulibrary/pdc_discovery/issues/340 and I thought could be useful in general.
head_ref_force_pushed
by Hector Correa at 2023-01-05 21:49:03.head_ref_force_pushed
by Hector Correa at 2023-01-05 22:02:28.review_requested
by Hector Correa at 2023-01-05 22:09:12.mentioned
by Bess Sadler at 2023-01-05 22:10:37.subscribed
by Bess Sadler at 2023-01-05 22:10:37.mentioned
by Tyler Wade at 2023-01-05 22:11:22.subscribed
by Tyler Wade at 2023-01-05 22:11:22.head_ref_force_pushed
by Francis Kayiwa at 2023-01-05 15:52:39.referenced
by Francis Kayiwa at 2023-01-05 16:06:31.merged
by Francis Kayiwa at 2023-01-05 16:06:31.closed
by Francis Kayiwa at 2023-01-05 16:06:31.head_ref_deleted
by Francis Kayiwa at 2023-01-05 16:06:32.referenced
by Francis Kayiwa at 2023-01-05 17:17:57.review_requested
by Francis Kayiwa at 2023-01-05 12:07:47.referenced
by None at 2023-01-05 21:41:25.merged
by None at 2023-01-05 21:41:25.closed
by None at 2023-01-05 21:41:26.head_ref_deleted
by None at 2023-01-05 21:41:27.head_ref_force_pushed
by Jane Sandberg at 2023-01-05 21:18:01.referenced
by Christina Chortaria at 2023-01-06 01:19:37.merged
by Christina Chortaria at 2023-01-06 01:19:37.closed
by Christina Chortaria at 2023-01-06 01:19:37.head_ref_deleted
by Christina Chortaria at 2023-01-06 01:19:38.Since I understand how to, I am going through each project and deleting the deploy key and recreating one. I can not quite remember how to create the Coverall Key, so I am skipping that for the moment.
All github deploy keys have been rotated. There are still some coverall keys in place for:
I believe all our repos have been completed
labeled
by Bess Sadler at 2023-01-05 16:34:05.assigned
by Bess Sadler at 2023-01-05 16:34:06.assigned
by None at 2023-01-05 16:56:52.closed
by None at 2023-01-05 18:29:52.Feedback: The second diagram is more what we want, with the addition of a Role
entity. The precise roles that we'll need is still in flux, and should not be hard-coded in the RDB structure. Back to draft.
convert_to_draft
by Chuck McCallum at 2023-01-05 15:14:42.ready_for_review
by Chuck McCallum at 2023-01-05 15:42:08.


{% include 'header.html' %} {# This is a comment. It shall be ignored. #} {# Comments can span multiple lines. There is absolutely nothing wrong with that. #}


Senior Programming Student
York, PA
<EMAIL_ADDRESS>Skills
Video Editing
Programming
Coding Languages
Javascript
Python
Java
I want to be able to make companies websites and new web designs
I want to learn Java fully in the future to make programs OR edit programs.
I want to fully learn and comprehend graphic designing to start working on my own website design and do work on others.


--- ---
Kafka has a modern cluster-centric design that offers strong durability and fault-tolerance guarantees.
Kafka is an excellent choice for transporting metrics. It's not a simple system, so you will find yourself digging through the official documentation from time-to-time. It is resilient towards the failure of individual nodes, and it supports log retention that could potentially give you some breathing room in the face of problems with other components without worrying about the permanent loss of metrics.
A Kafka cluster consists of the following parts:
You should follow the Kafka introduction for getting started.
On top of this, it is important that you configure the num.partitions option on the broker to be a larger number, like 100
.
# server.properties
num.partitions=100
The exact number is not important, but the number of partitions used for a particular topic is the limiting factor for distributing load. So, if you have a topic with only two partitions, this would limit the number of active Heroic consumers you have to two as well.
The following is a complete example configuration for a Kafka consumer.
Take note of group.id
below.
Two consumers belonging to the same group.id
will balance the responsibility between them.
Therefore you can operate as many consumers as you need to support your desired throughput and redundancy with the same configuration.
# heroic.yaml
port: 8080
consumers:
- type: kafka
schema: com.spotify.heroic.consumer.schemas.Spotify100
topics:
- "metrics-pod1"
config:
group.id: heroic-consumer
zookeeper.connect: zookeeper1.example.com,zookeeper2.example.com,zookeeper3.example.com/heroic
auto.offset.reset: smallest
auto.commit.enable: true
Using the above configuration as skeleton you need to fill in at least the metric, and metadata backends. At this point, you now have a consumer configuration that can be used to spawn one or more Heroic instances faithfully consuming your metrics.
ffwd-java is a metrics forwarding agent developed at Spotify. It has first-class support for sending metrics into Kafka, and the following will detail how this is configured.
Kafka uses partitions to distribute load, each producer decides which partition a particular message should be sent to. ffwd-java supports partitioning (see "Topics and Logs" in the Kafka documentation) per-host using the following output plugin:
# ffwd.yaml
attributes:
host: database.example.com
pod: pod1
output:
plugins:
- type: "kafka"
flushInterval: 10000
serializer:
type: spotify100
router:
type: attribute
attribute: pod
producer:
metadata.broker.list: "kafka1.example.com,kafka2.example.com,kafka3.example.com"
request.required.acks: 1
request.timeout.ms: 1000
The above will instruct ffwd-java to send metrics to kafka, the topic will be determined (routed) to the metrics-<pod>
topic, where <pod>
is the pod
attribute in the metric.
A host-based partitioner by default, so metrics sent from a single given host will all end up on the same partition.


Create a blog to publish a collection of Distill articles
Distill for R Markdown websites include integrated support for blogging. To create a blog you author a collection of posts (located in the _posts
subdirectory of your website) and then dedicate a page (usually the website homepage) to a listing of all of your posts.
Structure difference: Websites are just collections of pages you can navigate to via the menu, whereas blogs have collections of posts that can be indexed and syndicated (via their RSS feed). Distill blogs are a distill website with added blog posts.
Workflow difference: Furthermore, website pages and root pages of blogs are re-rendered when the site is rebuilt but blog articles are not. Each blog article has to be rendered on its own, with intent. Why? Given that R package upgrades have a tendency to break older code, continuously re-rendering old posts is nearly impossible to do without errors, especially over longer periods of time.
If you are using RStudio, the easiest way to get started is to use the Distill Blog option in the RStudio New Project dialog:
A new RStudio Project for the blog will be created and opened. The blog will include the following files:
| Option | Description |
|---|---|
_site.yml |
Website configuration file. |
index.Rmd |
Blog home page. |
about.Rmd |
Blog about page. |
_posts/welcome/welcome.Rmd |
Welcome post for the blog. |
Note that the welcome
post is just there to provide some skeletal content for the blog – feel free to delete it and add your own initial post to the blog as described in creating a post.
If you are not using RStudio you can also call the Distill create_blog()
function:
library(distill)
create_blog(dir = "my-blog", title = "My Blog")
The basic scaffolding for a blog and an initial welcome post will be created within the my-blog
sub-directory.
After you’ve created the blog scaffolding, there are a couple of additional configuration items you’ll want to add to your _site.yml
so that it’s easier to share content on the blog via RSS and social networks like Twitter:
A short description
of the site. This field is used for the channel description of your RSS feed.
A base_url
for the site (the URL where it will be published to). This is used both for RSS feed items and for sharing posts via Open Graph and Twitter Card.
For example:
_site.yml
name: "reproducible-finance-with-r"
title: "Reproducible Finance with R"
description: |
Exploring reproducible finance with the R statistical
computing environment.
base_url: https://beta.rstudioconnect.com/content/11424/
navbar:
logo: images/rstudio.png
right:
- text: "Home"
href: index.html
- text: "About"
href: about.html
- text: "Contributors"
href: contributors.html
- icon: fa fa-rss
href: index.xml
output: distill::distill_article
Note that we’ve also added a feed icon to the right side of the menu bar which makes it easy to discover and browse the RSS feed for the blog.
The easiest way to start authoring a new post is to call the create_post()
function from within your blog’s directory. For example:
library(distill)
create_post("The Sharpe Ratio")
This will create a sub-directory for your post within the _posts
directory, add a stub Distill article, and open the article for editing.
If you want your post to start out as a draft (i.e. not be included within the listing of all posts) then you can add draft = TRUE
. For example:
create_post("The Sharpe Ratio", draft = TRUE)
You work on blog posts independent of the enclosing website (use Knit to render and preview the post just like any R Markdown document). This is in fact the only way to update post content — posts are considered standalone documents that are not re-rendered when the site is built. This is because posts are often expensive to render and have R package dependencies that may be difficult to satisfy as time goes on.
In the next section will describe how to create a listing page for all of your posts.
Once you have authored one or more posts you’ll want to create a listing page. You can do this by adding a listing
metadata entry to the page you to include the listing on. This is often the main page for the website (index.Rmd). For example:
index.Rmd
---
title: "Reproducible Finance with R"
site: distill::distill_website
listing: posts
---
In our example blog (which will be described in more detail below) this results in the following listing:
Above we demonstrated creating a listing page for all posts. You can also create a custom listing for a subset of posts (e.g. a gallery of featured posts). To do this, just enumerate the posts you want to include as follows:
gallery.Rmd
---
title: "Gallery of featured posts"
listing:
posts:
- 2016-11-08-sharpe-ratio
- 2017-11-09-visualizing-asset-returns
- 2017-09-13-asset-volatility
---
If your posts include categories
metadata, then the page will also include category links to the right of the article listing. For example, here is some post metadata that includes categories:
---
title: "The Sharpe Ratio"
# (additional metadata e.g. description and date, excluded for brevity)
categories:
- portfolios
- dygraphs
As a result of including categories
, the listing page now looks like this:
When you create a listing page an RSS feed is created automatically for the page (using the name of the listing page with a .xml
file extension). You can link to the RSS feed within your site’s navigation bar as follows (some navbar entries excluded for brevity):
_site.yml
name: "reproducible-finance-with-r"
title: "Reproducible Finance with R"
description: |
Exploring reproducible finance with the R statistical
computing environment.
base_url: https://beta.rstudioconnect.com/content/11424/
navbar:
right:
- icon: fa fa-rss
href: index.xml
output: distill::distill_article
Note that the description
and base_url
fields are both required to generate an RSS feed.
By default the most recent 20 articles will be included in the RSS feed. You can change this by specifying feed_items_max
within the collection configuration in _site.yml
(navbar and output format fields omitted for brevity):
_site.yml
name: "reproducible-finance-with-r"
title: "Reproducible Finance with R"
description: |
Exploring reproducible finance with the R statistical
computing environment.
base_url: https://beta.rstudioconnect.com/content/11424/
collections:
posts:
feed_items_max: 50
Specify feed_items_max: false
to have no limit on the number of items included in the feed.
If you want to work on a post for a period of time without having it be added to the listing page, add draft: true
to the post’s metadata. For example:
---
title: "The Sharpe Ratio"
description: |
In this post we present a classic finance use case using the
PerformanceAnalytics, quantmod, and dygraphs packages.
We'll demonstrate importing stock data, building a portfolio,
and then calculating the Sharpe Ratio.
draft: true
---
When you are ready to publish the post, either remove the draft
option or set it to false
, then build the website.
Beyond support for drafts, Distill has a number of additional features to accommodate a variety of post authoring and contribution workflows, including importing posts published elsewhere on the web (e.g. on RPubs, in a Git repository, or on another blog). The article on blog post workflow describes these options in more detail.
Readers will likely want to comment on and share articles they read on your blog. You can enable support for Disqus comments and sharing links for Twitter, LinkedIn, and other services by adding options to the collection:posts
section of _site.yml
.
For example, the following options provide the Disqus shortname for a site and specify that we want sharing buttons for Twitter and LinkedIn.
_site.yml
name: "reproducible-finance-with-r"
title: "Reproducible Finance with R"
description: |
Exploring reproducible finance with the R statistical
computing environment.
base_url: https://beta.rstudioconnect.com/content/11424/
collections:
posts:
disqus: reproducible-finance-with-r
share: [twitter, linkedin]
The following footer is then automatically included at the end of each post:
Note that the base_url
field is required in order to use Disqus and sharing links.
Valid values for the share
option are twitter
, linkedin
, facebook
, google-plus
, and pinterest
.
By default, the full text of Disqus comments are not displayed (rather, a link is provided that will expand the comment section). This is done so that a long comment section doesn’t obscure the bibliography and other appendices. If you’d rather show the comments by default you can use this alterante syntax for disqus
configuration:
collections:
posts:
disqus:
shortname: reproducible-finance-with-r
hidden: false
share: [twitter, linkedin]
Specifying the hidden: false
option for disqus
will causes all comments to be displayed inline by default.
You can use whatever scheme you like to organize the _posts
directory. You can have all posts at the top level or you can create subdirectories to create groupings of posts.
One popular scheme for organizing blog posts is to use a date prefix for the post directory names. For example:
_posts/
2017-11-09-visualizing-asset-returns/
2017-09-13-asset-volatility/
2017-03-07-quandl-and-forecasting/
2016-11-08-sharpe-ratio/
The benefits of this scheme are that post names are given additional uniqueness (to guard against colliding names over the long term) and are also automatically listed in order when browsing the _posts
directory.
Note that if you use a date-prefixed post directory you are not required to specify an explicit date
field within your post’s metadata.
Note that the listing for our example above includes a preview image for each post. Preview thumbnail images are generated automatically based on the first plot encountered within your post. You can specify that a specific plot should be used as the preview image using the preview
chunk option. For example:
```{r, layout="l-body-outset", preview=TRUE}
library(ggplot2)
ggplot(diamonds, aes(carat, price)) + geom_smooth() +
facet_grid(~ cut)
```
If you want to use another image entirely as a post preview you add a preview
field to the post’s metadata. For example, here we add a preview
field to the example metadata from above (some fields excluded for brevity):
---
title: "The Sharpe Ratio"
description: |
In this post we present a classic finance use case using the
PerformanceAnalytics, quantmod, and dygraphs packages.
We'll demonstrate importing stock data, building a portfolio,
and then calculating the Sharpe Ratio.
preview: images/sharpe-ratio.png
---
Preview images are also used for generating Open Graph and Twitter Card metadata. However, since those systems require that preview images be specified as absolute URLs, you also need to add a base_url
field to your _site.yml
file as described above in Getting Started.
If your _site.yml
file provides a base_url
field, then an article citation appendix and related metadata will be included automatically within all published posts. For example:
If you want to disable this behavior you can use the collections:posts:citations
field within _site.yml
. For example:
_site.yml
name: "reproducible-finance-with-r"
title: "Reproducible Finance with R"
description: |
Exploring reproducible finance with the R statistical
computing environment.
base_url: https://beta.rstudioconnect.com/content/11424/
collections:
posts:
disqus: reproducible-finance-with-r
share: [twitter, linkedin]
citations: false
You can add HTML that enables readers to subscribe to your blog by including the collections:posts:subscribe
option within _site.yml
. The subscribe
option in turn points to an HTML file that provides the ability to subscribe to your blog. For example:
_site.yml
name: "reproducible-finance-with-r"
title: "Reproducible Finance with R"
description: |
Exploring reproducible finance with the R statistical
computing environment.
base_url: https://beta.rstudioconnect.com/content/11424/
collections:
posts:
disqus: reproducible-finance-with-r
share: [twitter, linkedin]
subscribe: _subscribe.html
_subscribe.html
<form method='post' action='https://blogtrottr.com'>

Enjoy this blog? Get notified of new posts via email:

<input type='text' name='btr_email' />
<input type='hidden' name='btr_url'
value='https://beta.rstudioconnect.com/content/11424/index.xml'/>
<input type='hidden' name='schedule_type' value='0' />
<input type='submit' value='Subscribe' />
</form>
This example uses the Blogtrottr service to provide an email subscription. You could also use another service or simply include a link to your RSS feed.
The contents of _subscribe.html
will be included in both the sidebar of the main listing page as well as in the footer of articles. Note that relative URLs won’t work in subscription HTML since the content appears at different levels of the site (thus we include the full URL to the RSS feed in the example above).
You can also add arbitrary HTML to the top of the sidebar by including the collections:posts:custom
option within _site.yml
. The custom
option in turn points to an HTML file that will be displayed above the “Subscribe” and “Categories” sections. Unlike the Subscribe HTML, Cutstom HTML is not displayed in article footers. This custom feature can be used to display anything in the sidebar that Distill does not automatically generate. While only one custom file may be defined per collection, the HTML contained within is extremely adaptable to different use cases (even several simultaneously). For example, the below snippets will display an About section on top, and below that a search bar:
_site.yml
name: "reproducible-finance-with-r"
title: "Reproducible Finance with R"
description: |
Exploring reproducible finance with the R statistical
computing environment.
base_url: https://beta.rstudioconnect.com/content/3776/
collections:
posts:
disqus: reproducible-finance-with-r
share: [twitter, linkedin]
custom: _custom.html
_custom.html

About

This blog explores reproducible finance with the
R
statistical computing environment.

Search

<form action="https://duckduckgo.com/">
<input type="text" name="q" placeholder="Search...">
<input type="hidden" name="sites"
value="https://beta.rstudioconnect.com/content/3776/">

</form>

While the custom HTML option inherits general CSS styling from the rest of the Distill blog, by default it does not inherit the sidebar-specific CSS. In order to fully match the rest of the sidebar sections, each section must be nested within a

tag, as seen in the above example. This configuration is intended to provide a good balance between flexibility and ease-of-use.
The example search bar functionality uses the popular DuckDuckGo search engine. After entering search terms and hitting the enter key the user is taken to the search engine’s website and shown relevant search results from the blog. Note that the blog will need to have been recently crawled by the search engine in order for search results to be thorough and up to date. Replacing the HTML snippet’s hard-coded blog URL should be the only modification necessary to begin using this example. Other search engines may be used with further modification. The “Search” button has been left out in this example, but may be uncommented if desired.
When a blog post is published, resource files located alongside the post in its directory are also published. The following files are not published by default:
Files beginning with "."
(hidden files).
Files beginning with "_"
Files known to contain R source code (e.g. ".R"
, ".s"
, ".Rmd"
), R data (e.g. ".RData"
, ".rds"
), or configuration data (e.g. "rsconnect"
,"packrat"
)).
You can override this behavior using a resources
metadata entry for your post, which can specify explicit files to include
or exclude
. For example (some fields excluded for brevity):
---
title: "The Sharpe Ratio"
description: |
In this post we present a classic finance use case using the
PerformanceAnalytics, quantmod, and dygraphs packages.
We'll demonstrate importing stock data, building a portfolio,
and then calculating the Sharpe Ratio.
resources:
exclude:
*.csv
---
After you’ve authored one or more posts you will want to build the entire site before publishing it.
If your Distill website is contained within an RStudio project you can use the Build Website command available in the Build pane to generate the site:
To build a website from the command line, use the rmarkdown::render_site()
function:
library(rmarkdown)
render_site()
There are a variety of options available for making your site available to others, see the article on website publishing for details.
The TensorFlow for R blog uses Distill for R Markdown: https://blogs.rstudio.com/tensorflow/
The source code for the TensorFlow for R blog can be found here: https://github.com/rstudio/tensorflow-blog
An example which reproduces several posts from the Reproducible Finance with R series on the R Views blog can be found here: https://beta.rstudioconnect.com/content/11424/
The source code for the example can be found here: https://github.com/jjallaire/reproducible-finance-with-r
If you see mistakes or want to suggest changes, please create an issue on the source repository.
Text and figures are licensed under Creative Commons Attribution CC BY 4.0. Source code is available at https://github.com/rstudio/distill, unless otherwise noted. The figures that have been reused from other sources don't fall under this license and can be recognized by a note in their caption: "Figure from ...".


convertOriginToViewUrl(origin: Origin): string
Conventionally converts a view model origin to a view url. Used by the ConventionalViewStrategy.
Parameters
origin: Origin
The origin of the view model to convert.
Returns
The view url.


array.pony
class Array[A] is Seq[A]
"""
Contiguous, resizable memory to store elements of type A.
## Usage
Creating an Array of String.
```pony
let array: Array[String] = ["dog"; "cat"; "wombat"]
// array.size() == 3
// array.space() >= 3
```
Creating an empty Array of String, which may hold at least 10 elements before
requesting more space.
```pony
let array = Array(10)
// array.size() == 0
// array.space() >= 10
```
Accessing elements can be done via the `apply(i: USize): this->A ?` method.
The provided index might be out of bounds so `apply` is partial and has to be
called within a try-catch block or inside another partial method.
```pony
let array: Array[String] = ["dog"; "cat"; "wombat"]
let is_second_element_wobat = try
// indexes start from 0, so 1 is the second element
array(1)? == "wombat"
else
false
end
```
Adding and removing elements to and from the end of the Array can be done via
`push` and `pop` methods. You could treat the array as a FIFO queue using
those methods.
```pony
while (array.size() > 0) do
let elem = array.pop()?
// do something with element
end
```
Modifying the Array can be done via `update`, `insert` and `delete` methods
which alter the Array at an arbitrary index, moving elements left (when
deleting) or right (when inserting) as necessary.
Iterating over the elements of an Array can be done using the `values` method.
```pony
for element in array.values() do
// do something with element
end
```
## Memory allocation
Array allocates contiguous memory. It always allocates at least enough memory
space to hold all of its elements. Space is the number of elements the Array
can hold without allocating more memory. The `space()` method returns the
number of elements an Array can hold. The `size()` method returns the number
of elements the Array holds.
Different data types require different amounts of memory. Array[U64] with size
of 6 will take more memory than an Array[U8] of the same size.
When creating an Array or adding more elements will calculate the next power
of 2 of the requested number of elements and allocate that much space, with a
lower bound of space for 8 elements.
Here's a few examples of the space allocated when initialising an Array with
various number of elements:
| size | space |
|------|-------|
| 0 | 0 |
| 1 | 8 |
| 8 | 8 |
| 9 | 16 |
| 16 | 16 |
| 17 | 32 |
Call the `compact()` method to ask the GC to reclaim unused space. There are
no guarantees that the GC will actually reclaim any space.
"""
var _size: USize
var _alloc: USize
var _ptr: Pointer[A]
new create(len: USize = 0) =>
"""
Create an array with zero elements, but space for len elements.
"""
_size = 0
if len > 0 then
_alloc = len.next_pow2().max(len).max(8)
_ptr = Pointer[A]._alloc(_alloc)
else
_alloc = 0
_ptr = Pointer[A]
end
new init(from: A^, len: USize) =>
"""
Create an array of len elements, all initialised to the given value.
"""
_size = len
if len > 0 then
_alloc = len.next_pow2().max(len).max(8)
_ptr = Pointer[A]._alloc(_alloc)
var i: USize = 0
while i < len do
_ptr._update(i, from)
i = i + 1
end
else
_alloc = 0
_ptr = Pointer[A]
end
new from_cpointer(ptr: Pointer[A], len: USize, alloc: USize = 0) =>
"""
Create an array from a C-style pointer and length. The contents are not
copied.
"""
_size = len
if alloc > len then
_alloc = alloc
else
_alloc = len
end
_ptr = ptr
fun _copy_to(
ptr: Pointer[this->A!],
copy_len: USize,
from_offset: USize = 0,
to_offset: USize = 0)
=>
"""
Copy copy_len elements from this to that at specified offsets.
"""
_ptr._offset(from_offset)._copy_to(ptr._offset(to_offset), copy_len)
fun cpointer(offset: USize = 0): Pointer[A] tag =>
"""
Return the underlying C-style pointer.
"""
_ptr._offset(offset)
fun size(): USize =>
"""
The number of elements in the array.
"""
_size
fun space(): USize =>
"""
The available space in the array.
"""
_alloc
fun ref reserve(len: USize) =>
"""
Reserve space for len elements, including whatever elements are already in
the array. Array space grows geometrically.
"""
if _alloc < len then
_alloc = len.next_pow2().max(len).max(8)
_ptr = _ptr._realloc(_alloc)
end
fun box _element_size(): USize =>
"""
Element size in bytes for an element.
"""
_ptr._element_size()
fun ref compact() =>
"""
Try to remove unused space, making it available for garbage collection. The
request may be ignored.
"""
if _size <= (512 / _ptr._element_size()) then
if _size.next_pow2() != _alloc.next_pow2() then
_alloc = _size.next_pow2()
let old_ptr = _ptr = Pointer[A]._alloc(_alloc)
old_ptr._copy_to(_ptr._convert[A!](), _size)
end
elseif _size < _alloc then
_alloc = _size
let old_ptr = _ptr = Pointer[A]._alloc(_alloc)
old_ptr._copy_to(_ptr._convert[A!](), _size)
end
fun ref undefined[B: (A & Real[B] val & Number) = A](len: USize) =>
"""
Resize to len elements, populating previously empty elements with random
memory. This is only allowed for an array of numbers.
"""
reserve(len)
_size = len
fun box read_u8[B: (A & Real[B] val & U8) = A](offset: USize): U8 ? =>
"""
Reads a U8 from offset. This is only allowed for an array of U8s.
"""
if offset < _size then
_ptr._offset(offset)._convert[U8]()._apply(0)
else
error
end
fun box read_u16[B: (A & Real[B] val & U8) = A](offset: USize): U16 ? =>
"""
Reads a U16 from offset. This is only allowed for an array of U8s.
"""
let u16_bytes = U16(0).bytewidth()
if (offset + u16_bytes) <= _size then
_ptr._offset(offset)._convert[U16]()._apply(0)
else
error
end
fun box read_u32[B: (A & Real[B] val & U8) = A](offset: USize): U32 ? =>
"""
Reads a U32 from offset. This is only allowed for an array of U8s.
"""
let u32_bytes = U32(0).bytewidth()
if (offset + u32_bytes) <= _size then
_ptr._offset(offset)._convert[U32]()._apply(0)
else
error
end
fun box read_u64[B: (A & Real[B] val & U8) = A](offset: USize): U64 ? =>
"""
Reads a U64 from offset. This is only allowed for an array of U8s.
"""
let u64_bytes = U64(0).bytewidth()
if (offset + u64_bytes) <= _size then
_ptr._offset(offset)._convert[U64]()._apply(0)
else
error
end
fun box read_u128[B: (A & Real[B] val & U8) = A](offset: USize): U128 ? =>
"""
Reads a U128 from offset. This is only allowed for an array of U8s.
"""
let u128_bytes = U128(0).bytewidth()
if (offset + u128_bytes) <= _size then
_ptr._offset(offset)._convert[U128]()._apply(0)
else
error
end
fun apply(i: USize): this->A ? =>
"""
Get the i-th element, raising an error if the index is out of bounds.
"""
if i < _size then
_ptr._apply(i)
else
error
end
fun ref update_u8[B: (A & Real[B] val & U8) = A](offset: USize, value: U8): U8 ? =>
"""
Write a U8 at offset. This is only allowed for an array of U8s.
"""
if offset < _size then
_ptr._offset(offset)._convert[U8]()._update(0, value)
else
error
end
fun ref update_u16[B: (A & Real[B] val & U8) = A](offset: USize, value: U16): U16 ? =>
"""
Write a U16 at offset. This is only allowed for an array of U8s.
"""
let u16_bytes = U16(0).bytewidth()
if (offset + u16_bytes) <= _size then
_ptr._offset(offset)._convert[U16]()._update(0, value)
else
error
end
fun ref update_u32[B: (A & Real[B] val & U8) = A](offset: USize, value: U32): U32 ? =>
"""
Write a U32 at offset. This is only allowed for an array of U8s.
"""
let u32_bytes = U32(0).bytewidth()
if (offset + u32_bytes) <= _size then
_ptr._offset(offset)._convert[U32]()._update(0, value)
else
error
end
fun ref update_u64[B: (A & Real[B] val & U8) = A](offset: USize, value: U64): U64 ? =>
"""
Write a U64 at offset. This is only allowed for an array of U8s.
"""
let u64_bytes = U64(0).bytewidth()
if (offset + u64_bytes) <= _size then
_ptr._offset(offset)._convert[U64]()._update(0, value)
else
error
end
fun ref update_u128[B: (A & Real[B] val & U8) = A](offset: USize, value: U128): U128 ? =>
"""
Write a U128 at offset. This is only allowed for an array of U8s.
"""
let u128_bytes = U128(0).bytewidth()
if (offset + u128_bytes) <= _size then
_ptr._offset(offset)._convert[U128]()._update(0, value)
else
error
end
fun ref update(i: USize, value: A): A^ ? =>
"""
Change the i-th element, raising an error if the index is out of bounds.
"""
if i < _size then
_ptr._update(i, consume value)
else
error
end
fun ref insert(i: USize, value: A) ? =>
"""
Insert an element into the array. Elements after this are moved up by one
index, extending the array.
An out of bounds index raises an error.
"""
if i <= _size then
reserve(_size + 1)
_ptr._offset(i)._insert(1, _size - i)
_ptr._update(i, consume value)
_size = _size + 1
else
error
end
fun ref delete(i: USize): A^ ? =>
"""
Delete an element from the array. Elements after this are moved down by one
index, compacting the array.
An out of bounds index raises an error.
The deleted element is returned.
"""
if i < _size then
_size = _size - 1
_ptr._offset(i)._delete(1, _size - i)
else
error
end
fun ref truncate(len: USize) =>
"""
Truncate an array to the given length, discarding excess elements. If the
array is already smaller than len, do nothing.
"""
_size = _size.min(len)
fun ref trim_in_place(from: USize = 0, to: USize = -1) =>
"""
Trim the array to a portion of itself, covering `from` until `to`.
Unlike slice, the operation does not allocate a new array nor copy elements.
"""
let last = _size.min(to)
let offset = last.min(from)
let size' = last - offset
// use the new size' for alloc if we're not including the last used byte
// from the original data and only include the extra allocated bytes if
// we're including the last byte.
_alloc = if last == _size then _alloc - offset else size' end
_size = size'
// if _alloc == 0 then we've trimmed all the memory originally allocated.
// if we do _ptr._offset, we will spill into memory not allocated/owned
// by this array and could potentially cause a segfault if we cross
// a pagemap boundary into a pagemap address that hasn't been allocated
// yet when `reserve` is called next.
if _alloc == 0 then
_ptr = Pointer[A]
else
_ptr = _ptr._offset(offset)
end
fun val trim(from: USize = 0, to: USize = -1): Array[A] val =>
"""
Return a shared portion of this array, covering `from` until `to`.
Both the original and the new array are immutable, as they share memory.
The operation does not allocate a new array pointer nor copy elements.
"""
let last = _size.min(to)
let offset = last.min(from)
recover
let size' = last - offset
// use the new size' for alloc if we're not including the last used byte
// from the original data and only include the extra allocated bytes if
// we're including the last byte.
let alloc = if last == _size then _alloc - offset else size' end
if size' > 0 then
from_cpointer(_ptr._offset(offset)._unsafe(), size', alloc)
else
create()
end
end
fun iso chop(split_point: USize): (Array[A] iso^, Array[A] iso^) =>
"""
Chops the array in half at the split point requested and returns both
the left and right portions. The original array is trimmed in place and
returned as the right portion. If the split point is larger than the
array, the left portion is the original array and the right portion
is a new empty array.
Both arrays are isolated and mutable, as they do not share memory.
The operation does not allocate a new array pointer nor copy elements.
"""
let start_ptr = _ptr
let size' = _size.min(split_point)
let alloc = if size' == _size then _alloc else split_point end
trim_in_place(split_point)
let left = recover
if size' > 0 then
from_cpointer(start_ptr._unsafe(), size', alloc)
else
create()
end
end
(consume left, consume this)
fun ref copy_from[B: (A & Real[B] val & U8) = A](
src: Array[U8] box,
src_idx: USize,
dst_idx: USize,
len: USize)
=>
"""
Copy len elements from src(src_idx) to this(dst_idx).
Only works for Array[U8].
"""
reserve(dst_idx + len)
src._ptr._offset(src_idx)._copy_to(_ptr._convert[U8]()._offset(dst_idx), len)
if _size < (dst_idx + len) then
_size = dst_idx + len
end
fun copy_to(
dst: Array[this->A!],
src_idx: USize,
dst_idx: USize,
len: USize)
=>
"""
Copy len elements from this(src_idx) to dst(dst_idx).
"""
dst.reserve(dst_idx + len)
_ptr._offset(src_idx)._copy_to(dst._ptr._offset(dst_idx), len)
if dst._size < (dst_idx + len) then
dst._size = dst_idx + len
end
fun ref remove(i: USize, n: USize) =>
"""
Remove n elements from the array, beginning at index i.
"""
if i < _size then
let count = n.min(_size - i)
_size = _size - count
_ptr._offset(i)._delete(count, _size - i)
end
fun ref clear() =>
"""
Remove all elements from the array.
"""
_size = 0
fun ref push_u8[B: (A & Real[B] val & U8) = A](value: U8) =>
"""
Add a U8 to the end of the array. This is only allowed for an array of U8s.
"""
let u8_bytes = U8(0).bytewidth()
reserve(_size + u8_bytes)
_ptr._offset(_size)._convert[U8]()._update(0, value)
_size = _size + u8_bytes
fun ref push_u16[B: (A & Real[B] val & U8) = A](value: U16) =>
"""
Add a U16 to the end of the array. This is only allowed for an array of U8s.
"""
let u16_bytes = U16(0).bytewidth()
reserve(_size + u16_bytes)
_ptr._offset(_size)._convert[U16]()._update(0, value)
_size = _size + u16_bytes
fun ref push_u32[B: (A & Real[B] val & U8) = A](value: U32) =>
"""
Add a U32 to the end of the array. This is only allowed for an array of U8s.
"""
let u32_bytes = U32(0).bytewidth()
reserve(_size + u32_bytes)
_ptr._offset(_size)._convert[U32]()._update(0, value)
_size = _size + u32_bytes
fun ref push_u64[B: (A & Real[B] val & U8) = A](value: U64) =>
"""
Add a U64 to the end of the array. This is only allowed for an array of U8s.
"""
let u64_bytes = U64(0).bytewidth()
reserve(_size + u64_bytes)
_ptr._offset(_size)._convert[U64]()._update(0, value)
_size = _size + u64_bytes
fun ref push_u128[B: (A & Real[B] val & U8) = A](value: U128) =>
"""
Add a U128 to the end of the array. This is only allowed for an array of U8s.
"""
let u128_bytes = U128(0).bytewidth()
reserve(_size + u128_bytes)
_ptr._offset(_size)._convert[U128]()._update(0, value)
_size = _size + u128_bytes
fun ref push(value: A) =>
"""
Add an element to the end of the array.
"""
reserve(_size + 1)
_ptr._update(_size, consume value)
_size = _size + 1
fun ref pop(): A^ ? =>
"""
Remove an element from the end of the array.
The removed element is returned.
"""
delete(_size - 1)?
fun ref unshift(value: A) =>
"""
Add an element to the beginning of the array.
"""
try
insert(0, consume value)?
end
fun ref shift(): A^ ? =>
"""
Remove an element from the beginning of the array.
The removed element is returned.
"""
delete(0)?
fun ref append(
seq: (ReadSeq[A] & ReadElement[A^]),
offset: USize = 0,
len: USize = -1)
=>
"""
Append the elements from a sequence, starting from the given offset.
"""
if offset >= seq.size() then
return
end
let copy_len = len.min(seq.size() - offset)
reserve(_size + copy_len)
var n = USize(0)
try
while n < copy_len do
_ptr._update(_size + n, seq(offset + n)?)
n = n + 1
end
end
_size = _size + n
fun ref concat(iter: Iterator[A^], offset: USize = 0, len: USize = -1) =>
"""
Add len iterated elements to the end of the array, starting from the given
offset.
"""
var n = USize(0)
try
while n < offset do
if iter.has_next() then
iter.next()?
else
return
end
n = n + 1
end
end
n = 0
// If a concrete len is specified, we take the caller at their word
// and reserve that much space, even though we can't verify that the
// iterator actually has that many elements available. Reserving ahead
// of time lets us take a fast path of direct pointer access.
if len != -1 then
reserve(_size + len)
try
while n < len do
if iter.has_next() then
_ptr._update(_size + n, iter.next()?)
else
break
end
n = n + 1
end
end
_size = _size + n
else
try
while n < len do
if iter.has_next() then
push(iter.next()?)
else
break
end
n = n + 1
end
end
end
fun find(
value: A!,
offset: USize = 0,
nth: USize = 0,
predicate: {(box->A!, box->A!): Bool} val = {(l, r) => l is r })
: USize ?
=>
"""
Find the `nth` appearance of `value` from the beginning of the array,
starting at `offset` and examining higher indices, and using the supplied
`predicate` for comparisons. Returns the index of the value, or raise an
error if the value isn't present.
By default, the search starts at the first element of the array, returns
the first instance of `value` found, and uses object identity for
comparison.
"""
var i = offset
var n = USize(0)
while i < _size do
if predicate(_ptr._apply(i), value) then
if n == nth then
return i
end
n = n + 1
end
i = i + 1
end
error
fun contains(
value: A!,
predicate: {(box->A!, box->A!): Bool} val =
{(l: box->A!, r: box->A!): Bool => l is r })
: Bool
=>
"""
Returns true if the array contains `value`, false otherwise.
The default predicate checks for matches by identity. To search for matches
by structural equality, pass an object literal such as `{(l, r) => l == r}`.
"""
var i = USize(0)
while i < _size do
if predicate(_ptr._apply(i), value) then
return true
end
i = i + 1
end
false
fun rfind(
value: A!,
offset: USize = -1,
nth: USize = 0,
predicate: {(box->A!, box->A!): Bool} val =
{(l: box->A!, r: box->A!): Bool => l is r })
: USize ?
=>
"""
Find the `nth` appearance of `value` from the end of the array, starting at
`offset` and examining lower indices, and using the supplied `predicate` for
comparisons. Returns the index of the value, or raise an error if the value
isn't present.
By default, the search starts at the last element of the array, returns the
first instance of `value` found, and uses object identity for comparison.
"""
if _size > 0 then
var i = if offset >= _size then _size - 1 else offset end
var n = USize(0)
repeat
if predicate(_ptr._apply(i), value) then
if n == nth then
return i
end
n = n + 1
end
until (i = i - 1) == 0
end
end
error
fun clone(): Array[this->A!]^ =>
"""
Clone the array.
The new array contains references to the same elements that the old array
contains, the elements themselves are not cloned.
"""
let out = Array[this->A!](_size)
_ptr._copy_to(out._ptr, _size)
out._size = _size
out
fun slice(
from: USize = 0,
to: USize = -1,
step: USize = 1)
: Array[this->A!]^
=>
"""
Create a new array that is a clone of a portion of this array. The range is
exclusive and saturated.
The new array contains references to the same elements that the old array
contains, the elements themselves are not cloned.
"""
let out = Array[this->A!]
let last = _size.min(to)
let len = last - from
if (last > from) and (step > 0) then
out.reserve((len + (step - 1)) / step)
if step == 1 then
copy_to(out, from, 0, len)
else
try
var i = from
while i < last do
out.push(this(i)?)
i = i + step
end
end
end
end
out
fun permute(indices: Iterator[USize]): Array[this->A!]^ ? =>
"""
Create a new array with the elements permuted.
Permute to an arbitrary order that may include duplicates. An out of bounds
index raises an error.
The new array contains references to the same elements that the old array
contains, the elements themselves are not copied.
"""
let out = Array[this->A!]
for i in indices do
out.push(this(i)?)
end
out
fun reverse(): Array[this->A!]^ =>
"""
Create a new array with the elements in reverse order.
The new array contains references to the same elements that the old array
contains, the elements themselves are not copied.
"""
clone() .> reverse_in_place()
fun ref reverse_in_place() =>
"""
Reverse the array in place.
"""
if _size > 1 then
var i: USize = 0
var j = _size - 1
while i < j do
let x = _ptr._apply(i)
_ptr._update(i, _ptr._apply(j))
_ptr._update(j, x)
i = i + 1
j = j - 1
end
end
fun ref swap_elements(i: USize, j: USize) ? =>
"""
Swap the element at index i with the element at index j.
If either i or j are out of bounds, an error is raised.
"""
if (i >= _size) or (j >= _size) then error end
let x = _ptr._apply(i)
_ptr._update(i, _ptr._apply(j))
_ptr._update(j, consume x)
fun keys(): ArrayKeys[A, this->Array[A]]^ =>
"""
Return an iterator over the indices in the array.
"""
ArrayKeys[A, this->Array[A]](this)
fun values(): ArrayValues[A, this->Array[A]]^ =>
"""
Return an iterator over the values in the array.
"""
ArrayValues[A, this->Array[A]](this)
fun pairs(): ArrayPairs[A, this->Array[A]]^ =>
"""
Return an iterator over the (index, value) pairs in the array.
"""
ArrayPairs[A, this->Array[A]](this)
class ArrayKeys[A, B: Array[A] #read] is Iterator[USize]
let _array: B
var _i: USize
new create(array: B) =>
_array = array
_i = 0
fun has_next(): Bool =>
_i < _array.size()
fun ref next(): USize =>
if _i < _array.size() then
_i = _i + 1
else
_i
end
class ArrayValues[A, B: Array[A] #read] is Iterator[B->A]
let _array: B
var _i: USize
new create(array: B) =>
_array = array
_i = 0
fun has_next(): Bool =>
_i < _array.size()
fun ref next(): B->A ? =>
_array(_i = _i + 1)?
fun ref rewind(): ArrayValues[A, B] =>
_i = 0
this
class ArrayPairs[A, B: Array[A] #read] is Iterator[(USize, B->A)]
let _array: B
var _i: USize
new create(array: B) =>
_array = array
_i = 0
fun has_next(): Bool =>
_i < _array.size()
fun ref next(): (USize, B->A) ? =>
(_i, _array(_i = _i + 1)?)


--- layout: default title: "404: Page not found" ---
What the heck. Where are YOU going? Head back home to try and find yourself.


SmartHelp
SmartHelp is a holistic solution for Emergency Services in Norway. In case of an accident the Services know where you are and how they should help you.
Concerned about privacy? Keep calm. SmartHelp implements 'Privacy by Design' approach and has a fully end-to-end encrypted channel to exchange messages between parties and only those parties are able to read the messages.
The solution consists of two native mobile apps (iOS & Android), Emergency Services web panel and the backend. Bright Inventions takes part in the whole process from day 0, starting from ideas, through full-stack implementation to deployment and maintenance.
- iOS native application: ReactiveCocoa
- Android native application: Kotlin, RxAndroid, Dagger, Retrofit
- Web: AngularJS, Socket.io, Leaflet
- Backend: Node.js, Express, PostgreSQL
- Git, TeamCity, Docker, AWS


Utils
Static Method Summary
| Static Public Methods | ||
| public static |
angle(start: *, end: *): * Gets the angle between point1 -> start and 0,0 -> point2 (-pi to pi) |
|
| public static |
angle2pi(start: *, end: *): * shifts angle to be 0 to 2pi |
|
| public static |
closestPointOnLine(point: *, start: *, end: *): * Gets the projection of a point onto a line. |
|
| public static |
cycle(arr: *, shift: *): * Shift the items in an array by shift (positive integer) |
|
| public static |
distance(start: *, end: *): * Gets the distance of two points. |
|
| public static |
forEach(array: *, action: *) |
|
| public static |
forEachIndexed(array: *, action: *) |
|
| public static |
guide(): * Creates a Guide. |
|
| public static |
Checks if value is in array |
|
| public static |
isClockwise(points: *): * Checks if an array of points is clockwise. |
|
| public static |
lineLineIntersect(lineAStart: *, lineAEnd: *, lineBStart: *, lineBEnd: *): * |
|
| public static |
lineLineIntersectPoint(aStart: *, aEnd: *, bStart: *, bEnd: *): * |
|
| public static |
linePolygonIntersect(point: *, point2: *, corners: *): boolean Corners is an array of points with x,y attributes |
|
| public static |
map(array: *, func: *): * |
|
| public static |
pointDistanceFromLine(point: *, start: *, end: *): * Determines the distance of a point from a line. |
|
| public static |
pointInPolygon(corners: *, startX: *, startY: *): * |
|
| public static |
pointInPolygon2(corners: *, startX: *, startY: *): * |
|
| public static |
polygonInsidePolygon(insideCorners: *, outsideCorners: *, start: *): boolean Checks if all corners of insideCorners are inside the polygon described by outsideCorners |
|
| public static |
polygonOutsidePolygon(insideCorners: *, outsideCorners: *, start: *): boolean Checks if any corners of firstCorners is inside the polygon described by secondCorners |
|
| public static |
polygonPolygonIntersect(firstCorners: *, secondCorners: *): boolean both arguments are arrays of corners with x,y attributes |
|
| public static |
removeIf(array: *, func: *): * Remove elements in array if func(element) returns true |
|
| public static |
removeValue(array: *, value: *) Remove value from array, if it is present |
|
| public static |
subtract(array: *, subArray: *): * Subtracts the elements in subArray from array |
|
| public static |
unique(arr: *, hashFunc: *): * Returns in the unique elemnts in arr |
Static Public Methods
public static angle(start: *, end: *): * source
Gets the angle between point1 -> start and 0,0 -> point2 (-pi to pi)
Params:
| Name | Type | Attribute | Description |
| start | * | ||
| end | * |
Return:
| * | The angle. |
public static angle2pi(start: *, end: *): * source
shifts angle to be 0 to 2pi
Params:
| Name | Type | Attribute | Description |
| start | * | ||
| end | * |
Return:
| * |
public static closestPointOnLine(point: *, start: *, end: *): * source
Gets the projection of a point onto a line.
Params:
| Name | Type | Attribute | Description |
| point | * | the point |
|
| start | * | the starting coordinates of the line as THREE.Vector2 |
|
| end | * | the ending coordinates of the line as THREE.Vector2 |
Return:
| * | The point as THREE.Vector2. |
public static cycle(arr: *, shift: *): * source
Shift the items in an array by shift (positive integer)
Params:
| Name | Type | Attribute | Description |
| arr | * | ||
| shift | * |
Return:
| * |
public static distance(start: *, end: *): * source
Gets the distance of two points.
Params:
| Name | Type | Attribute | Description |
| start | * | the starting coordinate of the line as Vector2 |
|
| end | * | the ending coordinate of the line as Vector2 |
Return:
| * | The distance. |
public static forEach(array: *, action: *) source
Params:
| Name | Type | Attribute | Description |
| array | * | ||
| action | * |
public static forEachIndexed(array: *, action: *) source
Params:
| Name | Type | Attribute | Description |
| array | * | ||
| action | * |
public static hasValue(array: *, value: *): boolean source
Checks if value is in array
Params:
| Name | Type | Attribute | Description |
| array | * | ||
| value | * |
public static isClockwise(points: *): * source
Checks if an array of points is clockwise.
Params:
| Name | Type | Attribute | Description |
| points | * | Is array of points with x,y attributes |
Return:
| * | True if clockwise. |
public static lineLineIntersect(lineAStart: *, lineAEnd: *, lineBStart: *, lineBEnd: *): * source
Params:
| Name | Type | Attribute | Description |
| lineAStart | * | ||
| lineAEnd | * | ||
| lineBStart | * | ||
| lineBEnd | * |
Return:
| * |
public static lineLineIntersectPoint(aStart: *, aEnd: *, bStart: *, bEnd: *): * source
Params:
| Name | Type | Attribute | Description |
| aStart | * | ||
| aEnd | * | ||
| bStart | * | ||
| bEnd | * |
Return:
| * |
public static linePolygonIntersect(point: *, point2: *, corners: *): boolean source
Corners is an array of points with x,y attributes
Params:
| Name | Type | Attribute | Description |
| point | * | ||
| point2 | * | ||
| corners | * |
public static map(array: *, func: *): * source
Params:
| Name | Type | Attribute | Description |
| array | * | ||
| func | * |
Return:
| * |
public static pointDistanceFromLine(point: *, start: *, end: *): * source
Determines the distance of a point from a line.
Params:
| Name | Type | Attribute | Description |
| point | * | The Point coordinates as THREE.Vector2 |
|
| start | * | The starting coordinates of the line as THREE.Vector2 |
|
| end | * | The ending coordinates of the line as THREE.Vector2 |
Return:
| * | The distance value (number). |
public static pointInPolygon(corners: *, startX: *, startY: *): * source
Params:
| Name | Type | Attribute | Description |
| corners | * | Is an array of points with x,y attributes |
|
| startX | * | X start coord for raycast |
|
| startY | * | Y start coord for raycast |
Return:
| * |
public static pointInPolygon2(corners: *, startX: *, startY: *): * source
Params:
| Name | Type | Attribute | Description |
| corners | * | Is an array of points with x,y attributes |
|
| startX | * | X start coord for raycast |
|
| startY | * | Y start coord for raycast |
Return:
| * |
public static polygonInsidePolygon(insideCorners: *, outsideCorners: *, start: *): boolean source
Checks if all corners of insideCorners are inside the polygon described by outsideCorners
Params:
| Name | Type | Attribute | Description |
| insideCorners | * | ||
| outsideCorners | * | ||
| start | * |
public static polygonOutsidePolygon(insideCorners: *, outsideCorners: *, start: *): boolean source
Checks if any corners of firstCorners is inside the polygon described by secondCorners
Params:
| Name | Type | Attribute | Description |
| insideCorners | * | ||
| outsideCorners | * | ||
| start | * |
public static polygonPolygonIntersect(firstCorners: *, secondCorners: *): boolean source
both arguments are arrays of corners with x,y attributes
Params:
| Name | Type | Attribute | Description |
| firstCorners | * | ||
| secondCorners | * |
public static removeIf(array: *, func: *): * source
Remove elements in array if func(element) returns true
Params:
| Name | Type | Attribute | Description |
| array | * | ||
| func | * |
Return:
| * |
public static removeValue(array: *, value: *) source
Remove value from array, if it is present
Params:
| Name | Type | Attribute | Description |
| array | * | ||
| value | * |
public static subtract(array: *, subArray: *): * source
Subtracts the elements in subArray from array
Params:
| Name | Type | Attribute | Description |
| array | * | ||
| subArray | * |
Return:
| * |
public static unique(arr: *, hashFunc: *): * source
Returns in the unique elemnts in arr
Params:
| Name | Type | Attribute | Description |
| arr | * | ||
| hashFunc | * |
Return:
| * |


"While it is always best to believe in oneself, a little help from others can be a great blessing."
Uncle Iroh is a firebending master from the Fire Nation, who's main objective is to guide his nephew Zuko. In the show, Avatar the Last Airbender, he consistently uses his wisdom and age to help others with their problems. Though a well respected bender, he is also known for his love of tea, depicted in the image above.
A snippet of Iroh's part in my personal favorite episode of Avatar.


BetterBatch is meant as a replacement for batch files. It has the following advantages over batch files:
BetterBatch’s sweet spot is for things that can be done by a batch command and need to be maintained over time by different people who may not have the same knowledge of scripting nor want the extra complexity of scripts (which can be more difficult to maintain).
The following example checks if a file exists and if it doesn’t exist copy from the filepath specified on the command line to that location.
First of all enter the following text into a new text file named “copyfile.bb”
- set file_to_check=<shell.temp>\testing_betterbatch.txt
- if not exists <file_to_check>:
- copy <file_to_copy> <file_to_check>
Now execute it by running the following at the DOS prompt
bbrun.py copyfile.bb file_to_copy=autoexec.bat
BetterBatch does not have to be installed as a Python Package, just download, unzip and run bbrun.py.
Note - it does have a requirement on PyYAML (http://pyyaml.org/) If you have Setuptools you can use the following command:
easy_install -U pyyaml
BetterBatch can also be installed as a Python module (if you want to import and use BetterBatch functionality in python scripts). Use easy_install.py or your favourite python package installation method.
If you want to associate the BetterBatch extension ”.bb” with bbrun.py then you can run:
associate_bb_filetype.py
This expects that python is on the path - but you can update it to your python installation if python is not on the path.
Script files are based on YAML, but don’t worry too much about that! Just be careful of the following rules:
- Tab characters should be avoided (BetterBatch actually will replace them and print a warning when it loads a file with tab characters)
- Start each command with a ‘- ‘
Note - while a YAML parser is being used to parse the file, some things which would fail if parsing as YAML directly will pass with betterbatch. This is because pre-processing is done on the contents of the file before it is passed to the YAML parser.
BetterBatch script files are made up of statements.
A simple statement starts with a dash (-), whitespace and then the command to execute.
For example the typical first programming example - Hello World! - is:
- echo Hello World!
Unless a statement is one of the other types (see below) it is an Command Statement
If the executable statement is not a built-in command then it will be executed in the shell, just as if you typed it at the command line.
Note - by default BetterBatch captures the output of the command (output and error output) and adds it to the logfile (if set). It will also by default stop execution of the script if the command returns an error value (return code other than zero(0)). This behaviour can be modified by qualifiers.
Changed in version 1.2.0: Added {*nocapture*} qualifier and made {*echo*} and {*ui*} qualifiers the same.
Example:
- set variable_name = variable value
Variable definitions can include other variables or executable sections. For example:
- set variable_name = The value of <variable> and output of {{{executable section}}}
By default any variable you reference and any executable sections will be executed when the variable definition is encountered in the script. You can specify that variables and executable sections should not be replaced until the variable is actually used by specifing the {*delayed*} qualifier for example:
- set later_var = This <variable> and {{{executable section}}} will be replaced only when used {*delayed*}
The {*hidden*} qualifier can be used on passwords and other sensitive data so that it will not be put into the log file or output on the command line. Please note that the support for this may not be complete - so you still need to be careful with sensitive data.
If you need to include ‘<’ or ‘>’ characters in the variable value - you need to escape them. This is done by doubling them.
Example:
- echo Running your script
The message will be output to the screen and to the log file.
You can optionaly provide the {as_error} or {as_warning} qualifiers to have the text output as an error or warning respectively.
Example:
- include path\to\includefile.bb
The steps in the file will be subsituted for the include statement as if they were defined in the including file.
You can mark an include as optional by using the {*optional*} qualifier.
An include marked as optional will be used if it exists, but otherwise will be ignored (a log file message will output if it was found or not).
Example:
- logfile path\to\logfile.bb
If a previous logfile statement was given then that logfile will be closed (if it can be) and all logging information will be written to the new logfile.
These statements allow you to branch based on conditions that you specify.
Example:
- if exists required_files\file.abc:
and exists required_files\file.zxy:
- echo Great - both files exist
else:
- echo OH! - one of the files does not exist
“and” or “or” can be used with the “if” part of the statement. You cannot mix “and” and “or” in the same if statement (it should be consistently “or” or consistently “and” in a single statement).
CAREFUL - the first letter of the if/and/or/else all have to line up vertically - or the statement will not be parsed correctly.
For example the following will actually be wrong:
- if not defined <var>:
or not exists required_files\file.zxy:
- end 1, Requirements not met - please fix
else:
- echo Lets continue then
The or and the else are not lined up with the if statement.
The construct defined variable_name is a condition worth mentioning in more detail e.g.
- if defined build:
- echo Value for build is <build>
else:
- end 1, The BUILD variable is not set - please specify a value
This is the best way of using optional variables. (often passed on the command line by passing var_name=var_value.
For statements iterate over a list of items. Internally it uses uses the newline character n to delimit the items. The split command can be easily used to convert a list of values into the format required for the for statement.
The format of the step is:
- for LOOP_VARIABLE in INPUT:
- exectute steps
- which optionally using <LOOP_VARIABLE>
The block of statements is executed once per line in the input, so for example the general case of iterating over files in a directory that match a pattern:
- for file in {{{dir <__working_dir__>/b *.txt}}}:
- echo working on "<file>"
- Curl - upload <file> to site..
Another example could be the following:
- set components = Server,Client,Database,Registry
# split the components variable on comma
- for component in {{{ split <components> {*,*} }}}:
- echo working on Component "<component>"
- Do work on <component>
Many steps can often take quite a bit of time to complete, and you may want other actions to start before it the long runnig step has finished.
Obviously these steps should not depend on each other.
One good example is downloading separate files, downloading can take quite a while and you may want to start many downloading/uploading processes at the same time.
In batch files you can acheive this by preceding the call to the tools with “start” but then you will not be able to easily check return status nor retrieve the tool’s output, etc.
In a BetterBatch script you can still use “Start” if you want - but much better is to put the steps you want to execute in parallel in a “parallel” block:
- parallel:
- cUrl.exe big_file....
- cUrl.exe another_big_file....
- cUrl.exe and lots of small files 1
- cUrl.exe and lots of small files 2
- cUrl.exe etc
As the order of execution of the items in the parallel section is not defined you should never rely on one starting/finishing before another will start/finish. Also ONLY command steps are allowed (i.e. no Variable Definitions, logfile, include, for or if statements are allowed.
You can define a function that you can call later at anytime. Here is a an example:
- function PrintArgs (arg1, arg2, arg3=123, arg4=This arg):
- echo <arg1>, <arg2>, <arg3>, <arg4>
- return <arg1>_<arg2> (<arg3> - <arg4>)
In the above function definition the function name is PrintArgs, it takes 4 arguments arg1, arg2, arg3 and arg4. Arguments arg3 and arg4 have default arguments “123” and “This arg” respectively. The function call will have to pass values for arg1, arg2 but passing values for arguments arg3 and arg4 is optional. If no option is passed then the default values will be used.
Return values will be available to the calling code.
You can call functions in the following way:
- call PrintArgs (here, there, arg4 = some value)
Matching this against the example function defintion above arg1 will have value here, arg2 will have value there, arg3 will have value 123 (the default value), arg4 will have value some value.
To assign the return value (if any!) to a variable you can use the executable section syntax:
- set dll_directory = {{{ call GetDLLDirectory() }}}
Changed in version 1.2.0: allowed function arguments to contain spaces.
You can reference any defined variable by using <variable_reference>.
The value of the variable will replace the variable reference.
If you need to have < or > in your script - then you double them. e.g.
Executable sections can be used in variable definition or executable statements. The section will be replaced from the output from the section after executing it.
Examples:
- set file_contents = {{{type c:\autoexec.bat }}}
- echo {{{ replace <file_contents> {*a*} {*b*} }}}
- file_list {{{ dir c:\ /b }}}
Executable sections can call any built-in command or external command. Executable sections can reference variables
For example if you runn the following command:
c:\Program Files\betterbatch> bbrun.py c:\MyProject\MakeBuild.bb
then the values of the special variables will be:
__script_dir__ c:\MyProject
__script_filename__ MakeBuild.bb
__working_dir__ c:\Program Files\betterbatch
Shell environment variables are pre-fixed with ‘shell.’ to avoid conflicts with any internal variables.
For example if your script expects the user to pass a ‘buildnumber’ value to the script, but the environment has a ‘buildnumber’ variable defined. Without the pre-fix the environment variable would have been used silently if no value was passed to the script. The shell prefix makes it clearer that the BetterBatch script is going to use the environment value.


Bootstrap and Masonry
Integrate Masonry with the Bootstrap grid system and cards component.
Masonry is not included in Bootstrap. Add it by including the JavaScript plugin manually, or using a CDN like so:
<script<EMAIL_ADDRESS>integrity="sha384-GNFwBvfVxBkLMJpYMOABq3c+d3KnQxudP/mGPkzpZSTYykLBNsZEnG2D9G/X/+7D" crossorigin="anonymous" async></script>
By adding data-masonry='{"percentPosition": true }'
to the .row
wrapper, we can combine the powers of Bootstrap's responsive grid and Masonry's positioning.
Card title that wraps to a new line
This is a longer card with supporting text below as a natural lead-in to additional content. This content is a little bit longer.
Card title
This card has supporting text below as a natural lead-in to additional content.
Last updated 3 mins ago
Card title
This card has a regular title and short paragraph of text below it.
Last updated 3 mins ago
Card title
This is another card with title and supporting text below. This card has some additional content to make it slightly taller overall.
Last updated 3 mins ago


We built this visualization as the final project of CSC ST395 Data Visualization class. We applied a natural language processing model (Word2vec) on wikipedia corpus (as of March 20th 2017) which computes a similarity score between any two words in the vocabularies.
This force graph translates the numerics between any two words into a network to better visualize the relationship amongst multiple words. While each node represents a word, each word connects to other words which share the most similar context. Several filter options are avaible to customize the visualization. For the purpose of this demo, we used 10 pre-generated word list. The actual model allows users to search for any word that appears in Wikipedia corpus.
We would like to thank the instructor of the course Professor Charlie Curtsinger and the classmates for their support and feedback. We would also like to thank DASIL for displaying our work. If you have questions or suggestions, please reach out to us!
An Hoang<EMAIL_ADDRESS>Minh N Tran<EMAIL_ADDRESS>Jinlin He<EMAIL_ADDRESS>Jun Taek Lee<EMAIL_ADDRESS>Citation: 1. Wikipedia Downloads at https://dumps.wikimedia.org/ 2. gensim package at https://radimrehurek.com/gensim/index.html3. Force graph https://bl.ocks.org/mbostock/4062045


Hi there! I'm James! A Front-End Web Developer currently honing my craft at HackerYou in Toronto, Ontario, Canada.
I specialize in creating beautifully responsive & dynamic sites for my clients using HTML5, CSS3 and JavaScript.
In my previous life I was a touring musician & restaurant manager. When I'm not hunched over my computer coding websites or learning new skills, I enjoy traveling, eating, laughing and living life!
Beyond design & development, James went out of his way to understand my project and present the data in a logical manner
— 'Dewole Ajao, ACPRN
Questions? Drop me a line! I'd love to hear from you!


#include <db_cxx.h>int DbLockTab::id(u_int32_t *idp);
The DbLockTab::id method copies a locker ID, which is guaranteed to be unique in the specified lock table, into the memory location referenced by idp.
The Berkeley DB access methods generate a unique locker ID for each file that is opened with locking. During Berkeley DB access method operation, this locker ID will be used for all lock calls unless a transaction identifier was specified for the call, in which case the transaction ID specified is used as the locker ID.
The DbLockTab::id method either returns errno or throws an exception that encapsulates an errno on failure, and 0 on success.
The DbLockTab::id method may fail and throw an exception for any of the errors specified for the following Berkeley DB and C library functions: abort(3), fcntl(3), fprintf(3), and getpid(3).


Ali Kasasbeh
Mohammed Alazzam
Mohammed Khasawneh
Duha Masadeh
Reem Alqurm
Contact Us
Email us and keep upto date with our latest news
Your Name
Last Name
Email
Submit


Larger numbers == better quality, but are slower to generate
Grayscale will improve network and system performance!


Thoughts & Opinions
Analyzing Conflict
Sources, Emotions, and Teachings from the Past
03/28/2015
I worked at a place with predominantly men. I didn’t have a problem working with other men, after all, that was what most of my engineering classes looked like. My co-worker spoke to me trying to explain what GitHub was, assuming I didn’t know. I was frustrated and kept in my anger, hoping he’d pause to ask, but he continued explaining as if I knew nothing about it. It didn’t bug me that he explained, that was very nice of him, but he assumed the other guys knew and I didn’t.
I would trace the source of the conflict back to asking a question about the inter-workings of GitHub. I felt frustrated and slightly annoyed that he would try and simplify something I had already told him I knew how to do. The first time I quickly tried to tell him I already knew what he was trying to explain, but he couldn’t care less and decided to continue speaking his mind. I didn’t feel as respected or understood as just as competent as the men.
If I could go back, I would definitely ask him to take a short break with me and discuss how I felt, and why he felt the need to continue explaining to me and not the others. Quite frankly, It made me feel uncomfortable. Talking to him in private would have been a good idea in order to sort things out one-on-one. I learned a lot from just this one experience. I learned I should hold my ground, and discuss issues that bother me with the inflicter. This would have helped him realize that although his intentions may have been good, the world needs more people with less assumptions on others’ talents and capabilities.


Profile
Nickname.
Log into
Teacher / Parent
Portal
PLAY Games Now
Coming Soon
CHAT BOX
GET READY TO ENJOY!
Coming Soon
Quote of
THE DAY
GET READY TO ENJOY!
Tip Of The Day
Regularly and thoroughly clean your hands with an alcohol-based hand rub or wash them with soap and water!
- March 11, Thursday
Community News
Coming Soon
VIDEO Of
THE DAY
GET READY TO ENJOY!
Coming Soon
Event Of
THE DAY
GET READY TO ENJOY!
Coming Soon
Campus picture Of
THE DAY
GET READY TO ENJOY!
Leader-board
Coming Soon
Campus Alerts
And Activities
SOON TO BE ACTIVATED!
Resilience Tree


This is not the greatest page in the world, this is just a
Tribute Page
For my Free Code Camp course one of the projects I needed to do was a tribute page. Their example was lovely with a tasteful page giving details of the life of one of the authors personal heroes. I decided to take a different path.
Inspired by the Tenacious D song "Tribute" I decided to make a "Tribute" page.
For those who haven't heard it the lyrics are:
"Tribute"
[Spoken]
This is the greatest and best song in the world... Tribute.
Long time ago me and my brother Kyle here,
we was hitchhikin' down a long and lonesome road.
All of a sudden, there shined a shiny demon... in the middle... of the road.
And he said:
[Sung]
"Play the best song in the world, or I'll eat your soul." (soul)
[Spoken]
Well me and Kyle, we looked at each other,
and we each said... "Okay."
[Sung]
And we played the first thing that came to our heads,
Just so happened to be,
The Best Song in the World, it was The Best Song in the World.
Look into my eyes and it's easy to see
One and one make two, two and one make three,
It was destiny.
Once every hundred-thousand years or so,
When the sun doth shine and the moon doth glow
And the grass doth grow...
Needless to say, the beast was stunned.
Whip-crack went his Whoopy tail,
And the beast was done.
He asked us: "(snort) Be you angels?"
And we said, "Nay. We are but men."
Rock!
Ahhh, ahhh, ahhh-ah-ah,
Ohhh, whoah, ah-whoah-oh!
This is not The Greatest Song in the World, no.
This is just a tribute.
Couldn't remember The Greatest Song in the World, no, no.
This is a tribute, oh, to The Greatest Song in the World,
All right! It was The Greatest Song in the World,
All right! It was the best muthafuckin' song the greatest song in the world.
[2-part skat]
[Spoken]
And the peculiar thing is this my friends:
the song we sang on that fateful night it didn't actually sound
anything like this song.
[Sung]
This is just a tribute! You gotta believe it!
And I wish you were there! Just a matter of opinion.
Ah, fuck! Good God, God lovin',
So surprised to find you can't stop it.
[Skat]
All right! All right!
And this is an embeddded youtube video of the song:
If you want more information about Tenacious D their wikipedia page can be found here