Pre-Class: The Queue Data Structure
Pre-Class: The Linked List Data Structure
What is an array and how do they work?
01 01 was a race horse
10 10 was one too
01 01 won one race
10 10 01 01 10
An array allocates a certain amount of memory when they are created.
Array lookup begins at [0]
because it’s zero pointer sizes away from the pointer at the beginning of the sequence. While it’s harder for people, it’s easier for computers to do the math.
Index * size of type = array[index]
So, 0 * 4 bits = 0. If we started with 1 instead of 0, that would require an additional operation to find the starting point beause 1 * 4 = 4, not 0.
array[5] would point to the 20th bit because 5 * 4 = 20.
If we know that we want an array of 3, 12 bits of memory will be set aside for this array (3 * 4 = 12).
If we want to decrease the size of that array, we can easily indicate that the memory for that array is less than 12 bits.
But if we want to add to the array, we have to first check if the memory next to the end of the current array is already allocated.
If that memory is not already allocated, we can use it to expand the array. But if it is taken, how do we expand the array?
Because arrays must be contiguous (unlike linked lists), we can’t just allocate the next closest available bits of memory.
Depending on if the language manages memory for us (like Python), we may have to do this manually.
We first would need to find a larger memory block that fits the new array length, then copy the original array data into that new memory block. Afterwards, we release the original block of memory by marking it as free (or able to be collected by the garbage collector).
Typically that data is not actually cleared. It’s just marked as free to re-use. When we get rid of old hard drives or other memory storage devices, it’s best to fully destroy anything that contained sensitive data because it may still be written to memory if it was not memory that was cleared to re-use. De-allocation is not the same as erasing, despite being “deleted” according to the computer.
Not all languages de-allocate automatically. In Python it does, but in C, you have to do it manually (or risk a memory leak).
For more in-depth information about how arrays work, read here.
LIFO = Last In First Out
FILO = First In Last Out
We can think of stacks like vertical stacks of paper on a desk. We add to the top of the stack, placing newer papers on top. As we process through the papers, we’re dealing with the newer papers first, instead of the oldest.
You can also think of LIFO/FILO with your email inbox. Most people work through their email inbox from the top down (newest to oldest). Or, a social medai feed. The most recent thing would be considered the most important.
FIFO = First In First Out
Most stores work with a first in, first served method to ensure that customers are happy and served quickly. Similarly, a bakery wants to sell the older baked good sooner than the brand new ones. First made, first sold. If you add the new ones to the front, then the old ones might go bad (expire).
If a customer service line handled new inqueries first, the first customers to reach out would become very angry. Or a playlist usually lists the oldest song put onto the playlist first.
Queues function the same way where they handle the oldest items first.
Learn more about LIFO v FIFO.

Linked Lists and Arrays are very similar - both are used for storing lists of data. Arrays are usually included as part of any language’s library but linked lists are not necessarily (JS and Python do not export a standard linked list implementation), so we are more familiar with arrays. We see them commonly.
With arrays, the information stored within them are all physically stored next to each other in memory.
A linked list might be better represented as a bead necklace - little nodes connected by a link (beads by string). There is no requirement that this data exist next to each other in memory. Instead, each item in the list points to the next item’s location in memory.
Arrays have to be contiguous because they are data stored next to each other in memory. In the bits, the allocated memory must always have a value – it isn’t null in memory. It’s either a 0 or a 1. No matter if we aren’t storing a value, a 0 is still being read. That position in memory is always being read, so even if it’s “empty”, it’ll be read as nothing. (That memory is either still reserved for the array or marked as not in use, but probably contains unused data.)
Linked Lists are not contiguous. The parts can exist in separate blocks of memory, pointing from one to the next.
If we have a grocery list like so:
Milk
Ground Beef
Cheese
Taco Shells
Lettuce
Eggs
Salsa
We could go down the list and get each item in order. But navigating a grocery store makes more sense if we move through section by section. If we start with Milk, we’re near the dairy. It would make the most sense to get cheese and eggs before getting the other items.
If we then added in Hot Sauce, we know that it’s probably by Taco Shells, so rather than adding it to the end of the list, we would want to add it before or after Taco Shells to organize it better.
With a linked list, each item points to the next item. If we re-wrote our list like a linked list, it would look more like this:
Milk
Cheese
Eggs
Ground Beef
Taco Shells
Hot Sauce
Salsa
Lettuce
In a linked list, each item is a Node with a pointer to the next item. Milk would point to Cheese. Salsa would point to Lettuce.
When we add Hot Sauce in, previously, Taco Shells pointed to Salsa. In order to add an item, we would find an open space in memory, create a new node called Hot Sauce. Hot Sauce would point to Salsa. Then we would change Taco Shells to point to Hot Sauce.
In this way, updating items in a Linked List is more time and space efficient than with an array, because we aren’t having to find a new contiguous space of memory and copy an old array; or shift all items in the array over one.
With the Linked List, we add a new node and update the previous node’s pointer. It’s quick and easy.
If our memory is already being used up by other applications - there are available spots but not that many. If we use an array, we need that specific size of continuous space for that array. A linked list is more memory flexible by using the available spaces.
That said, this con of linked lists is more conceptual than applicable. Typically, arrays are still considered to be more memory efficient and this would not be a factor in choosing a linked list over an array.
A good reason to decide which one to use is considering the run time of removing or inserting an item from the linked list v array.
If we wanted to remove the first item in an array, there would be a hole in the first spot of the array. Arrays are unhappy if the hole is anywhere other than the end of the array - so the remaining elements are shifted one to the left. The runtime of that change is O(n)
. A very large array would have a significant shift run time.
Removing any elements from the front or middle of an array is a linear operation in the worst case (the exception is removing from the end).
If we wanted to insert a new element to the start (or middle) or an array, we have to shift the other elements to the right to make room for a new item to be added into the continuous array space in memory.
Again, insert (other than to the end of an array) has a linear run time O(n)
.
Arrays are only efficient when adding/removing from the end.
Linked Lists instead have a basic “head of the list” and “tail of the list”, with references to each.
H -> x -> x -> x -> x -> T
To remove an item from the start of the linked list, we would need to shift the Head Reference to the second item in the linked list (the new Head of the list) and then remove the first node.
H -> x -> x -> x -> T
Nothing is shifted. The pointers to the next item in the list are simply being moved around.
If we wanted to add a new element into the middle of the list, we would simply add a new node, that holds a reference to the previous and next node in the list. Nothing is being shifted, just the pointers are being re-drawn.
No matter how big the linked list is, the run time is constant O(1)
.
Adding or removing from the end of the linked list retains the same run time as an array too - so it’s more efficient overall and equally efficient to the array’s best case scenario.
Typically with linked list implementations, there’s a node class and a linked list class (which builds on top of the node class). Let’s start building one in our linked list python file.
class Node:
def __init__(self, value=None, next_node=None):
self.value = value
self.next_node = next_node
Our Node class starts with a value that defaults to none and a next_node that also defaults to None. We’ll also add some methods:
class Node:
def __init__(self, value=None, next_node=None):
self.value = value
self.next_node = next_node
def get_value(self):
return self.value
def get_next(self):
return self.next_node
def set_next(self, new_next):
self.next_node = new_next
def set_value(self, value):
self.value = value
This gives our Node some methods that will return the current value, the pointer to the next node and allows us to re-assign the next node pointer.
Our LinkedList needs a Head Reference and Tail Reference - those are the only reference a linked list contains, which is an important difference to arrays. Every item in an array is indexed, allowing us to access any element within the array via bracket notation. Linked Lists do not work the same way.
To traverse a linked list, you have to start at the head node and keep moving the reference through the list, until you find the wanted item. We can’t just request and access x item in the list (second or fifth).
This is one of the major reasons arrays are more commonly used because indexing is useful.
We’ll also adds a method to add a tail to the end of our linked list. Thinking about the way that adding a new item to the linked list is by creating a new node, the re-write the previous next_node reference to the new node, and then re-write the Tail Reference to this new node.
class LinkedList:
def __init__(self):
self.head = None
self.tail = None
def add_to_tail(self, value):
# wrap the value in a node
new_node = Node(value)
# update the old tail's next reference to refer to the new node
self.tail.set_next(new_node)
# update the linked list's 'tail' reference
self.tail = new_node
Does the order of those last two operations matter? Why would this work (or not)?
def add_to_tail(self, value):
# wrap the value in a node
new_node = Node(value)
# update the linked list's 'tail' reference
self.tail = new_node
# update the old tail's next reference to refer to the new node
self.tail.set_next(new_node)
If, instead, we made the new node and then moved the Tail Reference to the end prior to setting self.tail.set_next() would mean that it would just be the new node referencing itself, instead of the previous node referencing the new node as the tail.
Order matters for this.
What are some assumptions we’re making currently that don’t account for possible edge cases?
The list was not empty, elements already existed
What does an empty Linked List look like?
It just has head and tail references that are both “none”.
If we add a new node, it will be the only node in the linked list and will be referenced to as both the head and the tail.
To adjust our constructor for handling this, we can keep our current setup but we need to also set the head:
# check if we're in an empty list state
# can also write: if not self.head and not self.tail
if self.head == None and self.tail == None:
# set the list's head reference to point to new_node
self.head = new_node
# set the list's tail reference to point to new_node
self.tail = new_node
Now our Linked List class will look like this with the If/Else setup handling this edge case:
class LinkedList:
def __init__(self):
self.head = None
self.tail = None
def add_to_tail(self, value):
new_node = Node(value)
if self.head == None and self.tail == None:
self.head = new_node
self.tail = new_node
else:
self.tail.set_next(new_node)
self.tail = new_node
Now let’s add a remove head method. We need to take the old_head’s value, and update it to the next_node, then remove that node.
def remove_head(self):
# Store reference to node being removed to return value
old_head = self.head
# update head reference to refer to the old head's next_node
self.head = old_head.get_next()
# return the old head's value
return old_head.get_value()
A double linked list would imply that the flow of pointers goes in both directions. Currently, they only go one way, with each node pointing to the next one, but not the previous one.
H -> x -> x -> x -> T
A linked list where the nodes point to both the previous and next node, then that is a doubly linked list, like so:
H <-> x <-> x <-> x <-> T
Hash Tables and Caches are times where linked lists might be preferred over arrays…but that comes later.
What if our list is empty? We need to return non to show we can’t remove the head.
We’ll check and return None
if that is the case.
What if our list has only one Node?
Then the self.head
will equal self.tail
, because the head reference and tail reference will be to the same node.
We’ll set our reference to the old_head and then update the current head and tail to None, since removing this single Node would mean there is no node left (empty list)
# what if our list is empty?
if not self.head and not self.tail:
return None
# what if our list only contains a single node?
if self.head is self.tail:
old_head = self.head
self.head = None
self.tail = None
return old_head.get_value()
How can we iterate through a linked list, looking for a target value?
First, let’s check if our list is empty. There’s no reason to search through our list if it contains nothing.
def contains(self, target):
# what if our list is empty?
if not self.head and not self.tail:
return False
# get the current reference that initially starts at the head of the list
current = self.head
# keep looping while curent is valid (not None)
while current:
# check if current.get_value() is the same as our target
if current.get_value() == target:
return True
# otherwise, update current to the next node
else:
current = current.get_next()
# otherwise we didn't find it in the linked list so return false
return False
If our list is like this:
1 –> 2 –> 3 –> 4 –> N
We have to start at the head because with a single Linked List, we can only traverse it in one direction.
Does this linked list contain 3?
We keep looping so long as there is a Node to check against the Target (3).
When it checks Node 1, and 1 != 3, Current
become Node 2. It continues to iterate through until it hits Node 3 and returns True
because 3 == 3.
If we were looking for 5, this would iterate through the entire linked list until the final Node is None
(end of the list) and no target matched, so it returns False
.
If you found these notes helpful and want to show appreciation to the author, coffee donations are much loved.


