|
|||||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |
See:
Description
| Class Summary | |
| AbstractKeyValue | Abstract pair class to assist with creating KeyValue and MapEntry implementations. |
| AbstractMapEntry | Abstract Pair class to assist with creating correct Map Entry implementations. |
| AbstractMapEntryDecorator | Provides a base decorator that allows additional functionality to be added to a Map Entry. |
| DefaultKeyValue | A mutable KeyValue pair that does not implement MapEntry. |
| DefaultMapEntry | A restricted implementation of Map.Entry that prevents
the MapEntry contract from being broken. |
| MultiKey | A MultiKey allows multiple map keys to be merged together. |
| TiedMapEntry | A Map Entry tied to a map underneath. |
| UnmodifiableMapEntry | A Map.Entry that throws UnsupportedOperationException
when setValue is called. |
This package contains implementations of collection and map related key/value classes. These are usually used in maps, however they can be used as data holders in any collection.
The following key/value designs are included:
|
|||||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |


To comply with business standards and industry regulations, organizations must protect sensitive information and prevent its inadvertent disclosure. Sensitive information includes financial data or personal identity data, such as credit card numbers, social security numbers, or health records.
With a data loss prevention (DLP) policy, you can identify, monitor, and automatically protect sensitive information across all Microsoft 365 services.
When a DLP policy looks for a sensitive information type, such as a credit card number, it doesn't just identify a 16-digit number. Each sensitive information type is defined and detected by using a combination of:
These methods help DLP detection achieve a high degree of accuracy while reducing the number of false positives that can interrupt people's work.
With a DLP policy, you can:
You create and manage DLP policies on the Data loss prevention page in the Microsoft 365 Security & Compliance Center.
If your organization has DLP, you can define policies to prevent people from sharing sensitive information in a Microsoft Teams channel or chat session. A DLP policy can also prevent sensitive information being shared with external users. To create a new DLP policy, you must be assigned a role that has permissions to edit DLP them.
Simple settings are designed for the most common requirements of a DLP policy. Advanced settings give you complete control to change each setting.
Allow approximately one hour for your new policy to work its way through your datacenter and sync to user accounts.
Note
To make sure documents that contain sensitive information aren't shared inappropriately in Teams, turn on SharePoint sites and OneDrive accounts, and Teams chat and channel messages.
If someone attempts to share sensitive information in a Teams chat or channel with guests (external users) and you have a DLP policy defined to prevent this occurring, the message is deleted. This deletion happens automatically, and within seconds, according to how your DLP policy is configured. DLP for Microsoft Teams blocks sensitive content when shared with users who have either:
DLP for external chat sessions only works if both the sender and the receiver are in Teams Only mode and using Microsoft Teams native federation. DLP for Teams doesn't block messages in interop with Skype for Business or non-native federated chat sessions.
If a Microsoft Teams user attempts to share sensitive information in a document with guests, either in a Teams channel or chat, and a DLP policy is defined to prevent this happening, the document won't open for those users. The DLP policy must include SharePoint and OneDrive because they're used by Teams to share the document. Users must have a license for Microsoft 365 DLP, which is included in Microsoft 365 E3. However, users don't require a license for Microsoft 365 Advanced Compliance.
Policy tips help to educate and explain to users when an action conflicts with a DLP policy, such as if a message is blocked. If someone attempts to share a social security number in a Microsoft Teams channel, for example, the What can I do? link opens a dialog box. The sender then has options to resolve the issue. There might be an option to override the policy or notify an admin to review and resolve it. You can customize policy tips, providing you have permission to edit DLP policies.
To add Microsoft Teams as a location to existing DLP policies, you must have permissions to edit them.
Allow approximately one hour for the changes to work their way through your datacenter and sync to user accounts.


14.1 Description of Bit
Operations
When compressing and uncompressing
data, often we need to perform operations on less than a
single byte. Therefore, before discussing various methods of
data compression, it is important to become familiar with some
basic operations for working with data one bit at a time.
These operations are necessary because bit operators in C work
only with intrinsic integral operands, which are small. The
operations presented in this section work with buffers
containing any number of bits. Note that the set of operations
presented here is rather incomplete. Specifically, only those
that are used in this chapter and in Chapter
15, are defined.
|


{% extends "layout.html" %} {% block page_title %} Money Claims Prototype {% endblock %} {% block proposition_header %} {% set my_account="2" %} {% include "includes/propositional_navigation.html" %} {% endblock %} {% block content %} {% include "includes/phase_banner_beta.html" %} Back How much have you paid? The total amount claimed is {% if data['mediation-pilot'] == 'on' %}£300{% else %}£1,500{% endif %}. This includes the claim fee and any interest. How much have you paid? When did you pay this amount? For example, {{ date | date('add', 19, 'days') | date('D M YYYY') }} Day Month Year How did you pay this amount? {% if data['partial']=="2" %} {% else %} {% endif %} {% include 'prototypes/prototype-mar-2019/includes/contact.html' %}
The total amount claimed is {% if data['mediation-pilot'] == 'on' %}£300{% else %}£1,500{% endif %}. This includes the claim fee and any interest.
For example, {{ date | date('add', 19, 'days') | date('D M YYYY') }}


|
Panda3D
|
Represents a single TCP or UDP socket for input or output. More...
Public Member Functions | |
| __init__ (ConnectionManager manager, SocketIP socket) | |
| Creates a connection. More... | |
| bool | considerFlush () |
| Sends the most recently queued TCP datagram(s) if enough time has elapsed. More... | |
| bool | flush () |
| Sends the most recently queued TCP datagram(s) now. More... | |
| NetAddress | getAddress () |
| Returns the address bound to this connection, if it is a TCP connection. More... | |
| bool | getCollectTcp () |
| Returns the current setting of "collect-tcp" mode. More... | |
| double | getCollectTcpInterval () |
| Returns the interval in time, in seconds, for which to hold TCP packets before sending all of the recently received packets at once. More... | |
| ConnectionManager | getManager () |
| Returns a pointer to the ConnectionManager object that serves this connection. More... | |
| SocketIP | getSocket () |
| Returns the internal Socket_IP that defines the connection. More... | |
| setCollectTcp (bool collect_tcp) | |
| Enables or disables "collect-tcp" mode. More... | |
| setCollectTcpInterval (double interval) | |
| Specifies the interval in time, in seconds, for which to hold TCP packets before sending all of the recently received packets at once. More... | |
| setIpTimeToLive (int ttl) | |
| Sets IP time-to-live. More... | |
| setIpTypeOfService (int tos) | |
| Sets IP type-of-service and precedence. More... | |
| setKeepAlive (bool flag) | |
| Sets whether the connection is periodically tested to see if it is still alive. More... | |
| setLinger (bool flag, double time) | |
| Sets the time to linger on close if data is present. More... | |
| setMaxSegment (int size) | |
| Sets the maximum segment size. More... | |
| setNoDelay (bool flag) | |
| If flag is true, this disables the Nagle algorithm, and prevents delaying of send to coalesce packets. More... | |
| setRecvBufferSize (int size) | |
| Sets the size of the receive buffer, in bytes. More... | |
| setReuseAddr (bool flag) | |
| Sets whether local address reuse is allowed. More... | |
| setSendBufferSize (int size) | |
| Sets the size of the send buffer, in bytes. More... | |
| Public Member Functions inherited from ReferenceCount | |
| int | getRefCount () |
| Returns the current reference count. More... | |
| ref () | |
| Explicitly increments the reference count. More... | |
| bool | testRefCountIntegrity () |
| Does some easy checks to make sure that the reference count isn't completely bogus. More... | |
| bool | testRefCountNonzero () |
| Does some easy checks to make sure that the reference count isn't zero, or completely bogus. More... | |
| bool | unref () |
| Explicitly decrements the reference count. More... | |
Additional Inherited Members | |
| Static Public Member Functions inherited from ReferenceCount | |
| static TypeHandle | getClassType () |
| Public Attributes inherited from ReferenceCount | |
| int | ref_count |
| The current reference count. More... | |
Represents a single TCP or UDP socket for input or output.
| __init__ | ( | ConnectionManager | manager, |
| SocketIP | socket | ||
| ) |
Creates a connection.
Normally this constructor should not be used directly by user code; use one of the methods in ConnectionManager to make a new connection.
| bool considerFlush | ( | ) |
Sends the most recently queued TCP datagram(s) if enough time has elapsed.
This only has meaning if set_collect_tcp() has been set to true.
| bool flush | ( | ) |
Sends the most recently queued TCP datagram(s) now.
This only has meaning if set_collect_tcp() has been set to true.
| NetAddress getAddress | ( | ) |
Returns the address bound to this connection, if it is a TCP connection.
| bool getCollectTcp | ( | ) |
Returns the current setting of "collect-tcp" mode.
See set_collect_tcp().
| double getCollectTcpInterval | ( | ) |
Returns the interval in time, in seconds, for which to hold TCP packets before sending all of the recently received packets at once.
This only has meaning if "collect-tcp" mode is enabled; see set_collect_tcp().
| ConnectionManager getManager | ( | ) |
Returns a pointer to the ConnectionManager object that serves this connection.
| SocketIP getSocket | ( | ) |
Returns the internal Socket_IP that defines the connection.
| setCollectTcp | ( | bool | collect_tcp | ) |
Enables or disables "collect-tcp" mode.
In this mode, individual TCP packets are not sent immediately, but rather they are collected together and accumulated to be sent periodically as one larger TCP packet. This cuts down on overhead from the TCP/IP protocol, especially if many small packets need to be sent on the same connection, but it introduces additional latency (since packets must be held before they can be sent).
See set_collect_tcp_interval() to specify the interval of time for which to hold packets before sending them.
If you enable this mode, you may also need to periodically call consider_flush() to flush the queue if no packets have been sent recently.
| setCollectTcpInterval | ( | double | interval | ) |
Specifies the interval in time, in seconds, for which to hold TCP packets before sending all of the recently received packets at once.
This only has meaning if "collect-tcp" mode is enabled; see set_collect_tcp().
| setIpTimeToLive | ( | int | ttl | ) |
Sets IP time-to-live.
| setIpTypeOfService | ( | int | tos | ) |
Sets IP type-of-service and precedence.
| setKeepAlive | ( | bool | flag | ) |
Sets whether the connection is periodically tested to see if it is still alive.
| setLinger | ( | bool | flag, |
| double | time | ||
| ) |
Sets the time to linger on close if data is present.
If flag is false, when you close a socket with data available the system attempts to deliver the data to the peer (the default behavior). If flag is false but time is zero, the system discards any undelivered data when you close the socket. If flag is false but time is nonzero, the system waits up to time seconds to deliver the data.
| setMaxSegment | ( | int | size | ) |
Sets the maximum segment size.
| setNoDelay | ( | bool | flag | ) |
If flag is true, this disables the Nagle algorithm, and prevents delaying of send to coalesce packets.
| setRecvBufferSize | ( | int | size | ) |
Sets the size of the receive buffer, in bytes.
| setReuseAddr | ( | bool | flag | ) |
Sets whether local address reuse is allowed.
| setSendBufferSize | ( | int | size | ) |
Sets the size of the send buffer, in bytes.