The display property is used to determine how the element is going to relate to other elements. The block property makes it so that the element will stay fixed in its block.
When an element is inline, it will never try to take up more space than it needs. It will try to fit into the smallest area possible. Like so:
When an element is in a block, it tries to maintain its shape, but if its inline block, it tries to fit into the same line if possible.
This makes inline-block useful for making a row of elements that each have their own distinct shape, and inline for a row where every element is as small as its text.


Duelist Kaien:
Certainly you are not finished with the trial yet! Why do you seek me? Do not come to me again until you have defeated all of the opponents on the list at least 3 times.


ReFresh
Register
Login
Register
First name:
Last name:
Email:
Username:
Password:
Confirm Password:
Cancel
Submit


Karuda:
You can earn the following rewards:
S80 weapon recipe - Requires 500 Cursed Grave Goods
Leonard - Requires 8 Cursed Grave Goods
Adamantine - Requires 15 Cursed Grave Goods
Orichalcum - Requires 12 Cursed Grave Goods
Remember, I'm counting on you!


Boeing clinches another order for its grounded 737 Max jet
The coup at the Dubai Airshow is a boost for the aircraft which remains earthbound since two fatal crashes.
Boeing’s embattled 737 Max jet has got another boost at the Dubai Airshow.
An order from Kazakhstan’s newly-launched budget carrier came as the Chicago-based company works to try and win US regulatory approval to get the plane back in the sky by early next year.
The plane has been grounded around the world after two crashes that killed 346 people.
The jet’s automated flight control system has been blamed in part in the crashes that occurred after take-off from Indonesia in October of last year and from Ethiopia in March.
Still, the single-aisle jet managed to secure some deals at the airshow.
Kazakhstan’s national carrier Air Astana announced a letter of intent to purchase 30 of the 737-8 Max jets with a list price value of 3.6 billion US dollars for its new budget airliner FlyArystan.
A day earlier at the airshow, Turkey’s SunExpress announced a purchase of 10 additional 737-8 Max jets for its fleet.
Airlines are likely negotiating competitive prices for the aircraft as Boeing talks to its already existing customer base about possible compensations related to the grounding of the jets and reaches settlements with relatives of victims who perished.
Air Astana executives said details of the deal, including the final price, will be finalised in the coming months as the newly-launched low-cost carrier scales its services from its current fleet of two A320 aircraft.
FlyArystan began operations in May.
Air Astana’s chief planning officer Alma Aliguzhinova said FlyArystan expects to start operations of the first 737 Max in late 2021, giving the company 18 months to observe its operations from when Boeing hopes to have the jet back in service globally.
“What we see is that, as I said, we have time before we start operations,” she said.
“So we are confident that this will be addressed by that time… We are confident in Boeing.”
In a major coup for Boeing not long after the second crash, one of the world’s largest airline groups, IAG, announced in June its intention to purchase 200 of the 737 Max jets.
Boeing competitor Airbus, meanwhile, also moved ahead with some deals on Tuesday after securing 30 billion US dollars in deals a day earlier at the airshow.
Air Senegal announced a memorandum of understanding to purchase eight Airbus A220s in an order worth 734 million US dollars at list price.
Airbus also secured purchases from British budget carrier easyJet, which said it will order 12 additional A320neos it previously had options to buy, pushing the airline’s total order for the single-aisle plane to 159.
The airline operates across Europe with a fleet of entirely Airbus aircraft, serving 155 European airports.
The list price of the A320neo in 2018 was 110.6 million US dollars, making the order for 12 worth about 1.3 billion US dollars.
Airlines, however, typically negotiate better prices.


Download
source map | unminified javascript | full coffeescript
seen.js has no dependencies.
Licensed under Apache 2.0
To see what is new in this version, read the release notes.
Demos
-
{% for demo in demos %}
- {{demo.title}} {% endfor %}


Dairy
Home
Farmer
Add raw materials
Producer
Order raw materials
Add Dairy Products
Add products to Warehouse
WarehouseOwner
Create Warehouse
Customer
Order Dairy Products
About Us
Feedback
Register
Login
Logout
Products that we sell
Access Manufacturing Capacity
Get the best quotes from a pre-qualified manufacturing network when you need it.
Secure Blockchain Order Process
All your PO documents in one place! Securely stored on our proprietary Blockchain platform.
End-To-End Visibility
Control your supply chain with transparent order tracking allowing better exceptions handling.
.


Discovery Lab
ASU CAS Authentication
Login with ASU credentials to access this application
ASU CAS Authentication
Login with ASU credentials to access this application
An interactive Lab with numerous questions that helps honing the skills of the students.
The instructors can create, delete, modify labs. It also allows the instructor to analyze student data.


Google Smart Displays start showing dates on some photo slideshows
by Damien WildeOne of the best features of the Google Nest Hub, Nest Hub Max and Google Smart Displays, in general, is the photo slideshow feature. While the nostalgia factor is great, the addition of dates to your photo slideshows is now a great new Smart Display addition.
Dates will only show on some of your Smart Display photo slideshows though (via Android Police). You’ll notice them in the bottom right of your photos with the date taken. Not only that but there is now further album information and details of the photo-taker or uploader too — if you use shared albums or accounts.
I’ve not been able to see it on any of my Nest Hub devices, but AP notes that the new date info will appear around 10 to 20% of the time. At present, the photo slideshow just shows the album info and the owner or uploader in the bottom right of each photo/collage.
It’s likely that Google is currently testing this feature and it only appears to be visible on Google Smart Displays such as the Nest Hub and Nest Hub Max. It’s unclear if this will be an exclusive feature but it’s so early that it’s really hard to tell.
That said, this would be a really neat inclusion that gives some more context to those auto-generated nostalgia-driven photo slideshows and this makes the best smart digital photo frame even better still. Let’s just hope for a wider rollout soon.
If you have seen dates on your Smart Display devices, let us know down in the comments section below.
More on Google:
- Google Nest Hub and Nest Hub Max can detect when you’re nearby starting today
- Malicious phishing apps for Google Assistant could get user’s passwords [Video]
- Google is close to launching a speed test feature on Nest Hub devices
FTC: We use income earning auto affiliate links. More.


{#
#}
{% if payload.interface_details.interface_name != 'baseline' %} {% if payload.participant_state.privacy_switch_default == true %} Privacy Protection Off
On {% else %} Privacy Protection Off
On {% endif %} {% else %} {% if payload.participant_state.privacy_switch_default == true %} Privacy Protection Off
On {% else %} Privacy Protection Off
On {% endif %} {% endif %}
{% if payload.interface_details.interface_name == 'nudge_stoplight' %} {% if payload.participant_state.privacy_switch_default == true %}
P
Explain this
Privacy risk where
Red = High privacy risk
Yellow = Medium privacy risk
Green = Low privacy risk
{% endif %} {% endif %}
MEDICAL QUESTION {{ payload.current_med_question_num }}:
{{ payload.cochrane_definitions.QUESTION_TEXT }}
HEALTH ISSUE: {{ payload.cochrane_definitions.HEALTH_ISSUE_PHRASE }} -
{{ payload.cochrane_definitions.HEALTH_ISSUE_DEF }}
Source: {{ payload.cochrane_definitions.HEALTH_ISSUE_SOURCE }}
TREATMENT: {{ payload.cochrane_definitions.TREATMENT_PHRASE }} -
{{ payload.cochrane_definitions.TREATMENT_DEF }}
Source: {{ payload.cochrane_definitions.TREATMENT_SOURCE }}
You can click on links below
helpful:
The medical treatment
helps
if the treatment is effective and has a direct positive influence on the specified illness.
inconclusive:
The effectiveness of a medical treatment is
inconclusive
if medical professionals are still unsure if the treatment will have a positive, negative or no influence on the specified illness.
does not help:
The medical treatment
does not help
if the treatment is ineffective and either has no effect or has a direct negative influence on the specified illness.
{% block results %} {% endblock %} {% if payload.pagination|length > 1 %}
{% for item in payload.pagination %} {% if '99999' in item[1] %}
{{ item[0] }}
{% else %}
{{ item[0] }}
{% endif %} {% endfor %}
{% endif %}


ComplianceExec
75%
of tests failed25%
of tests failed12
fields in questionN/A FNMA ATR Exempt Test details
Initial APR Test details
Federal HPM Test details
N/A Texas Home Equity 3% Test details
This loan has failed HOEPA testing because it failed the Points & Fees test. FAIL
SECTION 32 PREPAYMENT PENALTY TEST PASS
SECTION 32 PREPAYMENT PENALTY TEST PASS
SECTION 32 POINTS & FEES TEST FAIL
Fannie Mae ATR Exempt Testing does not apply to this owner occupied loan. N/A
Loan failed the State High Cost test because it failed the Points & Fees check FAIL
RATE TEST PASS
POINTS & FEES TEST FAIL
INITIAL APR TEST PASS
INITIAL APR TESTPASS
Cause of Failure: Points & Fees check failed FAIL
Higher-Priced Qualified Mortgage Test PASS
POINTS & FEES TEST FAIL
This test only applies to TX home equity loans N/A
Confirm that the fees on the loan are less than 5% of the loan amount.
The fee limit is determined by a percentage of loan amount. This can be corrected by lowering fees below allowed limit.
This loan has passed HOEPA testing; no action needed.
The APR limit is determined by taking the Average Prime Rate set by the Consumer Financial Protection Bureau plus a threashold of either 6.5% or 8.5% based on the loan criteria. Lowering the interest rate or fees can address this problem.
This loan has passed the HOEPA Prepayment Penalty check; no action needed
The ability to have a Prepayment Penalty is based off loan criteria, such as loan type, state, etc.
Loan failed the points/fees portion of the HOEPA test.
The allowable fee limit is based off 5% of
the loan amount. The test will then look at the fees charged, and inform you by how much the fees on the
loan are over the limit. To correct, lower your fees so they are under the 5% of the loan amount threshold.
The following loan types are excluded from this test:
- 1. Prepaid Interest
- 2. FHA Upfront MIP
- 3. VA Funding Fee
- 4. USDA Upfront Fee
- 5. PMI Premium (refundable)
- 6. Monthly Mortgage Insurance
- 7. Bona Fide Discount Point(s)
- 8. Bona Fide Third Party in AP
The allowable fee limit is 5% of the loan amount. The test will look at the fees charged, and inform you by how much the fees on the loan are over the limit. To correct, lower your fees so they are under the 5% of the loan amount threshold.
The Points & Fees are over the 3% of the loan amount allowed limit for this loan.
The limit is between 3% and 8% depending on the loan amount. The test will compare the final Points & Fees and compare them to the allowed limit.
To correct, lower your fees so they are under the 3% of the loan amount limit.
The test examines the final APR on the loan and compares it to the allowable APR threshold rate, and inform you by how much the APR is over the threshold.
The APR limit takes the Average Prime Rate set by the Consumer Financial Protection Bureau and adds a threashold of either 6.5% or 8.5% based on the loan criteria.
A failed test can be corrected by lowering your interest rate or fees.
The APR falls under the High-Priced Mortgage (HPM) Limit.
The HPM Limit value is based on the application date of the loan and with an additional 1.5% threshold factor for first liens. The test will compare the final APR to the allowed HPM Limit for the loan.
Typically a failure of this test can be corrected by lowering points and fees.
The allowable fee limit is 5% of the loan amount. The test informs you by how much the fees on the loan are over the limit. To correct, lower your fees so they are under the 5% of the loan amount threshold.
The allowable difference between the initial disclosed APR and the final APR is .125%. The test compares the initial disclosed APR to the final APR to verify if it is within tolerance.
Failure of this test can typically be corrected by lowering the interest rate or the fees.
The APR falls under the QM limit. The QM limit is calculated using the application date of the loan and adding 1.5% threshold factor for first liens. The test will compare the final APR to the allowed QM Limit for the loan.
Typically this can be corrected by lowering rates and fees.
The allowable fee limit is based off 5% of the loan amount. The test informs you by how much the fees on the loan are over the limit.
To correct, lower your fees so they are under the 5% of the loan amount threshold.
This is a Texas test specific to Home Equity Loans.
This test ensures that the applicable fees are less han 3% of the loan amount. The test will compare the final applicable fees against the allowed 3% fee limit.
In the case of a failure, you can lower the fees included the fee limit to correct .


coleshepherd.com
Home
Music
Design Inspiration
Curated Music
Classical
Everything by Chopin
Chill
Endtroducing - DJ Shadow
Psyence Fiction - UNKLE
Antiphon - Alfa Mist
Jazz
Kind of Blue - Miles Davis
Metal
Ashes of the Wake - Lamb Of God
Soundtracks
Game Soundtracks
Gears of War - Kevin Riepl
The Elder Scrolls III: Morrowind - Jeremy Soule
The Elder Scrolls IV: Oblivion - Jeremy Soule
The Elder Scrolls V: Skyrim - Jeremy Soule
Halo 2 - Martin O'Donnell
Halo 3 - Martin O'Donnell
Halo Reach - Martin O'Donnell
Dark Souls Series - Motoi Sakuraba
Movie Soundtracks
Everything by Studio Ghibli - Joe Hisashi
The Lord of the Rings - Howard Shore
Harry Potter Series - John Williams, Patrick Doyle, Nicholas Hooper, Alexandre Desplat
The Dark Knight - Hans Zimmer
Ambient
Anything released by
Cryo Chamber
Echo - Apocryphos, Kammarheit, Atrium Carceri
Forsaken - Alphaxone & Dronny Darko
Legends of the Wood - Dead Melodies
Drum & Bass
Devious Methods - Hive
Miscellaneous
One - C418


Python Tuples
A tuple is a sequence of immutable Python objects. Tuples are sequences, just like lists. The differences between tuples and lists are, the tuples cannot be changed unlike lists and tuples use parentheses, whereas lists use square brackets.
Creating a tuple is as simple as putting different comma-separated values. Optionally you can put these comma-separated values between parentheses also. For example −
tup1 = ('physics', 'chemistry', 1997, 2000); tup2 = (1, 2, 3, 4, 5 ); tup3 = "a", "b", "c", "d";
The empty tuple is written as two parentheses containing nothing −
tup1 = ();
To write a tuple containing a single value you have to include a comma, even though there is only one value −
tup1 = (50,);
Like string indices, tuple indices start at 0, and they can be sliced, concatenated, and so on.
Accessing Values in Tuples
To access values in tuple, use the square brackets for slicing along with the index or indices to obtain value available at that index. For example −
#!/usr/bin/python tup1 = ('physics', 'chemistry', 1997, 2000); tup2 = (1, 2, 3, 4, 5, 6, 7 ); print "tup1[0]: ", tup1[0]; print "tup2[1:5]: ", tup2[1:5];
When the above code is executed, it produces the following result −
tup1[0]: physics tup2[1:5]: [2, 3, 4, 5]
Updating Tuples
Tuples are immutable which means you cannot update or change the values of tuple elements. You are able to take portions of existing tuples to create new tuples as the following example demonstrates −
#!/usr/bin/python tup1 = (12, 34.56); tup2 = ('abc', 'xyz'); # Following action is not valid for tuples # tup1[0] = 100; # So let's create a new tuple as follows tup3 = tup1 + tup2; print tup3;
When the above code is executed, it produces the following result −
(12, 34.56, 'abc', 'xyz')
Delete Tuple Elements
Removing individual tuple elements is not possible. There is, of course, nothing wrong with putting together another tuple with the undesired elements discarded.
To explicitly remove an entire tuple, just use the del statement. For example −
#!/usr/bin/python tup = ('physics', 'chemistry', 1997, 2000); print tup; del tup; print "After deleting tup : "; print tup;
This produces the following result. Note an exception raised, this is because after del tup tuple does not exist any more −
('physics', 'chemistry', 1997, 2000) After deleting tup : Traceback (most recent call last): File "test.py", line 9, in <module> print tup; NameError: name 'tup' is not defined
Basic Tuples Operations
Tuples respond to the + and * operators much like strings; they mean concatenation and repetition here too, except that the result is a new tuple, not a string.
In fact, tuples respond to all of the general sequence operations we used on strings in the prior chapter −
| Python Expression | Results | Description |
|---|---|---|
| len((1, 2, 3)) | 3 | Length |
| (1, 2, 3) + (4, 5, 6) | (1, 2, 3, 4, 5, 6) | Concatenation |
| ('Hi!',) * 4 | ('Hi!', 'Hi!', 'Hi!', 'Hi!') | Repetition |
| 3 in (1, 2, 3) | True | Membership |
| for x in (1, 2, 3): print x, | 1 2 3 | Iteration |
Indexing, Slicing, and Matrixes
Because tuples are sequences, indexing and slicing work the same way for tuples as they do for strings. Assuming following input −
L = ('spam', 'Spam', 'SPAM!')
| Python Expression | Results | Description |
|---|---|---|
| L[2] | 'SPAM!' | Offsets start at zero |
| L[-2] | 'Spam' | Negative: count from the right |
| L[1:] | ['Spam', 'SPAM!'] | Slicing fetches sections |
No Enclosing Delimiters
Any set of multiple objects, comma-separated, written without identifying symbols, i.e., brackets for lists, parentheses for tuples, etc., default to tuples, as indicated in these short examples −
#!/usr/bin/python print 'abc', -4.24e93, 18+6.6j, 'xyz'; x, y = 1, 2; print "Value of x , y : ", x,y;
When the above code is executed, it produces the following result −
abc -4.24e+93 (18+6.6j) xyz Value of x , y : 1 2
Built-in Tuple Functions
Python includes the following tuple functions −
| Sr.No. | Function with Description |
|---|---|
| 1 | cmp(tuple1, tuple2)
Compares elements of both tuples. |
| 2 | len(tuple)
Gives the total length of the tuple. |
| 3 | max(tuple)
Returns item from the tuple with max value. |
| 4 | min(tuple)
Returns item from the tuple with min value. |
| 5 | tuple(seq)
Converts a list into tuple. |


What needs to be done?
Add Todo
{{ todo.desc }}
Delete
Clear completed {{ todoList.length - pendingCount }}


With the modern web, it is possible to build a single code base capable of satisfying all platforms. It's no longer necessary to build a separate code base for the web, iOS, Android, and Windows Phone.
The MashupJS is a bootstrap for building one code base.
The MashupJS provides the components and a prescriptive guide that can be followed. Some of the components you will find are logging, instrumentation, advanced caching, structured for large applications, Lazy loading of components. There are many more features, to many to list here.
The large application nature of the Mashup makes it easy to build modules around technologies for demonstration and study. These modules be used for teaching and learning while hidden by security. They can serve as documentation for approaches used by whatever application is created from the Mashup.


Home > Overview > User Interface > Menus >
The options dialog is available from the "Options..." item under the "View" menu.
The options dialog allows you to configure the text colors used in each type of node as well as the font used and the background color. A drop down arrow on each color lets you pick from different color palettes. You can also cusomtize the font that is used in the Microsoft XML Notepad tree view.
You can also configure the formatting options that are used when you save an XML file, or turn off formatting altogether.
You can also use this dialog to configure the auto-update mechanism. If the "Enable updates" field is true, then Microsoft XML Notepad will ping the specified "Update Location" for an "Updates.xml" file to see if a new version of Microsoft XML Notepad is available. See Updates for more information on how this works.


| Last Name | First Name | Assignment | Grade |
|---|---|---|---|
| Smith | John | Homework #1 | C |
| Wimbleton | Julie | Homework #1 | D |
| Doe | Jane | Homework #1 | A |
| Grey | William | Homework #1 | B |
| Smith | John | Homework #2 | A |
| Wimbleton | Julie | Homework #2 | F |
| Doe | Jane | Homework #2 | C |
| Grey | William | Homework #2 | D |
| Smith | John | Midterm #1 | A |
| Wimbleton | Julie | Midterm #1 | B |
| Doe | Jane | Midterm #1 | D |
| Grey | William | Midterm #1 | F |


A two-player game in which players take turns connecting dots to complete boxes. A player can complete a box started by the other player. When a player completes a box, he/she gets another turn. The player with the most completed boxes wins.
Built with HTML, CSS, JavaScript, and jQuery in a one-week sprint.
Project Site GitHubA forum for Italophiles to share their love for the Italian language and culture, organize local meetups, find language partners, and more. Users can view posted content without signing up, but must sign up and log in to post, comment on posts, and upvote or downvote posts.
Built with Ruby on Rails, PostgreSQL, HTML, CSS, and Bootstrap in a one-week sprint.
Project Site GitHubGet introduced to new potential areas of interest through randomly generated TED Talks. Sign up and log in to see local Meetup groups in your area where you can further explore the topic introduced in the TED Talk.
Built in a team of three in a one-week sprint using MongoDB, Express, Node.js, HTML, CSS, Bootstrap, the YouTube API, the Meetup API, and Ajax.
Project Site GitHubA crowd-sourced travel planning tool for those looking to visit or explore California. Users can see user-recommended destinations on a map and can log in to add destinations of their own and to save destinations to their profile.
Built in a team of two in a one-week sprint using MEAN stack (MongoDB, Express, Angular.js, Node.js), HTML, CSS, Bootstrap, and the Google Maps API.
Project Site GitHub


by Lars Lindahl (c) 2000 Lars Lindahl
Lars Attacks! http://www.angelfire.com/ny3/larsattacks
"The Steel Helmet" (1951)
Starring Gene Evans, Robert Hutton, Steve Brodie, James Edwards, Richard Loo, Sid Melton, and William Chun.
Directed by Sam Fuller Written by Sam Fuller
Grade: **** (out of four)
Sam Fuller's rarely seen masterpiece, The Steel Helmet, is a film that should be included with Platoon and Saving Private Ryan, among others, as one of the great war films of the twentieth century. Although it is not as violently graphic as others, its anti-war message is just as powerful. With an extremely brief eighty-four minute running time, Fuller proves his point without any unnecessary characters or subplots and manages to avoid any major cliches that plague most war films.
The Steel Helmet is a frighteningly hypnotic tale, set during the Korean War, following a group of American soldiers, separated from their unit, who hide out in a Buddhist temple. In this temple we meet the diverse characters who find they have very little in common with everyone else: an African American medic who realizes that back home his family and friends are treated disrespectfully, a Japanese American soldier who notices the same discrimination, a young na´ve North Korean boy who ecstatically joins the group on their quest for safety, and a veteran Sergeant who luckily survived a bullet to his head thanks to his steel helmet. Fuller's use of different races and ages truly show the war's wide ranging effects on society. From this ambiguous group, there is hatred, friendship, innocence, and criminality. Fuller later introduces a South Korean character and he shows that the same traits apply for the opposite side. By doing this, Fuller leaves a powerful message that the war is completely meaningless and detrimental because it is either fought by soldiers with complete unjustified prejudice towards another race or by soldiers who don't know exactly why they are fighting. Since the film was made in 1951, Fuller boldly delivered his message to Americans who fought or cheered on the war. It's almost like releasing Saving Private Ryan the day after D-day; he was showing people what horrible things were happening at the exact time that they were happening. It comes as no surprise to hear that Fuller was at the time harshly accused of being a Communist.
 His use of external factors, such as smoke or sound effects, is as convincingly realistic as his perfect use of the musical score. The film also has some fantastic acting to fill all of the characters' roles, from Gene Evans as the Sergeant who reacts like any human being would, whether right or wrong to William Chun as an ingenuous young boy who does not notice the seriousness of the war he is in the middle of. This short film has a lasting impact on the horrors of twentieth century wars.
Grade: **** (out of four)
Lars Attacks! http://www.angelfire.com/ny3/larsattacks
by Lars Lindahl (c) 2000 Lars Lindahl
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Computer science classroom Web Page
Rao Casturi
A bit more info is needed since its your first time logging in
Select your class Day and Time
T&TH 5:30 - 7:15
class 2
class 3
class 4


Randomly crops a tensor to a given size.
tf.compat.v1.image.random_crop
tf.compat.v1.random_crop
tf.compat.v2.image.random_crop
tf.image.random_crop( value, size, seed=None, name=None )
Slices a shape size
portion out of value
at a uniformly chosen offset.
Requires value.shape >= size
.
If a dimension should not be cropped, pass the full size of that dimension.
For example, RGB images can be cropped with
size = [crop_height, crop_width, 3]
.
value
: Input tensor to crop.size
: 1-D tensor with size the rank of value
.seed
: Python integer. Used to create a random seed. See
tf.compat.v1.set_random_seed
for behavior.name
: A name for this operation (optional).A cropped tensor of the same rank as value
and shape size
.


Welcome to SustainUp!
Welcome to SustainUp!
Log in
Continue as guest
Don't have an account?
Make one here!


| runif64 {bit64} | R Documentation |
Create uniform random 64-bit integers within defined range
runif64(n, min = lim.integer64()[1], max = lim.integer64()[2], replace=TRUE)
n |
length of return vector |
min |
lower inclusive bound for random numbers |
max |
upper inclusive bound for random numbers |
replace |
set to FALSE for sampleing from a finite pool, see |
For each random integer we call R's internal C interface unif_rand()
twice.
Each call is mapped to 2^32 unsigned integers. The two 32-bit patterns are concatenated
to form the new integer64. This process is repeated until the result is not a NA_INTEGER64
.
a integer64 vector
Jens Oehlschlägel<EMAIL_ADDRESS>runif64(12) runif64(12, -16, 16) runif64(12, 0, as.integer64(2^60)-1) # not 2^60-1 ! var(runif(1e4)) var(as.double(runif64(1e4, 0, 2^40))/2^40) # ~ = 1/12 = .08333 table(sample(16, replace=FALSE)) table(runif64(16, 1, 16, replace=FALSE)) table(sample(16, replace=TRUE)) table(runif64(16, 1, 16, replace=TRUE))


sitar: Super Imposition by Translation and Rotation Growth Curve
Analysis
Functions for fitting and plotting SITAR (Super Imposition by
Translation And Rotation) growth curve models. SITAR is a shape-invariant model
with a regression B-spline mean curve and subject-specific random effects on
both the measurement and age scales.
The model was first described by Lindstrom (1995) <doi:10.1002/sim.4780141807>
and developed as the SITAR method by Cole et al (2010) <doi:10.1093/ije/dyq115>.
Downloads:
Reverse dependencies:
Linking:
Please use the canonical form
https://CRAN.R-project.org/package=sitar
to link to this page.


A glimps of current projects...
Description
When I meet an individual and learned that they are a Software Engineer, I'm so impressed yet not entirely sure what that meant. How could they train a machine, how does their brain work, I asked myself. What is it like to be a programmer?
Technology used
Today, I can answer that question coz I am now one of them.  Always thinking how to better our everyday life and experiences. So here, are my current projects I am thinking will be the next new thing.
Learn more →Sfwr Engineer
eHome Global
JAVA ▪ HTML5 ▪ CSS3 ▪ SASS ▪ JavaScript ▪ JQuery ▪ ES6 ▪ Bootstrap ▪ MySQL ▪ MongoDB ▪ MERN Stack ▪ Express.js ▪ React ▪ Redux ▪MobX ▪ Node.js ▪ AJAX ▪ API ▪ Semantic UI ▪ WP ▪ Karma ▪ SugarCRML ▪ Angular6
Lead QE
Intuit, Inc.
▪ Turbo Tax Support Turbo ▪ Tax Canada ▪ Quicken Support ▪ Salesforce CRM ▪ Selenium WebDriver ▪ Total Quality Management ▪ Quality Measurement ▪ Quality Project Management & Productivity ▪ Strategic Test Planning ▪ Agile Methodologies ▪ Staff Leadership
Lead QE
HP
▪ Staff Leadership ▪ Quality Test Plan ▪ Total Quality Management ▪ Quality Measurement ▪ Quality Project Management & Productivity ▪ Strategic Test Planning ▪ Quality Report Generation ▪ Risk Analysis
QA
Oracle Corp.
▪ JAVA ▪ PLSQL ▪ SQL ▪ Relational Database ▪ Database Testing ▪Testcase Development ▪ WinRunner ▪ Test Automation ▪ Manual Testing ▪ Regression, Functional, System, Integtation Testing ▪ UAT
Check out some of my exciting projects...
- Xtra Value
Technology used
- HTM5/CSS5
- Javascript/Jquery/ES6
- MongoDb
- NPM
- React/MobX
- User Authentication
- Coupon API
- Google Map API
- Heroku/Git
- The Wave
Technology used
- HTM5/CSS5
- Javascript/Jquery
- Google Map API
- Bootstrap
- Firebasejs
- MomentJS
- Express
- NPM
- Git
- Park Me
Technology used
- JAVA
- Javascript
- MySQL
- Google Map API


Dynamoid
Dynamoid is an ORM for Amazon's DynamoDB for Ruby applications. It provides similar functionality to ActiveRecord and improves on Amazon's existing HashModel by providing better searching tools and native association support.
DynamoDB is not like other document-based databases you might know, and is very different indeed from relational databases. It sacrifices anything beyond the simplest relational queries and transactional support to provide a fast, cost-efficient, and highly durable storage solution. If your database requires complicated relational queries and transaction support, then this modest Gem cannot provide them for you, and neither can DynamoDB. In those cases you would do better to look elsewhere for your database needs.
But if you want a fast, scalable, simple, easy-to-use database (and a Gem that supports it) then look no further!
Installation
Installing Dynamoid is pretty simple. First include the Gem in your Gemfile:
gem 'dynamoid'
Prerequisities
Dynamoid depends on the aws-sdk, and this is tested on the current version of aws-sdk (1.6.9), rails 3.2.8. Hence the configuration as needed for aws to work will be dealt with by aws setup.
Here are the steps to setup aws-sdk.
gem 'aws-sdk'
(or) include the aws-sdk in your Gemfile.
- Just like the config/database.yml this file requires an entry for each environment, create config/aws.yml as follows:
Fill in your AWS Access Key ID and Secret Access Key
development:
access_key_id: REPLACE_WITH_ACCESS_KEY_ID
secret_access_key: REPLACE_WITH_SECRET_ACCESS_KEY
dynamo_db_endpoint: dynamodb.ap-southeast-1.amazonaws.com
test:
<<: *development
production:
<<: *development
(or)
- Create config/initializers/aws.rb as follows:
#Additionally include any of the dynamodb paramters as needed.
#(eg: if you would like to change the dynamodb endpoint, then add the parameter in
# in the file aws.yml or aws.rb
AWS.config({
:access_key_id => 'REPLACE_WITH_ACCESS_KEY_ID',
:secret_access_key => 'REPLACE_WITH_SECRET_ACCESS_KEY',
:dynamo_db_endpoint => 'dynamodb.ap-southeast-1.amazonaws.com'
})
For a full list of the DDB regions, you can go here.
Refer to the documentation of the AWS module at the below link for all of the configuration options supported by DynamoDB.
Then you need to initialize Dynamoid config to get it going. Put code similar to this somewhere (a Rails initializer would be a great place for this if you're using Rails):
Dynamoid.configure do |config|
config.adapter = 'aws_sdk' # This adapter establishes a connection to the DynamoDB servers using Amazon's own AWS gem.
config.namespace = "dynamoid_app_development" # To namespace tables created by Dynamoid from other tables you might have.
config.warn_on_scan = true # Output a warning to the logger when you perform a scan rather than a query on a table.
config.partitioning = true # Spread writes randomly across the database. See "partitioning" below for more.
config.partition_size = 200 # Determine the key space size that writes are randomly spread across.
config.read_capacity = 100 # Read capacity for your tables
config.write_capacity = 20 # Write capacity for your tables
end
Once you have the configuration set up, you need to move on to making models.
Setup
You must include Dynamoid::Document
in every Dynamoid model.
class User
include Dynamoid::Document
end
Table
Dynamoid has some sensible defaults for you when you create a new table, including the table name and the primary key column. But you can change those if you like on table creation.
class User
include Dynamoid::Document
table :name => :awesome_users, :key => :user_id, :read_capacity => 400, :write_capacity => 400
end
These fields will not change an existing table: so specifying a new read_capacity and write_capacity here only works correctly for entirely new tables. Similarly, while Dynamoid will look for a table named awesome_users
in your namespace, it won't change any existing tables to use that name; and if it does find a table with the correct name, it won't change its hash key, which it expects will be user_id. If this table doesn't exist yet, however, Dynamoid will create it with these options.
Fields
You'll have to define all the fields on the model and the data type of each field. Every field on the object must be included here; if you miss any they'll be completely bypassed during DynamoDB's initialization and will not appear on the model objects.
By default, fields are assumed to be of type :string
. But you can also use :integer
, :float
, :set
, :array
, :datetime
, :boolean
, and :serialized
. You get magic columns of id (string), created_at (datetime), and updated_at (datetime) for free.
class User
include Dynamoid::Document
field :name
field :email
field :rank, :integer
field :number, :float
field :joined_at, :datetime
field :hash, :serialized
end
Indexes
You can also define indexes on fields, combinations of fields, and one range field. Yes, only one range field: in DynamoDB tables can have at most one range index, so make good use of it! To make an index, just specify the fields you want it on, either single or in an array. If the entire index is a range, pass :range => true
. Otherwise, pass the attribute that will become the range key. The only range attributes you can use right now are integers, floats, and datetimes. If you pass a string as a range key likely DynamoDB will complain a lot.
class User
include Dynamoid::Document
...
index :name
index :email
index [:name, :email]
index :created_at, :range => true
index :name, :range_key => :joined_at
end
Associations
Just like in ActiveRecord (or your other favorite ORM), Dynamoid uses associations to create links between models.
The only supported associations (so far) are has_many
, has_one
, has_and_belongs_to_many
, and belongs_to
. Associations are very simple to create: just specify the type, the name, and then any options you'd like to pass to the association. If there's an inverse association either inferred or specified directly, Dynamoid will update both objects to point at each other.
class User
include Dynamoid::Document
...
has_many :addresses
has_many :students, :class => User
belongs_to :teacher, :class_name => :user
belongs_to :group
has_one :role
has_and_belongs_to_many :friends, :inverse_of => :friending_users
end
class Address
include Dynamoid::Document
...
belongs_to :address # Automatically links up with the user model
end
Contrary to what you'd expect, association information is always contained on the object specifying the association, even if it seems like the association has a foreign key. This is a side effect of DynamoDB's structure: it's very difficult to find foreign keys without an index. Usually you won't find this to be a problem, but it does mean that association methods that build new models will not work correctly -- for example, user.addresses.new
returns an address that is not associated to the user. We'll be correcting this soon.
Validations
Dynamoid bakes in ActiveModel validations, just like ActiveRecord does.
class User
include Dynamoid::Document
...
validates_presence_of :name
validates_format_of :email, :with => /@/
end
To see more usage and examples of ActiveModel validations, check out the ActiveModel validation documentation.
Callbacks
Dynamoid also employs ActiveModel callbacks. Right now, callbacks are defined on save
, update
, destroy
, which allows you to do before_
or after_
any of those.
class User
include Dynamoid::Document
...
before_save :set_default_password
after_create :notify_friends
after_destroy :delete_addresses
end
Usage
Object Creation
Dynamoid's syntax is generally very similar to ActiveRecord's. Making new objects is simple:
u = User.new(:name => 'Josh')
u.email =<EMAIL_ADDRESS>u.save
Save forces persistence to the datastore: a unique ID is also assigned, but it is a string and not an auto-incrementing number.
u.id # => "3a9f7216-4726-4aea-9fbc-8554ae9292cb"
Along with persisting the model's attributes, indexes are automatically updated on save. To use associations, you use association methods very similar to ActiveRecord's:
address = u.addresses.create
address.city = 'Chicago'
address.save
Querying
Querying can be done in one of three ways:
Address.find(address.id) # Find directly by ID.
Address.where(:city => 'Chicago').all # Find by any number of matching criteria... though presently only "where" is supported.
Address.find_by_city('Chicago') # The same as above, but using ActiveRecord's older syntax.
And you can also query on associations:
u.addresses.where(:city => 'Chicago').all
But keep in mind Dynamoid -- and document-based storage systems in general -- are not drop-in replacements for existing relational databases. The above query does not efficiently perform a conditional join, but instead finds all the user's addresses and naively filters them in Ruby. For large associations this is a performance hit compared to relational database engines.
You can also limit returned results, or select a record from which to start, to support pagination:
Address.limit(5).start(address) # Only 5 addresses.
For large queries that return many rows, Dynamoid can use AWS' support for requesting documents in batches:
#Do some maintenance on the entire table without flooding DynamoDB
Address.all(batch_size: 100).each { |address| address.do_some_work; sleep(0.01) }
Address.limit(10_000).batch(100). each { … } #batch specified as part of a chain
Consistent Reads
Querying supports consistent reading. By default, DynamoDB reads are eventually consistent: if you do a write and then a read immediately afterwards, the results of the previous write may not be reflected. If you need to do a consistent read (that is, you need to read the results of a write immediately) you can do so, but keep in mind that consistent reads are twice as expensive as regular reads for DynamoDB.
Address.find(address.id, :consistent_read => true) # Find an address, ensure the read is consistent.
Address.where(:city => 'Chicago').consistent.all # Find all addresses where the city is Chicago, with a consistent read.
Range Finding
If you have a range index, Dynamoid provides a number of additional other convenience methods to make your life a little easier:
User.where("created_at.gt" => DateTime.now - 1.day).all
User.where("created_at.lt" => DateTime.now - 1.day).all
It also supports .gte and .lte. Turning those into symbols and allowing a Rails SQL-style string syntax is in the works. You can only have one range argument per query, because of DynamoDB's inherent limitations, so use it sensibly!
Partitioning, Provisioning, and Performance
DynamoDB achieves much of its speed by relying on a random pattern of writes and reads: internally, hash keys are distributed across servers, and reading from two consecutive servers is much faster than reading from the same server twice. Of course, many of our applications request one key (like a commonly used role, a superuser, or a very popular product) much more frequently than other keys. In DynamoDB, this will result in lowered throughput and slower response times, and is a design pattern we should try to avoid.
Dynamoid attempts to obviate this problem transparently by employing a partitioning strategy to divide up keys randomly across DynamoDB's servers. Each ID is assigned an additional number (by default 0 to 199, but you can increase the partition size in Dynamoid's configuration) upon save; when read, all 200 hashes are retrieved simultaneously and the most recently updated one is returned to the application. This results in a significant net performance increase, and is usually invisible to the application itself. It does, however, bring up the important issue of provisioning your DynamoDB tables correctly.
When your read or write throughput exceed your table's allowed provisioning, DynamoDB will wait on connections until throughput is available again. This will appear as very, very slow requests and can be somewhat frustrating. Partitioning significantly increases the amount of throughput tables will experience; though DynamoDB will ignore keys that don't exist, if you have 20 partitioned keys representing one object, all will be retrieved every time the object is requested. Ensure that your tables are set up for this kind of throughput, or turn provisioning off, to make sure that DynamoDB doesn't throttle your requests.
Concurrency
Dynamoid supports basic, ActiveRecord-like optimistic locking on save operations. Simply add a lock_version
column to your table like so:
class MyTable
...
field :lock_version, :integer
...
end
In this example, all saves to MyTable
will raise an AWS::DynamoDB::Errors::ConditionalCheckFailedException
if a concurrent process loaded, edited, and saved the same row. Your code should trap this exception, reload the row (so that it will pick up the newest values), and try the save again.
Calls to update
and update!
also increment the lock_version
, however they do not check the existing value. This guarantees that a update operation will raise an exception in a concurrent save operation, however a save operation will never cause an update to fail. Thus, update
is useful & safe only for doing atomic operations (e.g. increment a value, add/remove from a set, etc), but should not be used in a read-modify-write pattern.
Credits
Dynamoid borrows code, structure, and even its name very liberally from the truly amazing Mongoid. Without Mongoid to crib from none of this would have been possible, and I hope they don't mind me reusing their very awesome ideas to make DynamoDB just as accessible to the Ruby world as MongoDB.
Also, without contributors the project wouldn't be nearly as awesome. So many thanks to:
Running the tests
Running the tests is fairly simple. In one window, run fake_dynamo --port 4567
, and in the other, use rake
.
Copyright
Copyright (c) 2012 Josh Symonds.
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


fastify-webhook
Fastify Plugin to serve webhooks with some useful default settings.
With this plugin, Fastify will have a route configured for /webhook
POST requests.
Usage
const fastify = require('fastify')()
// example without specifying options, returning a default webhook mapped to '/webhook' that only acknowledge the POST request
fastify.register(require('fastify-webhook'))
// or
// example with custom webhook url and handler, and secret key
// fastify.register(require('fastify-webhook'), {'url': '/custom-webhook', 'handler': myWebhookHandler, 'secretKey': 'secret key'})
//
// note that to use one of handlers bundled with the plugin, you need to get a reference to the plugin script 'src/handlers', and then as handler pass a reference to desired function, like:
// const webhookHandlers = require('fastify-webhook/src/handlers') // get plugin handlers (optional)
// const webhookPlugin = require('fastify-webhook')
// fastify.register(webhookPlugin, { 'url': '/custom-webhook', 'handler': webhookHandlers.echo, 'secretKey': 'secret key'})
//
fastify.listen(3000)
// To test, for example (in another terminal session) do:
// curl http://<IP_ADDRESS>:3000/webhook -X POST -H 'Content-Type: application/json' -d '{"payload":"test"}' => returning a JSON dump of the given data, and no thrown error
// in Windows you need to escape double quote char in the given json body, so do:
// curl http://<IP_ADDRESS>:3000/webhook -X POST -H "Content-Type: application/json" -d "{\"payload\":\"test\"}"
// or put data in a json file and pass with something like: '-d @body.json'
In the example folder there are some simple server scripts that uses the plugin (inline but it's the same using it from npm registry).
Requirements
Fastify ^4.0.1 , Node.js 14 LTS (14.15.0) or later. Note that plugin releases 3.x are for Fastify 3.x, 4.x are for Fastify 4.x, etc.
Sources
Source code is all inside main repo: fastify-webhook.
Documentation generated from source code (library API): here.
Note
By default the plugin map a default handler on the URI /webhook
to be called via POST, otherwise it's possible to change via the setting 'url' in plugin options.
The plugin exposes some handlers, for common base operations (and webhook debug help).
To use one of them, before registering the plugin, you need to get a reference from its src/handlers
source file;
then you can configure the desired one in the setting 'handler' in plugin options.
They are:
acknowledge
(default handler) that simply acknowledge the request, and reply with a simple json responseecho
it dumps the given input data in the (json) responselogger
it dumps some info on the request using Fastify logger but of course for a real world usage you need to specify your own handler function, with arguments '(request, reply)'. Otherwise you can use yours, with signaturefunction handler (request, reply)
.
Other plugin options:
- 'disableWebhook' (default false) to disable the registration of the route for the webhook
- 'enableGetPlaceholder' (default false) to publish via GET a route with the same path of the webhook but returning an HTTP Error 405 Method Not Allowed
- 'secretKey' (default null) to specify a string as secret key that callers of the webhook must provide, or webhook will reply with an error
- 'preHandlers' is a list of functions to be used as preHandler in the specific route of the webhook; currently the list contains an internal function to check the secret key (if given); otherwise you can define and use yours, with signature
function preHandler (request, reply, done)
.
Note that there is not a good general way to handle (usually user-specific) token in requests, so this is not managed via the plugin, but in examples and tests you can find some info.
License
Licensed under Apache-2.0.


The Vaporist E-liquids are made to entice your gustatory and olfactory senses.
Only the best and most flavourful ingredients are used to create such harmoniously palatable E-liquids.
The Vaporist premium E-liquids are proudly and meticulously crafted in Canada.
DetailsWe are proud of our Canadian roots!
Proper manufacturing provides consistency, every time!
Properly balanced flavours, regardless of ratios. Quality over quantity!
From the beginning vaper to the advanced rebuilder, our different VG/PG ratio lineups caters to everyone!
No matter the profile, we are confident you will find an ADV from The Vaporist!
Our high/Max VG lineup is aimed for vapers with recent setups or advanced rebuilders. Great care has been brought to provide an outstanding flavor while providing thick vapor production!
Our High PG lineup is aimed at the low wattage vapers or older setups (CE4/Nautilus/Aerotank style atomizers). These flavours will properly wick and provide outstanding flavour profiles.
Lorem ipsum dolor sit amet, alia nulla simul has ne, sit nusquam placerat ne. In mei delicata aliquando, purto vocent nusquam no vis, ne nec tincidunt disputando. Pro feugiat quaerendum in.
Phone number:+123456789.


Real Time Traffic
50+ mph
<30 mph
30-40mph
Unspecified
Road Work & Incidents
Road Work
Incidents
Traffic Cameras
SELECT CAMERA
Please enable Javascript to view this map.


A unique identifier.
The UniqueId type represents the value of a unique identifier.
Generates a new UniqueId.
The new constructor returns a new UniqueId generated from an internal source. The method to generate the value is similar to Roblox's implementation.
Returns a UniqueId from components.
The new constructor returns a UniqueId composed of the components from each argument.
A sequential value.
The Index property represents the sequential portion of the unique identifier. This value is generated such that it is almost certain to be unique, but is also predictable.
The Random property represents the random portion of the unique identifier. This value is generated from a pseudo-random source.
A time-based value.
The Time property represents the time portion of the unique identifier. This value generated based on the time.
Returns whether two UniqueId values are equal.
The equal operator returns true if both operands are UniqueId, and each corresponding component is equal.


This document is the result an e-mail conversation between Marco Baringer and Dave Roberts. The conversation started with Dave Roberts' blog posting talking about REST in the context of web applications.
Marco Baringer's writing is enclosed in boxes like this one, while Dave Roberts' writing is enclosed in boxes like this.
In short: The REST camp is right, but our definition of "web application" is too wide. The term "web application," in its common use, appiles to two radically different things whcih both travel over HTTP:
I'd argue that REST is the perfect (and only) tool for the first category, while continuations work great for the second. I'd also argue that most "web sites" are a mix of both. Take amazon for example, when I use amazon there are two independant things i want to do 1) browse for books and 2) buy books. the browsing part should follow the REST principles, however the buying part should not, purchasing a book is an inherently statefull operation which requires the server to maintain some of the client's state. The order of operations in purchasing a book is complex and, imnsho, much easier to express using continutations. At the same time writing the code to show book details is much easier when you just transalte a url into an sql query and show the resulting rows.
I'm not totally convinced that the checkout portion can't be made REST as well. The REST crowd actually thinks so. Clearly, there is state, but they would say that the state should either return with the next request or should be stored on the server side in the database, not carried in the web server. That may be bending the rules on REST, though.
i'm not going to argue that i can't, only that it shouldn't.
The application, and its underlying database, have a certain state which is global and shared by everyone. Then there is the state of GUI, this information (what page we're looking at, what the navigation history is, etc.) may be implemented in the DB but it's not application state, its GUI state.
When the REST guys start sending this GUI state in the response objects they run into a number of obstacles (since they need to send all of the GUI state for every response): 1) object marshalling, 2) malicious clients 3) request/response size limits. Continuation based apps need only send: 1) a key (generally a random string a few tens of characters long) specifying the session and the point in the sesion history, 2) what's changed in the user interface.
Right. I would agree that it's much easier to just use standard session data like most web servers provide today. The REST guys would just argue that it's less scalable. And they're right, too. The big question is, does it only matter for sites like Amazon or EBay which are massive, or does it come into play at lower levels of scalability, too.
The REST guys are against sessions? I don't think that's what they meant; how else would you ever implement anything personalized?
Yep, they're against sessions and consequently generally down on personalization. Their answer is that this isn't REST.
I should probably qualify it, though. *In the context of REST*, they are down on those concepts. I think you'd find many people that would say, "Sure, the only way to implement personalization is with sessions, and that's fine when you want to go that way, but realize that you are now stepping out of a REST architecture style and you're going to pay that penalty" This is one reason why I think REST is most applicable to web applications that would otherwise use SOAP (i.e. "web services," not something interactive).
Maybe this is just another case of distinguishing between web apps as "collections of resources named by urls" and web apps as "applications which happen to use the browser for a GUI"
Yes, indeed.
This doesn't mean that you can't shoe-horn the statefull part of the application into REST but it does mean that REST is not the best option for this (and vice versa).
Right. The question really is, what penalty are you paying when you move outside the REST style, and can you afford that. In some cases, you probably can. My big question is, how much is the penalty for continuations? If it's small, then no biggie. If large, then you really have to think about it. I could see continuations being very large, depending on how they were implemented, and that would definitely push you to larger and larger server front-ends with all the consequent headache.
when you talk about continuations and web apps (interactive applications with a web GUI) there are (mainly) two places where the continutaions come into play:
writing the code - we (some of us at least) would like to write our code sequentially, even though it will be executed asynchronously and certain parts of it may be executed multiple times (think back button and window cloning). there is no penalty here if the contiuations are implemented by a compile time code transformation (as ucw does). [well, there is a slight penalty since we introduce an oscene number of lambda calls, but its basically 0 compared to reading/writing the requests/response (trust me on this)]. Even when you use "full" built in continuations (as SeaSide and PLT scheme do) the overhead is still little more than a couple function calls and some memory (stact) manipulation.
The only thing I was worried about was the memory allocation, not the time to render the page. As you say, either style's speed difference is swamped by the cost of the I/O. Again, my main issue is how much memory I'm sucking up with all those various continuations hanging around. And remember that I have multiple continuations per page (every link, right?). That could easily be many KB per continuation. Depending on how much back-button saving state I want to hang around, I could literally have MBs per user. If my policy is to let that stuff hang around until a timeout of some sort or an explicit logout/finish purchase point, I have to worry about how many people abandon their session, etc. You get the idea.
a ucw session object consists of:
each session frame object consits of:
what you (and i) should be worried about are all those closure objects. a closure consists of two things: 1) a code vector and 2) an environment. the code vector is shared across all closures in all sessions, so all we're really worried about is the environment. the environment is bascially a (constant size) vector of objects, assuming has a page has ten links each with an action (in ucw the actions are generally simple forms which call some function on the srever) we'll have a couple objets in the environment. each of these objects is however shared across all the closure in the page. in all honesty i don't think the cost of memory is such an issue , i did some quick math and came up with about 400 bytes per session + 700 bytes per request/response iteration (assuming you backtrack about 10 objects per request/response and assuming each "slot" is 4 byte wide (immediate objects are saved in the slot, non immediates require some memory for the data as well). would this be a big issue for sites like amazon and ebay? yes. is this an issue for 99% of the web apps out there? considering how the cost of 1GB of RAM, no.
what is a much bigger issue is farming out sessions. if you don't want to get swamped in serializeng/deserializng objects and sending them over the network you really need to leave a session on the same machine for its entire life, while dobale (i should have a client who will fund this work in a few months) it's not immediate and you still run the risk of having one machine at 100% CPU and another idle.
This is pretty easy and done all the time. That's why load balancers implement a sticky policy to keep a given client bound to the same front-end web server. The issue then becomes how critical that data is in the event of a server failure, but the scalability model has been conquered.
saving the state - when the user clicks on a link we want to make sure that the state of the app as the _user_ saw it on the page corresponds to the state on the server, even when the user has used the back button. in this case you, developer, have to tell the framework what state shoud be saved and restored based on the user's request and what state is global and doesn't change even though the user has "undone" some pages.
generally we save the state regarding the GUI (values of forms, what the "current" page is, state of the navigation menu) and don't save the general application state (user data, db manipulations, etc.) how much you save is up to the developer. i'd like to point out that this penalty (saving and restoring GUI state) is taken even by REST apps (if they want to do things right), it's just that's its done by hand.
Yes, agreed. State is state. You have to store it somewhere and then restore it when you get another request.
the difference is who has to deal with that job. in a continuation based system you usally end up with a framework where the saving and restoring is done by the framework itself, all you (developer) have to do is use tha data. in the rest frameworks i've seen you have to do this work yourself.
Right, agreed. The explicit model forces you to do more work. The continuation model makes this seamless, but could hand you a huge scalability problem if you aren't conscious about what's happening behind the scenes. Like any high-level paradigm (language, for instance), they can make some things seem really easy, but that can mask performance problems if you aren't careful.
The problem most people face is that you never hear about applications-which-use-browser-for-a-GUI, what you see 99% of the time are regular old web applications whose underyling paradigm hasn't changed since 1992. Those real world applications (#2 above) are usually deployed on an intranet and neither look nor feel (nor are considered) different from a regular desktop application.
How do you mean that you never hear about those? Can you give me an example of an application that you know about that works that way?
i've developed a document management systems for a law office and various patient management systems for hospitals, i've worked on buisness intelligence and e-learning tools. None of these apps were ever accessable to the public nor did they ever have to deal with more than 50 simultaneous users, though they did have extremly complex user interactions.
Ah, got it. I guess that's the sort of app that I think that continuation-based methods would work well on. If the user count is low and the scalability doesn't have to go higher than those sorts of numbers, I see no reason not to use almost whatever technique is most expedient (continuation, REST, or something else).
I don't think it's ever been proven, but i've a strong feeling that state machines are another way of writing cps code (and vice versa). if we have some code like this:
Actually, I think it has been proven, but perhaps in another context. Really, this is just the same old tension between old linear, sequential programming and event-driven programming, ala the original Mac GUI in 1984. The only difference between the two is where you store the state of the state machine. In the sequential code/continuation case, it's in the activation records sitting on the stack. In the state machine case, it's more explicit. Neither is ultimately more expressive, just different.
right. however i still think that while the underlying machinery is more explicit in the state machine the high level goals are more explict in the continuation case.
I suppose it depends on what you're comfortable with. Again, I often think in terms of state machines anyway. Either way, we're mapping a series of HTTP requests onto some sort of model and using that to simplify our thinking. You think sequentially; I often think in terms of state machines.
(do-one-thing) (show-a-page) (do-another-thing) (show-another-page) (done)
that's basically the same as writing:
(loop with state = 'initial do (case state (initial (do-one-thing) (print 'a-page) (setf state 'post-one-thing)) (post-one-thing (do-another-thing) (print 'another-page) (setf state 'post-another-thing)) (post-another-thing (done) (setf state 'done))))
it's just a lot harder to read.
Yup. I wonder if it wouldn't make sense to develop a small interpreted Lisp language (in Lisp, of course) that would drive the high-level page flow and allow you to save off continuations appropriately. Either that or some radical macros that would allow you to write in a very linear style but would explode to a full state machine with very optimized state storage. That's the fun thing about Lisp, I suppose--everything is possible and relatively easy to implement.
i had guessed you knew about UnCommom Web. UCW contains a cps transformer and the machinery for saving the lexical and GUI state, developers don't even need to know what a continuation is to use it, they just write:
(defaction do-something ((c my-task-component)) (do-one-thing) ;; pass do-another-thing the informaiot collected in a-page (do-another-thing (call 'a-page)) ;; pass done the information collected in another-page (done (call 'another-page)))
except for the html generation that's all there is to it. the code will "block" when the forms (call 'a-page) and (call 'another-page) are executed and will only continue when those pages "return".
Got it. Very interesting. Yes, that's basically what I had in mind. Given that you're doing this in CL, you have to fake the continuations with a macro transformation into CPS style. That's cool though. Any idea how much state you're saving per continuation?
the components a-page and another-page will need to "answer" at some point so that the forms (call 'a-page) and (call 'another-page) return. let's assume those component are immediate (don't ever call other components) and present two links, one which returns t and one which returns nil. let us also assume the components backtrack two places each (useing the shallow copyer). in order to complete the action do-something there will be, with these assumpitons, two pages seen by the user. so:
that's basically it. should the user use the back button certain functions will be called again but the amout of memory used won't increase.
note the each link in the page does not create a continuation. each link simply calls a function, the "continuations" only come into play when a component answers. each component object has its continuation and these continuations are nothing more than closures (so the code vector itself is compiled and shared across all instances while only the envornment changes from component to component).
My head is spinning at this point. I need to dig into the code and see what's really doing on. I can't follow the thread of control at the time of rendering and overall through the application from that description above (not your fault; I just don't understand enough UCW terminology yet).
you can't understand because te only place its described is the code. here's a high level description of the standard rerl implementation, tell me if its clear enough:
every time a user "uses" a ucw app they have one session object, every request/response cycle gets one session frame. every time a ucw recieves an http request it basically does this:
uncommon web has a main loop which looks more or less like this:
(loop for request = (read-request) for state = (fetch-state request) for new-state = (handle-action state request) do (setf (fetch-state request) new-state))
a while ago i wrote the control loop for a dynamic (states and state transfer functions were put into hash tables and changed at run time) state machine and it's main loop looked very similar to that.
Right. I'm not sure that's actually much easier to read/write at the end of the day. You're just making a state machine with a hashtable doing the state lookup and dispatch rather than a case.
depends on who writes it. in ucw it's written by the framework so i don't really care (or know :)) how hard/easy it is to write.
Personally, I find state machines very natural to write in. Perhaps that's my hardware background coming through. Rather that avoid the abstraction, I'm more willing to just embrace it. Its sort of like Linus writing Linux in C and disallowing all sorts of typedefs because he wants everybody to know when they're manipulating a structure and when they aren't. Part of me prefers to map my brain onto the underlying problem such that it's more well understood.
I'd assume that that part of your brain knows when the mapping is helpfull and when it's not (your brain doesn't map LOOP constructs into the underlying assembler).
Right, agreed. My motto is just to pick an abstraction that works. I'm not in the camp that all you have is a hammer and therefore everything should be viewed as a nail. ;-)
the reason ucw exists is that, in web applications, the underlying techincal details are so diametrically opposed to the high level problem. attempting to map "do this, then if A do that else loop over page B" to the http request/response paradigm is such a pain that you just give up on complex interactions.
[This is provacative but not complety untrue:
The REST camp is trying to simplify the world so that the problem ceases to exist. The continuation camp is solving the problem.]
You're right. That's provocative. ;-) I don't see that the REST camp is avoiding the problem so much as they are trying to make sure that people understand the tradeoffs. Even the REST people will say that sometimes you should just whack out something quickly with SOAP if you know that scalability is never going to be an issue. I think for interactive apps, they would just make sure that everybody is aware of the tradeoffs and then say, "Hey, if you can live with the scalability limits imposed by your particular architectural style, then fine. Get on with it."
you're trying to introduce the vaice of reason into this conversation. STOP IT! :)
Anyway, my point(s):
Yup, fully agree. In fact, that was exactly my motivation for asking the question. Continuations are clearly nice. But how far can they take you and where do they break down. Clearly REST is more scalable, blah, blah, but it's also a bit more complex because you may have to fit your application into a style that is less natural. Therefore, when should somebody go through the pain of choosing a REST style when it isn't natural?
Continuations in web apps do not allow you to do anything which can't be done without them, though i'd argue that there are certain user interactions which are too complex to manage (for a developer's point of view) without them.
I'd probably agree with that, but again, the threshold for "too complex" is probably higher than yours is, just because I seem to be more comfortable with a state machine architectural style. But yes, I agree.
Continuations have a non zero cost. However much of that cost already exists in REST apps when they attempt to offer the same functionality as continuation based apps.
It would be interesting to turn this into hard numbers. For instance, exactly how much state is being saved with every continuation?


Willow The more that you say, the lese I know. Wherever you stray I follow.
This has been very useful for my research. Thanks as well!
Comments
This has been very useful for my research. Thanks as well!


--- id: home layout: default title: Home description: Object oriented design patterns in the Rust programming language. ---
In Rust we Trust
Rust, the programming language, is an exciting new language that aims to be safe, concurrent, and practical.
It combines the familiar C style syntax that uses curly braces with the features you'd expect in a modern language.
Rust hopes to "preserve large-system integrity, availability and concurrency" by the separation it creates between its abstractions and implementations.
Design patterns have made a resurgence in recent years with the publication of the 1994 seminal work called Design Patterns: Elements of Reusable Object-Oriented Software (also called the Gang of Four book). It provided a catalog of design patterns that could be used across software systems.
This website takes all the design patterns in the Gang of Four book and turns them into working examples using the language Rust.
Three classes.
As was mentioned, Design Patterns: Elements of Reusable Object-Oriented Software is the main source of information provided on this website.
Yet the Gang of Four book isn't the most approachable for newcomers. A more gentle introduction is the Head First Design Patterns book. It provides very memorable examples with easier to understand explanations.
Rust Design Patterns is completely available as open source. It is hosted in GitHub and can be forked by anyone.
If you have suggestions on how to make these design patterns better, fork it and make a pull request with your updates. If the updates are awesome (which they probably will be) then the pull requests will be merged into the main project.
Rust Design Patterns is a project that Josh Davis started to learn more about design patterns. He wanted to learn how to become a better software engineer yet also learn a new programming language.
If you don't already do so, be sure to follow him on Twitter, GitHub, and Google+.


|
CoreSight Access Library
2.3
ARM CoreSight Access Library - on target CoreSight component control
|
Files | |
| file | cs_cti_ect.h [code] |
| CS Access API - program CTI and ECT registers. | |
| file | cs_debug_halt.h [code] |
| CS Access API - access core intrusive debug registers. | |
| file | cs_debug_sample.h [code] |
| CS Access API - access core debug sampling registers. | |
| file | cs_etm.h [code] |
| CS Access API - ETM/PTM programming. | |
| file | cs_etm_types.h [code] |
| CS Access API - ETM/PTM programming. | |
| file | cs_etmv4_types.h [code] |
| CS Access API - ETM/PTM programming. | |
| file | cs_init_manage.h [code] |
| CS Access API - Library Initialisation and Management. | |
| file | cs_pmu.h [code] |
| CS Access API - access core PMU registers. | |
| file | cs_reg_access.h [code] |
| CS Access API - Generic CoreSight register access. | |
| file | cs_stm_types.h [code] |
| CS Access API - STM programming. | |
| file | cs_sw_stim.h [code] |
| CS Access API - software stimulus trace ports. | |
| file | cs_topology.h [code] |
| CS Access API - ROM table and topology functions. | |
| file | cs_trace_metadata.h [code] |
| CS Access Utility Library - Examples : functions to extract component meta-data for post run analysis. | |
| file | cs_trace_sink.h [code] |
| CS Access API - functionality relating to trace sinks and buffers. | |
| file | cs_trace_source.h [code] |
| CS Access API - generic functionality relating to trace sources. | |
| file | cs_ts_gen.h [code] |
| CS Access API - program CS Timestamp Generator. | |
| file | cs_types.h [code] |
| CS Access API - type declarations for API. | |
| file | cs_util_create_snapshot.h [code] |
| CS Access Utility Library - Create trace snapshot files for DS-5 import. | |
| file | cs_utility.h [code] |
| CS Access Utility Library - Auxiliary functions using CS Access API. | |
| file | csaccess.h [code] |
| CoreSight Access Library API : On target library for programming CoreSight infrastructure. | |
| file | csregisters.h [code] |
| CS Access API: CoreSight architectural definitions. | |
| file | csregistration.h [code] |
| CS Access Utility Library - CoreSight board registration functions. | |


Quicklinks
Access to the systems and resources you use often.
myRMIT
Enrolment Online
Blackboard (LMS)
Student email
Announcements (myRMIT)
Library
myTimetable
Study help
RMIT Connect


title=Books date=2018-10-20 type=page status=published ~~~~~~
I've authored, or co-authored, six books so far. The latest and greatest of which are Reactive Spring and Cloud Native Java, about which you can find more information on this page.
I'm working on a new book that aims to introduce people to the wide world of reactive Spring.
Follow @ReactiveSpring on Twitter for more
I wrote this book with my buddy Kenny Bastani. It's all about how to build applications that survive and thrive in the cloud in terms of Spring Boot, Spring Cloud, and cloud technologies like Cloud Foundry. Consider this your one-stop shop for building cloud-native applications. It's available in a number of languages (left to right, top to bottom): English, Chinese, Korean, and Russian.
Follow @CloudNativeJava on Twitter for more


January-like air set to descend upon eastern half of US
The coldest air of the season is hitting the East Coast this morning and it’s only going to get colder.
Interested in Weather?
Add Weather as an interest to stay up to date on the latest Weather news, video, and analysis from ABC News. Weather Add Interest
With this cold air moving over the Great Lakes up to 14 inches of lake effect snow fell in the Upper Peninsula of Michigan and up to 4 inches in Erie Pennsylvania.
A Freeze Warning has been issued for many states from the Deep South all the way to New York City. The first freezing temperatures of the season are on the way by tonight and into Saturday morning.
With even a little wind, the wind chill will be in the teens in the Midwest and parts of the Northeast for the next 24 hours.
After this cold shot, our attention turns to an even colder air mass early next week that will bring more snow ahead of it from the Midwest into the Northeast.
On Monday morning, the new storm system will already be moving through the Midwest with snow from Chicago to Detroit. A few inches of the white stuff is expected there as well.
By Tuesday, this storm system will move east, brining rain and snow to the Northeast. This time around, big cities could see some snow but it is still too early to say how much and who will get the most.
Heavy lake effect snow is expected around the Great Lakes next week too.
What we do know for sure is that an even colder air mass will move in behind this next storm system.
Wind chills will be below zero for the Midwest and 20s all the way to Texas and the Deep South.
This cold blast moves into the Northeast on Tuesday night into Wednesday, it will feel like January for Washington, D.C., Philadelphia, New York City and Boston next week.


boutputPos arg1 arg2
Signature: StringBuilder -> pos -> unit
|
|
boutputRange arg1 arg2
Signature: StringBuilder -> range -> unit
|
|
fileIndexOfFile arg1
Signature: string -> FileIndex
|
|
fileOfFileIndex arg1
Signature: FileIndex -> string
|
|
mkFileIndexRange arg1 arg2 arg3
Signature: FileIndex -> pos -> pos -> range
|
This view of range marks uses file indexes explicitly
|
mkPos line column
Signature: line:int -> column:int -> pos
|
Create a position for the given line and column
|
mkRange arg1 arg2 arg3
Signature: string -> pos -> pos -> range
|
This view hides the use of file indexes and just uses filenames
|
outputPos arg1 arg2
Signature: TextWriter -> pos -> unit
|
|
outputRange arg1 arg2
Signature: TextWriter -> range -> unit
|
|
pos0
Signature: pos
|
|
posEq arg1 arg2
Signature: pos -> pos -> bool
|
|
posGeq arg1 arg2
Signature: pos -> pos -> bool
|
|
posGt arg1 arg2
Signature: pos -> pos -> bool
|
|
posLt arg1 arg2
Signature: pos -> pos -> bool
|
|
posOrder
Signature: IComparer<pos>
|
|
range0
Signature: range
|
|
rangeBeforePos arg1 arg2
Signature: range -> pos -> bool
|
|
rangeCmdArgs
Signature: range
|
|
rangeContainsPos arg1 arg2
Signature: range -> pos -> bool
|
|
rangeContainsRange arg1 arg2
Signature: range -> range -> bool
|
|
rangeN arg1 arg2
Signature: string -> int -> range
|
|
rangeOrder
Signature: IComparer<range>
|
not a total order, but enough to sort on ranges
|
rangeStartup
Signature: range
|
|
stringOfPos arg1
Signature: pos -> string
|
|
stringOfRange arg1
Signature: range -> string
|
|
trimRangeToLine arg1
Signature: range -> range
|
|
unionRanges arg1 arg2
Signature: range -> range -> range
|
|


jquery-side-navi / left slide demo
Simple Side Navigation with Javascript and Jquery
version
- 0.0.1
tech
- Javascript 5.x- jQuery 1.x
desciption
SideNavi can slide currently form left or right side.You only have to adapting the stylesheet file to
implement your own settings.
using
- slide from left use sidenavi-left.css- slide from right use sidenavi-right.css
- set first parameter value of init method with 'left' or 'right'


Table of Contents
What is {{ CLEARINGHOUSE }}
{{ CLEARINGHOUSE }} is a web-based portal for managing {{ TESTBED }} resources. These resources are donated by users who have installed {{ TESTBED }} on their machines. In return these users are allowed to use resources donated by others. {{ CLEARINGHOUSE }} enables users of donated resources to acquire nodes around the world on which they can then execute programs written in Repy, the {{ TESTBED }} platform programming language. {{ CLEARINGHOUSE }} also lets users to share their resources with other users, and perform a variety of other tasks. For more information about about how {{ CLEARINGHOUSE }} fits with the rest of the {{ TESTBED }} platform, see this page.
How to Register
You are required to fill out five fields as part of the registration process.
- Username. The login name you want to use in the {{ CLEARINGHOUSE }} portal. You will need your username as well as your password to login to the portal.
- Password. You should choose a password that is at least 6 characters in length. Please secure your password by making it obscure enough to evade possible dictionary attacks.
- Password Confirmation. Confirm your password.
- Affiliation. Choose a company name or an institution that you associate with.
- My Public Key. If you have a personal public/private key pair that you would like to use to access {{ TESTBED }} nodes, please select "Let me upload my public key" and select to upload your public key by clicking "Browse.." in the field below. Alternatively, you can have {{ CLEARINGHOUSE }} generate the public/private key pair for you.
How to Login
Enter your username and password to log into the portal.
Lost passwords
If you forget your password or your username, please email {{ TESTBED_DEVELOPERS_MAIL }}. For password reset requests, we validate that you are able to receive mail from the email address listed under the account.
{% include "common/help_contact.html" %}


{% extends 'admin/my_base.html' %} {% block body %} {% if form %}
Convert co-expression neighborhoods to clusters, making GO statistics etc. available for neighborhoods as well


Reducing to the group of retaining 3 pairs and 1 1x2x2 block
Foreword
In the end, there is actually not many moves to choose from. To expand one of the completed pairs into a 1x2x2 block, it must be one of the colored 1x2x2 blocks below. The part with the X symbol is the 4 pairs that have been prepared before.
All the rotations of this step only rotate the R, U faces, and do not destroy the 4 pairs that have been completed in the previous steps.
4 pairs expand 3 pairs and 1 1x2x2 block
The following X part is the completed pair.
Combining edge and center
Turn the edge out between the two old pairs
The two pairs to combine block are on the same layer
The two pairs to combine the block are not on the same layer
Of course, you can also choose to combine another block first.
Combining edge and center
Turn the edge out between the two old pairs
The two pairs to combine block are on the same layer
The two pairs to combine the block are not on the same layer
Complete the Cube
When you have expanded into 1 1x2x2 block and 3 pairs according to the previous instructions, without destroying that 1x2x2 block and 3 pairs, there is only one way to turn, following that only way can be completed the cube.
Example
- Turn 1~4 is combined edge and center
- Turn 5~8 is to expand 1x2x2 block
- Turn 9~15 is the only way that does not destroy the pair and that 1x2x2 block. Follow that way to complete
The RUP Method
This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International License.