US vaping-related deaths climb to 39, illnesses to 2,051
U.S. health officials on Thursday reported 2,051 confirmed and probable cases and 2 more deaths from a mysterious respiratory illness tied to vaping, taking the total death toll to 39.
REUTERS: U.S. health officials on Thursday reported 2,051 confirmed and probable cases and 2 more deaths from a mysterious respiratory illness tied to vaping, taking the total death toll to 39.
Last week, the Centers for Disease Control and Prevention reported 1,888 cases and 37 deaths from the illness.
As of Nov. 5, 39 deaths have been confirmed in 24 states and the District of Columbia, the agency said. (http://bit.ly/2NrLYXW)
Investigators have not linked the cases to any specific product or compound, but have pointed to vaping oils containing THC, the psychoactive ingredient in marijuana, as being especially risky.
(Reporting by Manojna Maddipatla and Saumya Sibi Joseph in Bengaluru in Bengaluru; Editing by Shailesh Kuber)


|
BeyondHooperville
A Village Ecodynamics Project simulation
|
Classes | |
| class | file |
Public Member Functions | |
| void | init () |
| synchronized void | write (String str, String filename, boolean usingYr, int yr) |
Unified data logging, avoids many redundant buffer flushed each sim year.
Examples of usage are in Agent.m in the methods saveLinks and saveLinksBRN.
| void com.mesaverde.village.Logger.init | ( | ) |
Initialize the file array to known values so the empty check works properly.
| synchronized void com.mesaverde.village.Logger.write | ( | String | str, |
| String | filename, | ||
| boolean | usingYr, | ||
| int | yr | ||
| ) |
Main logging function. Call this function to log output.
Give this function a string, a filename, a year and tell it whether to use the year in the filename. The string should not include the trailing newline. If you don't need a year, just pass 0 and set usingYear: NO.
Perhaps "filename" is too strong a word. The function is not limited to flat files. It could just as easily be adapted to write to a database. This is just the data storage name, such as "links." This function maintains its own open file handles and indexes by this name. In the current implementation, a call to this function using "links" as the filename and 649 as the year would generate a persistent file named "output/links649.out" and all subsequent calls using those parameters will write to that same file.
| str | The string to log. Should not include the trailing newline. |
| filename | The name of the file to write to |
| usingYr | Should the output file include the year? |
| yr | The current year of the simulation. |


Checking Location...
Unable to retrieve your location. Please enter your location on the search bar.
Units:
SI
US
Tue 5/13
Partly cloudy throughout the day.
Minalin, Pampanga
Humidity: 65%
Cloud Cover: 40%
5:55 AM |
6:19 PM
Light rain throughout the week, with temperatures peaking at 100°F on Wednesday.


A simple subclass of SexpProcessor that tracks method and class stacks for you. Use method_name, klass_name, or signature to refer to where you’re at in processing. If you have to subclass process_(class|module|defn|defs) you must call super.
# File lib/sexp_processor.rb, line 419 def initialize super @sclass = [] @class_stack = [] @method_stack = [] @method_locations = {} self.require_empty = false end
Adds name to the class stack, for the duration of the block
# File lib/sexp_processor.rb, line 431 def in_klass name if Sexp === name then name = case name.first when :colon2 then name = name.flatten name.delete :const name.delete :colon2 name.join("::") when :colon3 then name.last.to_s else raise "unknown type #{name.inspect}" end end @class_stack.unshift name yield ensure @class_stack.shift end
Adds name to the method stack, for the duration of the block
# File lib/sexp_processor.rb, line 455 def in_method(name, file, line) method_name = Regexp === name ? name.inspect : name.to_s @method_stack.unshift method_name @method_locations[signature] = "#{file}:#{line}" yield ensure @method_stack.shift end
Tracks whether we’re in a singleton class or not. Doesn’t track actual receiver.
# File lib/sexp_processor.rb, line 468 def in_sklass @sclass.push true yield ensure @sclass.pop end
Returns the first class in the list, or @@no_class if there are none.
# File lib/sexp_processor.rb, line 479 def klass_name name = @class_stack.first if Sexp === name then raise "you shouldn't see me" elsif @class_stack.any? @class_stack.reverse.join("::").sub(/\([^\)]+\)$/, '') else @@no_class end end
Returns the first method in the list, or “none” if there are none.
 Tracks all nesting. If you have to subclass and override this method, you can clall super with a block.
# File lib/sexp_processor.rb, line 506 def process_class(exp) exp.shift unless auto_shift_type # node type in_klass exp.shift do if block_given? then yield else process_until_empty exp end end s() end
Process a method node until empty. Tracks your location. If you have to subclass and override this method, you can clall super with a block.
# File lib/sexp_processor.rb, line 523 def process_defn(exp) exp.shift unless auto_shift_type # node type name = @sclass.empty? ? exp.shift : "::#{exp.shift}" in_method name, exp.file, exp.line do if block_given? then yield else process_until_empty exp end end s() end
Process a singleton method node until empty. Tracks your location. If you have to subclass and override this method, you can clall super with a block.
# File lib/sexp_processor.rb, line 541 def process_defs(exp) exp.shift unless auto_shift_type # node type process exp.shift # recv in_method "::#{exp.shift}", exp.file, exp.line do if block_given? then yield else process_until_empty exp end end s() end
Process a module node until empty. Tracks all nesting. If you have to subclass and override this method, you can clall super with a block.
# File lib/sexp_processor.rb, line 559 def process_module(exp) exp.shift unless auto_shift_type # node type in_klass exp.shift do if block_given? then yield else process_until_empty exp end end s() end
Process a singleton class node until empty. Tracks all nesting. If you have to subclass and override this method, you can clall super with a block.
# File lib/sexp_processor.rb, line 576 def process_sclass(exp) exp.shift unless auto_shift_type # node type in_sklass do if block_given? then yield else process_until_empty exp end end s() end
Process each element of exp in turn.
# File lib/sexp_processor.rb, line 591 def process_until_empty exp until exp.empty? sexp = exp.shift process sexp if Sexp === sexp end end
Returns the method signature for the current method.
# File lib/sexp_processor.rb, line 601 def signature "#{klass_name}#{method_name}" end


| Package | flare.analytics.cluster |
| Class | public class HierarchicalCluster |
| Inheritance | HierarchicalCluster Operator |
| Subclasses | AgglomerativeCluster, CommunityStructure |
Once a clustering has been computed, each node included in the
analysis will be annotated with both its cluster membership
using the name indicated by the clusterField
property.
By default, this class will attempt to pick an optimal level of the
cluster tree at which to break up items into discrete clusters.
However, clients can invoke the labelNodes
method with
a specific merge number which indicates the point at which to "cut"
the cluster tree into discrete sub-clusters. This class also annotates
nodes with a sequence number using the name indicated by the
sequenceField
property. The sequence number allows items
to be sorted in a way that attempts to preserve the clustered structure.
Additionally, the clusterTree
property will return a
flare.vis.data.Tree
instance that can be used to
visualize the structure of the cluster tree.
| Property | Defined by | ||
|---|---|---|---|
| clusterField : String The property in which to store cluster indices.
| HierarchicalCluster | ||
| clusterTree : Tree
[read-only] The cluster tree of detected community structures.
| HierarchicalCluster | ||
| criteria : Array [read-only] Computed criterion values for each merge in the cluster tree.
| HierarchicalCluster | ||
| enabled : Boolean Indicates if the operator is enabled or disabled.
| Operator | ||
| group : String The data group to cluster.
| HierarchicalCluster | ||
| parameters : Object
Sets parameter values for this operator.
| Operator | ||
| sequenceField : String The property in which to store sequence indices.
| HierarchicalCluster | ||
| visualization : Visualization
The visualization processed by this operator.
| Operator |
| Method | Defined by | ||
|---|---|---|---|
|
Creates a new HierarchicalCluster instance.
| HierarchicalCluster | ||
|
applyParameters(op:IOperator, params:Object):void
[static]
Static method that applies parameter settings to an operator.
| Operator | ||
|
labelNodes(merge:int = -1):void
Labels nodes with their cluster membership, determined by
the given merge number.
| HierarchicalCluster | ||
|
operate(t:Transitioner = null):void
Performs an operation over the contents of a visualization.
| Operator | ||
|
setup():void
Setup method invoked whenever this operator's visualization
property is set.
| Operator |
| clusterField | property |
clusterField:String
[read-write]The property in which to store cluster indices. This property is used to annotate nodes with the community they belong to (indicated as an integer index). The default value is "props.cluster".
Implementation public function get clusterField():String
public function set clusterField(value:String):void
| clusterTree | property |
clusterTree:Tree
[read-only] The cluster tree of detected community structures. The leaf nodes
correspond to each of the nodes in the input graph, and include the
same data
property. Non-leaf nodes indicate merges
made by the clustering algorithm, and have data
properties that include the merge
number (1 for the
first merger, 2 for the second, etc), the criterion
value computed for that merge, and the size
of the
cluster rooted at that node (the number of descendants in the
cluster tree).
public function get clusterTree():Tree
| criteria | property |
criteria:Array
[read-only]Computed criterion values for each merge in the cluster tree.
Implementation public function get criteria():Array
| group | property |
group:String
[read-write]The data group to cluster.
Implementation public function get group():String
public function set group(value:String):void
| sequenceField | property |
sequenceField:String
[read-write]The property in which to store sequence indices. This property is used to annotate nodes with their sequence index along the computed cluster tree. This value can be used to sort the nodes in a way that best preserves community structure. The default value is "props.sequence".
Implementation public function get sequenceField():String
public function set sequenceField(value:String):void
| HierarchicalCluster | () | constructor |
public function HierarchicalCluster()
Creates a new HierarchicalCluster instance.
| labelNodes | () | method |
public function labelNodes(merge:int = -1):void
Labels nodes with their cluster membership, determined by the given merge number. If the merge number is less than zero or unprovided, the merge number that maximizes the clustering criteria will be assumed.
Parametersmerge:int (default = -1 ) — the merge number at which to compute the clusters
|


Deno Markdown Site
Home
About
Contact
Home
Using
deno-md-site
you can generate a static site using just a single
.md
file.


|
Notices for file(s):
/rxandroid
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. |
|
Notices for file(s):
/changeloglib
/* * ****************************************************************************** * Copyright (c) 2013-2014 Gabriele Mariotti. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * ***************************************************************************** */ |
|
Notices for file(s):
/commons-io
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ |
|
Notices for file(s):
/AndroidSlidingUpPanel
/* * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ |
|
Notices for file(s):
/SeekArc
The MIT License (MIT) Copyright (c) 2013 Triggertrap Ltd 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. |
|
Notices for file(s):
/ShowCaseView
/* * Copyright 2014 Alex Curran * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ |
|
Notices for file(s):
/DiskLruCache
/android-support-v4 /* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ |
|
Notices for file(s):
/butterknife
/hugo /timber Copyright 2013 Jake Wharton Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. |
|
Notices for file(s):
/gson
Copyright (c) 2008-2009 Google Inc. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. |
|
Notices for file(s):
/android-support-v7-appcompat
/volley /* * Copyright (C) 2012 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ |
|
Notices for file(s):
/android-support-v7-cardview
/android-support-v7-palette /android-support-v7-recyclerview /* * Copyright (C) 2014 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ |
|
Notices for file(s):
/lastfm-java
/* * Copyright (c) 2012, the Last.fm Java Project and Committers All rights * reserved. Redistribution and use of this software in source and binary forms, * with or without modification, are permitted provided that the following * conditions are met: - Redistributions of source code must retain the above * copyright notice, this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above copyright notice, * this list of conditions and the following disclaimer in the documentation * and/or other materials provided with the distribution.  IN NO * EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ |
|
Notices for file(s):
/dagger
/flow /mortar Copyright 2013 Square, Inc. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. |
|
Notices for file(s):
/EventBus
/* * Copyright (C) 2012 Markus Junginger, greenrobot (http://greenrobot.de) * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ |
|
Notices for file(s):
/android-support-v7-mediarouter
/* * Copyright (C) 2013 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ |
|
Notices for file(s):
/drag-sort-listview
/* * DragSortListView. * * A subclass of the Android ListView component that enables drag * and drop re-ordering of list items. * * Copyright 2012 Carl Bauer * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ |
|
Notices for file(s):
/NanoHTTPD
Copyright (c) 2012-2013 by Paul S. Hawke, 2001,2005-2013 by Jarno Elonen, 2010 by Konstantinos Togias All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the NanoHttpd organization nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |


Please choose an animal that you would like to learn about.
The argentine black and white tegu is a species of tegu lizard that lives in South America. It is the largest species of tegu, growing 4.0-4.5 ft long and weighing up to 5.5-15.4 lbs, with the males being bigger. They are omnivorous, eating both vegetation and meat. This species of tegu are kept as pets and are often explained as dog like if properly socialized. However, they are difficult lizards to keep because of their size and needs, and if not properly socialized can be very aggressive and territorial, and should only be kept by those prepared for their needs.
The American Kestrel is the smallest and most common species of Falcon in North America. Depending on the sex, the Kestrel can range from the size and weight of a Blue Jay to a Morning dove, with females being the larger of the two sexes. They are ambush predators, mostly eating insects, small lizards, mice and small birds. The American Kestrel is a common bird used in Falconry, a sport which uses Raptors to hunt. They are one of two birds beginner Falconers are able to use. The other being Red-tailed Hawks.
The Maned Wolf is a large canine located in South America. Weighing 44-66 lbs and being about 3 feet tall, the maned wolf is the biggest canine in South America. Maned wolves are omnivorous, eating both small and medium sized prey items, such as small mammals, birds and fish. They also eat plant matter like sugarcane, tubers and fruit. Despite having wolf in the name, the maned wolf is not a species of wolf at all, and is in fact the only species in it's genus, Chrysocyon (meaning 'golden dog').


Performance of awk vs. other languages
Mon 4 May 13:48:22 BST 2020
I was just wondering how would awk compare to other scripting languages such as Perl, Python, etc and, for fun, also Go and C. In the end it all comes down to what is the task that you want to do with it but I though I would do some quick tests...
The test I did was calculating the number Pi iteratively. I didn't want to use any of the special features that each language have and I calculated it with a specially inefficient method. This would roughly give me an estimate of how fast each language each is on "brute force" type of programs.
The code for the awk implementation was:
BEGIN {
max = 2 ** 22
ex = -1
for (i=1; i<max; i++) {
ex = -ex
under = 2*i - 1
piplus = (4/under)*ex
pi = pi + piplus
}
printf "%.f, %.10f\n",max,pi
}
This represents the Leibniz Formula for Pi calculating 2^22 iterations. The other languages implementations are exactly the same lines of code but in their respective languages.
These were the results:
| Time in ms | Times slower than Go | Language |
|---|---|---|
| 0.023 | 1.0 | Go |
| 0.032 | 1.4 | C |
| 0.230 | 10.0 | Node.js |
| 0.526 | 22.9 | Lua |
| 1.311 | 57.0 | awk |
| 1.431 | 62.2 | Perl |
| 1.449 | 63.0 | Python |
| 10.345 | 449.8 | bc |
Even though this test is not the most representative ever, it shows that for this type of code can perform slightly faster than Perl or Python.
Copyright © 2019 Cristian Aria


object FitnessFunctions
A collection of standard fitness functions.
Custom fitness functions can be defined by creating any function with a type of FitnessFunction.
val CE: (mappingFunction: (Double) -> Double) -> SingleOutputFitnessFunction<Double>
Classification Error fitness function for programs that operate on doubles. |
|
val MAE: SingleOutputFitnessFunction<Double>
Mean absolute error fitness function. |
|
val MSE: SingleOutputFitnessFunction<Double>
Mean-Squared Error fitness function for programs that operate on doubles. |
|
val RMSE: SingleOutputFitnessFunction<Double>
Root Mean-Squared Error fitness function for programs that operate on doubles. |
|
val SSE: SingleOutputFitnessFunction<Double>
Sum-of-squared errors fitness function. |
|
val thresholdCE: (threshold: Double) -> SingleOutputFitnessFunction<Double>
Threshold Classification Error fitness function. |
|
const val UNDEFINED_FITNESS: Double
Large constant value for fitness in the cases when either a program is un-evaluated or the fitness computation overflows. |


| Created: | 11/23/2018 4:34:36 PM |
| Modified: | 4/28/2019 10:36:50 PM |
| Project: | |
| Advanced: |
| Attribute |
|
Private int description |
|
Details:
|
|
Private int make |
|
Details:
|
|
Private int model |
|
Details:
|
|
Private int id |
|
Details:
|
|
Private int vendorType |
|
Details:
|
|
Private int containedIn |
|
Details:
|
|
Private int class |
|
Details:
|
|
Private int relativePosition |
|
Details:
|
|
Private int name |
|
Details:
|
|
Private int hardwareRevision |
|
Details:
|
|
Private int firmwareRevision |
|
Details:
|
|
Private int softwareRevision |
|
Details:
|
|
Private int serialNumber |
|
Details:
|
|
Private int alias |
|
Details:
|
|
Private int assetID |
|
Details:
|
|
Private int isFieldReplaceable |
|
Details:
|
|
Private int manufactureDate |
|
Details:
|
|
Private int uris |
|
Details:
|
| Element | Source Role | Target Role |
|
SensedValue Class |
Name: |
Name: source |
|
Details:
|


--- layout: post title: "Postel's law as a profunctor" description: "When viewing inputs and outputs as sets, Postel's law looks like a profunctor." date: 2021-11-29 7:10 UTC tags: [Software Design] image: "/content/binary/misaligned-drain-pipes.jpg" image_alt: "Misaligned drain pipes." --- {% include JB/setup %}
{{ page.description }}
This article is part of a series titled Some design patterns as universal abstractions. Including the present article in that series is a bit of a stretch, since Postel's law isn't really a design pattern, but rather a software design principle or heuristic. I still think, however, that the article fits the spirit of the article series, if not the letter.
This article is heavily inspired by Michael Feathers' article The Universality of Postel's Law, in which he writes:
[Postel's law] has been paraphrased over the years as “Be liberal in what you accept, and conservative in what you send” and for people who are mathematically inclined: “be contravariant in your inputs and covariant in your outputs.”
A thing contravariant in input and covariant in output sounds like a profunctor, but why does Michael Feathers write that about Postel's law?
In this article, I'll try to explain.
 As I've previously outlined, with sufficient squinting, we can think about methods and other operations as functions, so in this article I'll focus on functions.
Functions don't stand alone. Functions have callers. Some other entity, usually client code, passes some input data to the function, which then performs its work and returns output data. When viewed with a set-based perspective, we can depict a function as a pipe:
Client code often use the output of one function as input for another:
Int3 isEven = EncodeEven(number); Int3 decremented = Decrement(isEven);
Even though this code example uses an explicit intermediary variable (isEven
), it's equivalent to function composition:
var composition = EncodeEven.Compose(Decrement);
where Compose
can be implemented as:
public static Func<A, C> Compose<A, B, C>(this Func<A, B> f, Func<B, C> g) { return x => g(f(x)); }
Such a composition we can depict by appending one pipe after another:
This works, but is brittle. It's a close fit. The output set of the first function has to exactly fit the input set of the second function. What happens if the pipes don't perfectly align?
Functions compose when they fit perfectly, but in the real world, that's rarely the case. For example, it may turn out that Decrement
is defined like this:
static Int3 Decrement(Int3 i) { if (i == 0) throw new ArgumentOutOfRangeException( nameof(i), "Can't decrement 0."); return i - (Int3)1; }
This function is undefined for 0
. If we wanted to peek at the set diagram 'inside' the pipe, we might depict the function like this:
In a sense, it's still a mapping from our hypothetical 3-bit integer to 3-bit integer, but it's a partial function.
Another way to depict the mapping, however, is to constrain the domain to [1..7]
, and narrow the codomain to the function's image, producing a bijection:
Such sets are a little harder to express in code, because how do you represent a set with seven elements? Often, you'd stick with an implementation like the above Decrement
function.
This turns out to be unfortunate, however, because EncodeEven
is defined like this:
static Int3 EncodeEven(Int3 i) { return i.IsEven ? (Int3)1 : (Int3)0; }
As a set diagram, we might depict it like this:
It turns out that half the inputs into the above composition don't work! It's almost as though the pipes are misaligned:
This can easily happen, also in the real world:
This is also why Michael Feathers writes:
We can see Postel in the physical world too. Every time you see a PVC pipe with a flanged end, you’re seeing something that serves as a decent visual metaphor for Postel’s Law. Those pipes fit well together because one end is more accepting.
In other words, there's nothing new in any of the above. I've just been supplying the illustrations.
How should we interpret the idea of flanges? How do we illustrate them? Here's a way:
Given our set-based interpretation of things, how should we interpret a flange? Let's isolate one of them. It doesn't matter which one, but lets consider the left flange. If we attempt to make it transparent, we could also draw it like this:
What does that look like? It looks like a mapping from one set to another.
The left-hand set is slightly larger than the right-hand set, but the illustration includes neither the elements of each set nor the arrows that connect them.
If we think of the 'original' function as a function from the set A to the set B we can also write it in pseudo-code as A -> B
. In Haskell you'd exactly write A -> B
if A
and B
were two concrete types. Polymorphically, though, you'd write any function as a -> b
, or in C# as Func<A, B>
.
Let's think of any function a -> b
as the 'perfect fit' case. While such a function composes with, say, a function b -> c
, the composition is brittle. It can easily become misaligned.
How do we add flanges to the function a -> b
?
As the above illustration of the flange implies, we can think of the flange as another function. Perhaps we should call the slightly larger set to the left a+
(since it's 'like' a
, just larger - that is, more liberal). With that nomenclature, the flange would be a function a+ -> a
.
Likewise, the right flange would be a function b -> b-
. Here, I've called the narrower set of the flange b-
because it's smaller (more conservative) than b
.
Thus, the flanged pipe is just the composition of these three functions: a+ -> a
, a -> b
, and b -> b-
:
That's exactly how dimap
is defined in Haskell:
dimap ab cd bc = cd . bc . ab
The implementation code uses other letters, and recall that Haskell is typically read from right to left. As its name implies, ab
is a function a -> b
, bc
is a function b -> c
, and cd
is a function c -> d
.
In other words, Postel's law is a description of the Reader profunctor, or, as Michael Feathers put it: Be contravariant in your inputs and covariant in your outputs.
Postel's law is a useful design principle to keep in mind. Intuitively, it makes sense to think of it as making sure that pipes are flanged. The bigger the receiving flange is, and the smaller the nozzle is, the easier it is to compose the flanged pipe with other (flanged) pipes.
Using mostly visual metaphor, this article demonstrates that this is equivalent with being contravariant in input and covariant in output, and thus that the principle describes a profunctor.
Postel's law, however, isn't the only design principle describing a profunctor.


AP Top Political News at 2:34 a.m. EST
Democrats spar at debate over health care, how to beat Trump
‘On whose authority?': What to watch in impeachment hearings
Key witnesses will cap intense week in impeachment inquiry
In wake of impeachment testimony, no signs yet of GOP cracks
Trump's ‘no quid pro quo' call open to interpretation
Fiona Hill, adviser with sharp eye for detail, is next up
Official: Ukraine asked about aid on day of Trump call
Congress adopts bills to support human rights in Hong Kong
Impeachment intensifies buzz about Pompeo run for US Senate
NBC's issues aren't addressed despite candidates' letter
Copyright 2019 The Associated Press. All rights reserved. This material may not be published, broadcast, rewritten or redistributed.


RnBeads
. You can also download the corresponding datasets and create analysis reports using the following commands:
rnb.run.example(1) rnb.run.example(2) rnb.run.example(3)
Analysis of DNA methylation in a large cohort of cancer patients using the Infinium 450k assay
This example contains data from the The Cancer Genome Atlas (TCGA) assayed using the Infinium 450k assay.
Analysis of DNA methylation during adult stem cell differentiation in the blood and skin lineages using reduced representation bisulfite sequencing (RRBS)
DNA methylation in embryonic stem cells (taken from the vignette)


Awesome productivity tool Trello (which I’ve mentioned before) released an update to its iOS app today. Among many great new features is functionality that I’ve wanted for some time: URL scheme support.
All the juicy details can be found on the Trello iOS App board. It’s early, but all the functionality you’d want in a first release is there:
- Showing boards
- Creating boards
- Creating boards
- Creating cards
Giddy joy! I will be working to update my URL Actions for iOS guide with all the relevant productivity uses I find. Stay tuned!


Here are some reasons why you should consider using Novax...
You can design the lay-out anyway you like. Your design adapts to every screen size too!
Yes, this theme is built with the Bootstrap framework. Bootstrap comes with a lot of modules so that you can always add new stuff.
This theme is optimized for any screen size. This will also give you a higher rank in Google.
Forget scanning lines and lines of code just to change a sentence. We format our code so you can easily find what you're looking for.
That's right! This theme can be all yours with just a click of a button. Go to Aclevo.xyz now and start building today!
In this neat section you can add your contact information so that your visitors know how to reach out to you.


Home
Terry
George R. R. Martin
External Links
Welcome to my writers tribute page
"This is one of my first attempts in making web pages.
Forgive me all errors and unfriendly page behavior"
"The pen is mightier than the sword if the sword is very short, and the pen is very sharp."
Another random quote


{# https://github.com/sphinx-doc/sphinx/blob/master/sphinx/themes/basic/page.html #} {%- extends "layout.html" %} {% block body %} {{ body }}
This is rendered using a custom template
... which has a custom context as well: {{ special_setting }}
{% endblock %}


Health and wellbeing
Leeds City Council are commited to supporting healthy, physically active lifestyles.
Find out more about Health and wellbeing.
{% extends "design-system-page-layout-campaigns.html" %} {% set section_id = "campaigns" %} {% set page_id = "icon-panel" %} {% set page_title = "Icon panel" %} {% block sectionOneTop %}{% endblock %} {% block sectionLeftHandColumn %} {% include "includes/design-system/design-system-side-nav.html" %} {% endblock %} {% block sectionOneRightContent %}

Health and wellbeing

Leeds City Council are commited to supporting healthy, physically active lifestyles.

Find out more about Health and wellbeing.


Add New User
Validation error
This is the first access. Please create a user in order to be able to login.
Login:
Validation error
Name:
Validation error
Password:
Validation error
Password confirmation:
Validation error
Mail:
Validation error
Is Admin
Save


We're sorry but django-vue doesn't work properly without JavaScript enabled. Please enable it to continue.
Test the things Between here -----------
And Here -------------------->


--- layout: default nav: tutorial ---
This example has a form with a second drop-down dependent on the value of the first, with the values driven by a server-side data structure.
Note that the "server side" implementation is mocked out using mockjax, so you can see the entire implementation. Click the "Source Code" tab to see the code.
/models
via a
ic-post-to
attributes. It does this when the value changes (the default trigger on inputs). It targets the model
drop down by CSS ID using the
ic-target
attribute, and displays a spinner via the
ic-indicator
attribute.


American, Australian freed by Taliban treated at US Air Force base in Germany
by Bradford BetzAn American and an Australian who were freed by the Taliban Tuesday after three years in captivity are receiving treatment at a U.S. military hospital in Germany, officials said.
U.S. Ambassador Richard Grenell and Australian Ambassador Lynette Wood met American Kevin C. King and Australian Timothy J. Weeks at the U.S. Air Force's Ramstein after they arrived late Wednesday, a U.S. official said.
King, 63, and Weeks, 50, were then taken to the nearby Landstuhl Regional Medical Center where they will stay for some time for medical evaluations and a reintegration process.
The two former professors were freed Tuesday in Afghanistan in exchange for three figures in the Taliban-linked Haqqani network: Anas Haqqani, Haji Mali Khan, and Hafiz Rashid.
A Taliban statement that followed the swap – which freed the younger brother of Sirajuddin Haqqani, the head of the Haqqani network – called the exchange a "confidence-building measure" that could help bring an end to Afghanistan's endless war.
King and weeks were abducted at gunpoint outside the American University in Kabul where they worked as teachers. The U.S. State Department said after their release that King and Weeks would both soon be reunited with their families.
2 US SERVICE MEMBERS KILLED IN CHOPPER CRASH IN AFGHANISTAN
Australian Prime Minister Scott Morrison wrote on Twitter that Weeks' family had "asked the Australian government to convey their relief that their long ordeal is over, and their gratitude to all those who have contributed to Tim's safe return."
Grenell told Fox News that he had presented King with an American flag when he met him at Ramstein and told him that "we never forgot about you."
CLICK HERE TO GET THE FOX NEWS APP
Grenell said King then told him: "I know that, and that is what sustained me all these years."
Fox News’ Danielle Wallace and The Associated Press contributed to this report.


This project template is the basis of an PCB for the Wiska 607 junction box Board Dimensions: XX.xxmm["] x YY.yymm["]
The board outline looks like the following:
(c)2016 Ashton Johnson (c)1997-2016 Hammond Mfg Co Inc (c)2016 Kicad Developers


Anti-VEGF Control
Odds Ratio Weight M-H, Fixed, 95% Cl
Study or Subgroup _—Events Total Events Total
1.3.1 Conjunctival erythema/Subconjunctival hemorrhage Banifatem2011 16 = 22 18 22 Hwang2015 4 26 2 33 Singh, Priyanka 2015 2 30 2 30 Subtotal (95% Cl) 78 85
Total events 22 22
Heterogeneity: Chi? = 1.79, df = 2 (P = 0.41); I = 0% Test for overall effect: Z = 0.17 (P = 0.86)
1.3.2 Inflammation
Singh, Priyanka 2015 2 30 1 30 Subtotal (95% Cl) 30 30 Total events 2 1 Heterogeneity: Not applicable
Test for overall effect: Z = 0.58 (P = 0.56)
1.3.3 Conjunctival ischaemic
Banifatem2011 10 22 10 22 Nava-Castaneda2014 16 933 0 16 Shahin2012 2 20 0 2i Subtotal (95% Cl) 75 59 Total events 28 10
Heterogeneity: Chi? = 5.97, df = 2 (P = 0.05); I? = 66% Test for overall effect: Z = 2.43 (P = 0.02)
Total (95% Cl) Total events 52 33 Heterogeneity: Chi? = 8.36, df = 6 (P = 0.21); I? = 28% Test for overall effect: Z = 2.09 (P = 0.04)
183 174
31.8% 0.59 [0.14, 2.48] 9.7% — 2.82 [0.47, 16.76] 12.1% 1.00 (0.13, 7.60] 53.6% 1.09 [0.42, 2.79] 6.0% 2.07 [0.18, 24.15] 6.0% 2.07 [0.18, 24.15] 35.4% 1.00 (0.31, 3.28] 2.2% 31.11 [1.72, 561.40]
2.8% 5.81 [0.26, 128.90] 40.4% 2.99 [1.24, 7.24] 100.0% — 1.91 [1.04, 3.52]
Test for subgroup differences: Chi? = 2.37, df = 2 (P = 0.31), I? = 15.4%
Odds Ratio M-H, Fixed, 95% Cl
—+»+_
=
EEE — ey ——+-—_ > ie Pt
0.01 0.1 1 10 100 Anti-VEGF CONTROL


Code taken from http://bencentra.com/2017-07-11-basic-html5-canvas-games.html Modified for classwork.


QUAKE PREP
PREPARE YO-SELF
How to prepare for an earthquake in the Puget Sound Region:
- React Safely
- Take Cover
- Survive on Your Own
- Stay in Contact
- Care for People, Pets, and Property
Click here to make your own personal earthquake preparation list.
Click here to start your own communications plan.
Quick Facts:


Introduction
Complicated rules, multiple contact points, numerous forms and applications and three administrative levels: processes as common as home renovations in Flanders require a lot of manual administrative work. To streamline customer journeys and simplify processes, municipalities and other public organizations would benefit from e-government applications. However, implementing these solutions is challenging, considering the lack of well-structured content and the need to integrate legacy systems. FAST aims to tackle the challenges to e-government adoption by creating an engine to automatically generate customer journeys from existing unstructured content – the ideal collection of digital interaction points between public services, organizations and citizens – for a range of public tasks.
FAST in a nutshell
-
1.
Municipalities struggle to implement e-government
Citizens engaging with government processes encounter many different tools, UI’s, webforms and administrative levels. Customer journeys could be vastly simplified through electronic and automated administrative processes and services. Yet the most municipalities find these tools difficult to implement, causing them to score poorly on European benchmarks such as ‘government transparency’ and ‘service delivery’.
-
2.
Putting e-government in the fast lane
FAST gathers experts in UX, UI, natural language processing and data linking to develop a rapid approach to e-government implementation in municipalities. Together, the consortium will optimize existing customer journeys though data linking and public data, and use them as models for new customer journeys. A flexible library of UI elements will allow for the generation of the customer journeys and usage monitoring. The project will be validated by a user group made up of different municipalities at various levels of e-government adoption.
-
3.
Simpler, faster and reusable
Three main innovation goals have been set forth by the FAST consortium:
- To automatically simplify customer journeys by cutting input requests, reusing data sources, harmonizing terminology and avoiding redundant interactions
- To make the generation of customer journeys of underdeveloped local authorities three times faster
- To determine the potential of using the project’s results in other domains and sectors
-
4.
Fostering trust, reducing dependency on outside parties
The FAST solution will not only be used by consortium partners to grow their knowledge and enhance competitive advantages. Because many other EU countries rank lower in e-government than Belgium, the potential value of the solution is significant.
“Through data linking, natural language processing and UX and UI innovation, the FAST solution will accelerate the adoption of e-government in municipal contexts and simplify customer journeys for key administrative processes.“
Who is it for?
FAST was developed with these people profiles in mind:
End user
The end user who will make use of government provided services.
- Seamless and tailored user experience
- Organised around the tasks I want to execute (life-events)
- Services based on the most up-to-date data and regulations
- Touchpoint of my choice (portal, chat, voice…)
Application Owner
The application owner who is maintaining FAST solutions.
- Application based on the most up-to-date data and regulations
- Relevant regulations of different government levels
- Application improves automatically based on its use
- Low cost for maintenance (keeping it up-to-date with the law)
Policy maker
The policy maker creates and manages government regulations.
- Easy way to manage regulations
- Transparent regulations
- Once-only for regulations:
- Regulations build on top of other regulations
- Regulations from different government levels


Zoom In
Zoom Out
←
→
↑
↓
Paste a link to your photo or upload your image to put a #MaskOn. Choose from different masks.
Get image from URL:
Ok


This tool will export the list of all foods in the selected locale including references to the food composition tables they are linked to and the corresponding nutrient data from those tables.
The meaning of columns in the output .csv file is as follows:
Intake24 food code — self explanatory.
English description — food description in English.
Local description — food description in the local language associated with the selected locale.
Source locale — locale that was used to resolve the food composition table code. This will usually be the selected locale, however it can be different if the food has no food composition table links defined int the selected locale and the system has to fall back on the data from the prototype locale.
FCT — the ID of the food composition table that this food is linked to, e.g. NDNS_Yr_12.
FCT record ID — the ID of the record in the food composition table that the food is linked to, e.g. if the FCT is NDNS_Yr_12 then this is the NDNS (NDB) food code
The rest is the nutrient data in units per 100g/ml. The available nutrient types and their order is determined by the locale settings and the unit can be found in the header row.


Connecting
Insight and techniques for growing trust
Trust is extremely important in any relationship, be it personal or work related. It is very hard to work or interact with anybody you don't trust. To be able to open up to someone and have good conversations you need to know that you can trust that person, so you can have friendly arguments in order to resolve anything. Some techniques to gain trust are:
- Be sincere
- Kindness
- Openness
- Empathic listening
- Praise
I believe I have used all of the above techniques for growing trust to build better relationships. They all work and it generally depends on the other person on which technique or better what combination of techniques will work best.
Empathic listening
To actively use the empathic listening technique, it helps to fall back onto mindfulness and kindness. To practice empathic listening, listen out for the other person's feeling.
I tried this exercise with a friend and found it very interesting, especially when you don't agree with the other person. But sometimes it helps a lot to understand what the other person's perspective on an issue is and what they feel about this issue to be able to resolve a potential conflict.
How did you find the loving kindness meditation?
I found this meditation to be very calming. It was good to actively think about that one person because life can be hectic at times and it's good to take a time out to think of the people around us who we care about.
Political awareness exercise
My view: In one of the jobs I worked at, my manager was promoted and hired a new manager for our team who in turn promoted one of my team members as team lead. This team lead had in no way proved as a team player or even technically competent in the past, the team member was simply the old manager's pet. And when the team questioned the decision, the manager just slammed a fist on the table saying that the decision had been made and we are not there to question this decision.
The other view: As the hiring manager was new, this manager simply listened to recommendations from the predecessor.


| Name | Artist | Year | Producer | Price | Songs |
|---|---|---|---|---|---|
| KILL 'EM ALL | Metallica | 1983 | Paul Curcio | 11.98$ |
Hit the Lights -
2
The Four Horsemen -
3
Motorbreath -
2
Jump in the Fire -
3
(Anesthesia) Pulling Teeth -
2
Whiplash -
3
Phantom Lord -
2
No Remorse -
3
Seek and Destroy -
4
Metal Militia -
2
|
| MASTER OF PUPPETS | Metallica | 1986 | Metallica with Flemming Rasmussen | 21.98$ |
Battery -
2
Master of Puppets -
3
The Thing That Should Not Be -
2
Welcome Home (Sanitarium) -
3
Disposable Heroes -
2
Leper Messiah -
3
Orion -
2
Damage, Inc. -
3
|
| Sin After Sin | Judas Priest | 1977 | Roger Glover and Judas Priest | 11.98$ |
Sinner -
2
Diamonds And Rust -
3
Starbreaker -
2
Last Rose of Summer -
3
Let Us Prey -
2
Call For The Priest -
3
Raw Deal -
2
Here Come The Tears -
3
Dissident Aggressor -
4
Race With The Devil -
2
|


Many professional software engineers see concurrent programming as something of an arcane art, and indeed it’s possible to make it several years into a career without a good grasp of threads. The reasons seem clear enough:
- Most problems don’t require a strong understanding of concurrency. I’d even argue that many web applications, which are often highly concurrent, don’t require a strong understanding of concurrency: sometimes there isn’t significant data sharing; sometimes the burden of managing concurrency, isolation and deadlocks is pushed back to a transactional data store; sometimes the consequences of races are minor or completely insignificant; etc.
- Even when a problem does require some knowledge of concurrency, a lack of knowledge manifests itself only sporadically and generally in ways that are difficult to reproduce, which allows people to mistake their 99.9999% solution for a 100% solution. Even in cases where the developer is under no such delusion, he may believe that his 99.9999% solution “works”. He fails to notice that 99.9999% may not be so high when you’re talking about long-running applications running on processors that execute billions of cycles per second, and that sometimes the consequences of that 1-in-1,000,000 screwup are disastrous.
- The “behavioral” structure of a program, as embodied by its threads, is largely orthogonal to the program’s “static” structure, as embodied by packages, classes and methods. Since code is organized around the latter, developers can “see” and understand it. Since code is not organized around the behavioral structure (for example, the code does not contain explicit representations of the paths of individual threads), developers have a harder time seeing and understanding it.
There are times when you really do need to understand how threads work in order to implement required functionality or else avoid simple but potentially serious mistakes.
What we’ll cover
In this three-part series of posts we’re going to cover several important concurrent programming concepts that every professional software developer needs to understand: serialism, parallelism, race conditions, synchronization, deadlocks and global lock orderings. The concepts form a logical progression that looks a little like an arms race: some problems lend themselves to a parallel solution, but parallelism gives rise to race conditions. We counter race conditions with synchronization (among other techniques), but synchronization leads to deadlocks (among other problems). And so we counter deadlocks with global lock orderings (among other techniques).
You’ll note that I said “among other problems” and “among other techniques”. The treatment here doesn’t pretend to be comprehensive. There are lots of important topics in concurrent programming, such as proper encapsulation, contention-induced (rather than compute-induced) performance issues, read/write locking, minimizing lock scope, fine- vs. coarse-grained locks, timeouts, forking and joining and on and on (and on). I believe however that the topics we’re about to treat provide a nice context against which developers can more easily learn other topics. I’ll probably write about some of the other topics eventually.
By the end of the series you’ll have a basic foundation in multithreaded programming, one that I consider to be required for practicing software engineers.
Our presentation is Java-centric, but developers from other languages (especially C#) should still find the discussion useful.
What is a thread?
Let’s begin by introducing the star of the show, the thread. The following is probably more accurately considered a description rather than a definition, even though it reads a little like the latter.
A thread is a sequential flow of control with its own program counter and call stack. It shares state, memory and resources with other threads in the same process. Since each thread gets its own call stack, local variables aren’t shared. Instance and class variables, however, are shared across threads. It’s also possible to define variables that exist outside of methods but are still local to a specific thread, and these are called thread-local variables.
OK, so that’s what a thread is. What can we do with them?
Serialism and parallelism
In software development we’re asked to solve different kinds of problem. We may be asked to write code that takes a bunch of information about a loan applicant and produces a verdict as to whether that applicant should get the loan. Maybe we have to write a web-based shopping cart. Or maybe we have to write code to make a guy’s arms and legs flail about in a realistic fashion when he falls off a cliff in a video game.
For any given problem there are typically multiple ways to solve it, and different ways to categorize the solutions. One useful way of distinguishing solutions is to separate serial from parallel solutions. Let’s look at that distinction in more detail.
Serial approaches to solving problems
Some problems have solutions that are essentially a single series of steps. If you’re writing a home affordability calculator, for example, the steps might be as follows:
- Collect data from the user, such as their annual salary, the amount of the down payment, their monthly bill payments, whatever.
- Crunch some numbers.
- Show the maximum dollar amount the user can afford and an ad for a local Realtor.
Our recipe for solving the “home affordability problem” is said to be serial because it’s essentially just a series of steps to carry out. We might even go so far as to describing the problem itself as a serial problem, which is just a shorthand way of saying that the most plausible and reasonable solutions to the problem are serial solutions. Either way, the essence of serialism is that we have a series of steps that a single control flow can carry out.
Now let’s look at the alternative to serialism, which would be parallelism.
Parallel approaches to solving problems
Some problems are amenable to solutions involving multiple concurrent control flows, which is to say that they have parallel solutions. To take a non-computing example, say you have a room with toys scattered all over the floor. You want the room clean. As potential participants to the cleanup effort you have yourself and three kids. A possibly-relevant piece of background information is that one child is entirely responsible for the mess.
Readers with young children will no doubt recognize this classic problem from the field of parenting algorithms. Fortunately, well-known serial and parallel solutions are available. The best approach in any given case depends strongly upon your goals:
- If you’re trying to emphasize fairness and personal responsibility, you might opt for the obvious serial solution even though it’s slower. (In reality this isn’t a serial solution; it inevitably involves close supervisory involvement by a supervisory parent thread. We can ignore that detail.)
- If you’re in a big hurry because you need to get the kids off to school, you might choose the obvious parallel solution, despite the unfairness.
- If you’re in an even bigger hurry you might choose the “other” serial solution. (Hint: it doesn’t involve any kids.)
Whether we’re talking about serialism or parallelism, there is a recurring concept, which is that of a flow of control. In the serial case we have exactly one flow. In the parallel case we have more.
Computer scientists, hardware engineers and software engineers spend a lot of time with the distinction between serialism and parallelism. Let’s look at why that is.
Serialism vs. parallelism: why do we care?
In a word, performance. In many cases—not all, but many—parallel solutions are simply faster than serial solutions, owing to the “many hands make light work” effect. And from a practical perspective, that’s the main reason we care about concurrency (i.e., parallelism) despite its many attendant complications.
The next post in our series explains what some of those complications are and some ways to overcome them.


--- layout: default ---
This tool allows you to visualize hours budgeted for projects as they are allocated for work on frameworks and programming languages, and assigned to student developers. Simply edit the YAML in the text field below to modify the visualization.
Warning: Do not try to link a node on the right backwards to a node on the left.


Preparation time
less than 30 mins
Cooking time
10 to 30 mins
Serves
Serves 4
Dietary
These are delicious vegan burgers with a chilli kick. They can be prepared in advance and left in the fridge until you're ready to cook.
Heat the olive oil in a pan and fry the onion and garlic for ten minutes until soft. Add the spices and coriander and cook for another minute. Remove from the heat.
Pulse the chickpeas in a blender with the onion spice mix. Taste, season with salt and pepper, and add a squeeze of lemon juice. Form the mixture into stiff patties and set aside in the fridge until you are ready to cook.
For the salad, salt the red onion and red pepper on a plate and leave for 20 minutes.
When ready to cook the burgers, sprinkle the polenta onto a plate and press the burgers onto the polenta. Heat the sunflower oil in a pan and fry the burgers on both sides until cooked through. (Alternatively, you can bake these on an oiled tray for 15-20 minutes at 200C/180C Fan/Gas 6.)
To finish the salad, wash the onion and pepper under cold, running water and drain. Sprinkle the sumac over the tomatoes. Combine the tomatoes with the Cos lettuce leaves, red onion and red pepper. Mix together the chilli sauce and mayonnaise in a small dish.
Serve the burgers in the buns with the salad and chilli dip alongside.


Welcome to BiBler
The simple bibliography management tool.
Developer: Eugene Syriani.
Version: 0.2.5
All rights reserved.


| Top |
| SoupMultipart * | soup_multipart_new () |
| SoupMultipart * | soup_multipart_new_from_message () |
| void | soup_multipart_free () |
| int | soup_multipart_get_length () |
| gboolean | soup_multipart_get_part () |
| void | soup_multipart_append_part () |
| void | soup_multipart_append_form_string () |
| void | soup_multipart_append_form_file () |
| void | soup_multipart_to_message () |
SoupMultipart *
soup_multipart_new (const char *mime_type
);
Creates a new empty SoupMultipart with a randomly-generated
boundary string. Note that mime_type
must be the full MIME type,
including "multipart/".
Since 2.26
SoupMultipart * soup_multipart_new_from_message (SoupMessageHeaders *headers
,SoupMessageBody *body
);
Parses headers
and body
to form a new SoupMultipart
headers |
the headers of the HTTP message to parse |
|
body |
the body of the HTTP message to parse |
Since 2.26
void
soup_multipart_free (SoupMultipart *multipart
);
Frees multipart
Since 2.26
int
soup_multipart_get_length (SoupMultipart *multipart
);
Gets the number of body parts in multipart
Since 2.26
gboolean soup_multipart_get_part (SoupMultipart *multipart
,int part
,SoupMessageHeaders **headers
,SoupBuffer **body
);
Gets the indicated body part from multipart
.
multipart |
||
part |
the part number to get (counting from 0) |
|
headers |
return location for the MIME part headers. |
[out][transfer none] |
body |
return location for the MIME part body. |
[out][transfer none] |
TRUE
on success, FALSE
if part
is out of range (in
which case headers
and body
won't be set)
Since 2.26
void soup_multipart_append_part (SoupMultipart *multipart
,SoupMessageHeaders *headers
,SoupBuffer *body
);
Adds a new MIME part to multipart
with the given headers and body.
(The multipart will make its own copies of headers
and body
, so
you should free your copies if you are not using them for anything
else.)
Since 2.26
void soup_multipart_append_form_string (SoupMultipart *multipart
,const char *control_name
,const char *data
);
Adds a new MIME part containing data
to multipart
, using
"Content-Disposition: form-data", as per the HTML forms
specification. See soup_form_request_new_from_multipart()
for more
details.
multipart |
a multipart (presumably of type "multipart/form-data") |
|
control_name |
the name of the control associated with |
|
data |
the body data |
Since 2.26
void soup_multipart_append_form_file (SoupMultipart *multipart
,const char *control_name
,const char *filename
,const char *content_type
,SoupBuffer *body
);
Adds a new MIME part containing body
to multipart
, using
"Content-Disposition: form-data", as per the HTML forms
specification. See soup_form_request_new_from_multipart()
for more
details.
multipart |
a multipart (presumably of type "multipart/form-data") |
|
control_name |
the name of the control associated with this file |
|
filename |
the name of the file, or |
|
content_type |
the MIME type of the file, or |
|
body |
the file data |
Since 2.26
void soup_multipart_to_message (SoupMultipart *multipart
,SoupMessageHeaders *dest_headers
,SoupMessageBody *dest_body
);
Serializes multipart
to dest_headers
and dest_body
.
multipart |
||
dest_headers |
the headers of the HTTP message to serialize |
|
dest_body |
the body of the HTTP message to serialize |
Since 2.26
typedef struct SoupMultipart SoupMultipart;
Represents a multipart HTTP message body, parsed according to the
syntax of RFC 2046. Of particular interest to HTTP are
multipart/byte-ranges
and
multipart/form-data
.
Although the headers of a SoupMultipart body part will contain the full headers from that body part, libsoup does not interpret them according to MIME rules. For example, each body part is assumed to have "binary" Content-Transfer-Encoding, even if its headers explicitly state otherwise. In other words, don't try to use SoupMultipart for handling real MIME multiparts.
Since 2.26


{% load staticfiles %}
人力资源
{% include "wuqian/title.html"%}
Human Resources
人力理念
社会招聘
校园招聘
{{about|safe}} {% include "wuqian/footer.html" %}


Memory Address Register (MAR)¶
The memory address register stores the address of the data the RAM module should be pointing at.
Mode of Operation¶
The memory address register is very similar in its operation principle to any of the data registers.
It uses the same 74LS173 4-bit D-type registers, however since it’s output is not connected to the databus but instead directly to the address pins of the RAM module, no buffers are used at the output.
Instead a 74LS157 quadruple 2-to-1 multiplexer is used to select either the register contents or a DIP switch array to set the address outputs. The DIP switches can be used in program mode to set the address manually while in run mode the address can be loaded as the lower 4 bits of the data bus which represent the instruction data (ID) nibble of an instruction (see the ISA section for more detail).
To select the current mode of operation (run / program), the SPDT switch Program / Run can be used.


Preparation time
overnight
Cooking time
10 to 30 mins
Serves
Serves 4
James Martin combines Japanese and Chinese ingredients to make a stunning marinated fish dish served with flavour-packed greens.
For the miso halibut, stir together the sake, mirin, white miso paste and caster sugar in a shallow dish. Remove a couple of tablespoons of the marinade and put it in squeezy bottle for the dressing and set aside. Add the fish to the shallow dish, cover and leave to marinate in the fridge for 24 hours.
When you are ready to cook the fish, preheat the grill to high. Wipe any excess marinade from the fish and place the fish on a baking tray.
Grill the fish for three minutes on each side, or until cooked to your liking.
For the teriyaki green veg and miso dressing, first make the teriyaki sauce. Heat a frying pan until hot, add the rice wine, sake, mirin, soy sauce and caster sugar and bring the mixture to a simmer.
Simmer for 1-2 minutes, or until the mixture has just thickened.
Heat a large wok and add the oil. Once the oil is hot, add the shallot, garlic, ginger, salt and the greens and cook for 2-3 minutes. Pour in the teriyaki sauce and stock (or water) and stir.
To serve, use the marinade in the squeezy bottle to dress each of four plates. Place the greens on each plate topped with the miso fish. Garnish with the red amaranth and coriander cress.


Dining Dollars
Format should look like "1234.56"
Your custom amount of dining dollars
Your custom amount of dining dollars
Format should look like "1234.56"
How much you are rolling over from last semester
Format should look like "1234.56"
How many dollars you have remaining
How many dollars you have remaining
Date Range
Format should look like "08/26/2019"
The start date for the semester
Format should look like "12/18/2019"
The end date for the semester
The end date for the semester
Format should look like "9"
How many days off in total
Format should look like "12"
How many days off have passed
How many days off have passed
You can spend
today and still be on schedule.
| Daily | Weekly | ||
| Average | |||
| Currently | |||
| Difference |


The primary interfact with which the application interacts with the telegram api via the telegram_bot gem.
It currently does not process state or 'remember' conversations, so does not have persistence handling. This is likely to be developed at some point in the future. Any bot interactions must be done explicitly through this object and not directly through the Telegram_Bot.
Namespace
- CLASS MaraBot


The ScrumMaster is responsible for making sure a Scrum team lives by the values and practices of Scrum. The ScrumMaster protects the team by making sure they do not overcommit themselves to what they can achieve during a sprint.
The ScrumMaster facilitates the daily scrum and becomes responsible for removing any obstacles that are brought up by the team during those meetings.


 It’s time to get back outdoors..
Input your daily screen time, latitude/longitude, and click “Find My Park!” to get the NC State Park closest to you and the amount
of hiking miles equivalent to your screen time. Already been there? Click "Next Closest Park" to see the second closest park to you. Been there too? Continue clicking "Next Closest Park".
Not sure of your (Latitude, Longitude)? Type your location in Google Maps,
right click on the pin & copy and paste the top coordinates. The more decimals you include, the more accurate it will be.
Data obtained from Google Maps and NC State Parks.
Disclaimer: Distance calculation based on point to point, not driving distance.
Check true driving distance before going on trip. Icons obtained from https://www.flaticon.com/
Created by: Virginia Gilliland, vigilliland@davidson.edu


{% if site.layout == 'stacked' %} {% assign metadata_styles = 'd-md-inline-block mx-3 mb-1 mb-md-0' %} {% else %} {% assign metadata_styles = 'd-flex flex-items-center mb-3' %} {% endif %}
Incoming Software Engineering Intern @ Splunk | Former Software Engineering Intern @ PagerDuty | Engineering @ UWaterloo
{% if include.metadata %}I'm a third-year Engineering Student at the University of Waterloo. I've previously worked at Splunk and PagerDuty as a Software Engineering Intern and I'm always looking for unique opportunities to apply my skills and learn some more.
I'm particularly interested in building highly reliable and scalable systems, however I'd love to hear from you if you believe I'd be a good fit for additional opportunities.


Dashboards
Home
Issues
Measures
Rules
Quality Profiles
Quality Gates
More
Compare Projects
Dependencies
Log in
Apache HttpComponents Client
Version 4.5-alpha1-SNAPSHOT / 2015年12月4日午前10時10分
Overview
Components
Issues
More
Dashboards
Issues Report
Time Machine
Tools
Design
Libraries
Compare
[
hide
]
[
hide
]
[
hide
]
Unit tests errors
0


We both really like video games, as they played pivotal parts in our lives growing up. With that in mind, we figured that it would be a fun project to make a sort of list of the history of video game sales, one that could be
updated and saved in the internet. Using data from Kaggle, sqlite, and basic web development, we were able to make this website as an online, interactive look.


QR Code Converter
Looking for the ASIN to Barcode Label Sheet Printer?
Click here.
Enter ASINs and title, comma-delimited, one per line:
Submit


new Album(entry, responseopt)
Create album entry.
Parameters:
| Name | Type | Attributes | Description |
|---|---|---|---|
entry |
string | The album to search for. |
|
response |
string |
<optional> |
JSON album object. |
- Source:
Members
albumResponse
Album response.
- Source:
entry
Entry string.
- Source:
fetchTracks
Whether to fetch tracks.
- Source:
limit
Number of albums to fetch.
- Source:
searchResponse
Search response.
- Source:
Methods
createQueue(response) → {Promise|Queue}
Create a queue of tracks.
Parameters:
| Name | Type | Description |
|---|---|---|
response |
JSON | A JSON response object. |
- Source:
Returns:
A queue of tracks.
- Type
- Promise | Queue
dispatch() → {Promise|Queue}
Dispatch entry.
- Source:
Returns:
A queue of tracks.
- Type
- Promise | Queue
fetchAlbum() → {Promise|JSON}
Fetch album metadata.
- Source:
Returns:
A JSON response.
- Type
- Promise | JSON
id() → {string}
Spotify ID.
- Source:
Returns:
The Spotify ID of the album,
or -1
if not available.
- Type
- string
popularity() → {string}
The album popularity.
- Source:
Returns:
- The album popularity.
- Type
- string
searchForAlbum() → {Promise|JSON}
Search for album if not known.
- Source:
Returns:
A JSON response, or null
if not found.
- Type
- Promise | JSON
setLimit(limit)
Set the number of albums to fetch.
Parameters:
| Name | Type | Description |
|---|---|---|
limit |
integer | The maximum amount of albums. |
- Source:
setResponse(response)
Set the JSON response.
Parameters:
| Name | Type | Description |
|---|---|---|
response |
JSON | The response. |
- Source:
title() → {string}
The album title.
- Source:
Returns:
- The album title.
- Type
- string
type() → {string}
The album type.
- Source:
Returns:
- The album type.
- Type
- string
uri() → {string}
Spotify URI.
- Source:
Returns:
The Spotify URI
(a string on the form spotify:album:xxxxxxxxxxxxxxxxxxxxxx
),
or the empty string if not available.
- Type
- string


Sample description about card 1
View Details
Sample description about card 2
View Details
Sample description about card 3
View Details
ORGANIC TRAFFIC
Better than last week (25%)
View Details
SALES
Better than last week (25%)
View Details
SUBSCRIPTIONS
Worse than last week (25%)
View Details
SALES
Better than last week (25%)
View Details
TRAFFIC
Better than last week (75%)
View Details
ORGANIC TRAFFIC
Better than last week (25%)
View Details