What are 'ruby' annotations?
Ruby is a name for small annotations that are rendered alongside base text. This is especially useful for Japanese and other East Asian content (ruby may be called furigana in Japanese).
The HTML specification provides a way to mark up ruby text, and CSS can be used to fine tune the positioning of ruby text.
The name ruby originated from a named font size (about half the size of the normal 10 point font) used by British typesetters.
Typically ruby is used in East Asian scripts to provide phonetic transcriptions of obscure and little known characters, characters that the reader is not expected to be familiar with (such as children or foreigners learning to write), or characters that have multiple readings which can't be determined by the context (eg. some Japanese names). For example it is widely used in educational materials and children’s texts.
It is also occasionally used to convey information about the meaning of ideographic characters.
In Japanese, where ruby is often called furigana, phonetic transcriptions typically appear in hiragana characters above horizontal text and to the right of vertical text.
On the rare occasions that it is used to express semantic information, Japanese ruby often appears below horizontal text, and to the left of vertical text.
As can be seen in the following example, it is possible to combine both phonetic and semantic ruby for the same run of base text.
Ruby text in these examples is colored red only to direct your attention to it – ruby annotations would normally be the same color as the base text.
Although ruby in Japanese is often written in hiragana, you will occasionally find annotations in kanji, katakana (particularly in Japanese 'manga' comics) and Latin text.
In Mainland China, Simplified Chinese characters are typically annotated with pinyin transliterations above or below each character.
Ruby annotations in Traditional Chinese commonly use bopomofo characters to indicate pronunciation. Rather than the annotation appearing above the main text, it is included vertically to the right of each character, whether the main text flows vertically or horizontally.
Note, especially, how the tone marks in the example appear to the right of the column of alphabetic bopomofo characters, even though they are not combining characters.
The Japanese Layout Requirements document describes three different ways in which ruby behaves.
Mono ruby is commonly used for phonetic annotation of text.
In mono ruby the ruby text is positioned alongside a single base character. There is typically no overlap across adjacent base characters, although that and other positional aspects can be tailored using styling. Note how, in the figure below, a single character annotation is typically centred over its base character, leaving a small gap either side of the annotation, and how a three-character annotation forces the base character away from its neighbour to avoid overlapping.
You can break a word that uses mono ruby at any point, and the ruby text stays with its base character.
Group ruby is used where phonetic annotations don’t map to discreet base characters, or for semantic glosses that span the whole base text. The figure below shows an example of a Japanese word for which each individual base character has no independent pronunciation. The annotation applies to both base characters as a single unit.
You can’t split text that is annotated with group ruby. It has to wrap as a single unit onto the next line.
Jukugo refers to a Japanese compound noun, ie. a word made up of more than one kanji character, such as 調理師 (chef).
Jukugo ruby is a term that is used to describe ruby annotations that sometimes behave like group ruby, and sometimes like mono ruby. It is worth describing it in a little detail, since people often find it confusing.
Jukugo ruby behaves like mono ruby, in that there is a strong association between ruby text and individual base characters. This becomes clear when you split a word at the end of a line: you’ll see that the ruby text is split so that the ruby annotating a specific base character stays with that character. What’s different about jukugo ruby is that when the word is not split at the end of the line, there can be some significant amount of overlap of ruby text with adjacent base characters.
The image to the right shows three examples of ruby annotating jukugo words.
In the top two examples, the effect is the same as mono ruby, since neither of the base characters are overlapped by ruby text that doesn’t relate to that character.
The third example is where we see the difference that characterises jukugo ruby. The first three ruby characters are associated with the first kanji character. Just the last ruby character is associated with the second kanji character. And yet the ruby text has been arranged evenly across both kanji characters.
Note, however, (and this is an important distinction!) that we aren’t simply spreading the ruby over the whole word, as we would with group ruby. There are rules that apply, and in some cases gaps will appear. See the following examples of distribution of ruby text over jukugo words.
Also note that if the third word is split at the end of a line, so that the second kanji character moves to the next line, only the last hiragana character will move with it, and the annotations will once again look like mono ruby.
Requirements for Japanese Text Layout
Related links, Authoring HTML & CSS


Forcast of Sales for California through 2015 (Product Category Office Supplies ONLY)
California Profit by Month & Category (Last TWO Years)
California Profit by Month (Last TWO Years)
Sum of Profit in the United States
Notice how this page looks different? It is because I programmed the CSS for this page! NO BOOTSTRAP INCLUDED :)
Forcast of Sales for California through 2015 (Product Category Office Supplies ONLY)
California Profit by Month & Category (Last TWO Years)
California Profit by Month (Last TWO Years)
Sum of Profit in the United States


Rainbow Six Siege Shifting Tides is adding the most lethal gun in the game
by Evan LahtiHit the deck: a big, scary gun is coming in the next Rainbow Six Siege update.
The CSRX 300 is Siege's first bolt-action rifle. It can penetrate seven layers of 'soft' walls with a single shot. And its gadget can destroy almost any defensive gear sitting on the other side of a reinforced wall.
This intimidating long gun will be held by Kali, a new attacker who's a mash-up of Glaz's sniping, Thatcher's disabling, and Ash's destruction-from-a-distance. For me, Kali is the most eyebrow-raising operator since the arrival of Clash's electrified shield (which later had to be temporarily taken out of Siege while exploits were fixed).
Kali exclusively carries the CSRX 300 as her primary weapon, making her just the second dedicated sniper in Siege after Glaz, who was part of the initial 2015 roster. Though her gun doesn't offer Glaz's thermal optics, Kali's rifle can zoom to 5X or 12X dynamically (compared to Glaz's 3X magnification), allowing her to operate at a significantly longer range than any other character in the game. It also damages differently.
Like every gun in Siege, the CSRX insta-kills on a headshot, but if you're shot in the body by it, you're instantly downed, and you automatically whirl around, prone, to face Kali. This does make her rifle the most lethal weapon in the game, but in practice this mechanic actually works in the defender's favor in some cases: if you're getting shot at through a window at a distance, automatically dropping prone will probably protect you from a follow-up killshot. When I spawn-peeked out from an elevated window on Consulate and got insta-downed by Kali, I was able to limp away out of view and get revived by a teammate.
The thing sitting underneath this rifle's barrel may be the bigger deal. Kali's gadget, the LV Explosive Lance, shoots like one of Ash's Breaching Rounds: they fling out with zero drop-off, burrow into any surface, and detonate after a short fuse expires. Kali carries three charges.
These explosive projectiles destroy almost anything on either side of any soft or reinforced wall they hit: barbed wire, deployable shields (including Goyo's Volcàn), Maestro's Evil Eye, Bandit's batteries, Kaid's Rtila, and other gear that happens to be in within 2.5 meters. It also deals a small amount of damage, should a defender be hiding on the other side of the wall. Mira's Black Mirrors are one of the only defensive gadgets not affected.
As a package, Kali will test the level design of every map in Siege: expect players to exploit her ability to punch through soft walls at insane distance. And with the ability to knock out a big range of gadgets, she becomes one of the most versatile attackers, one who can influence the objective room from farther than any other operator. Counterbalancing her a bit are the thick white tracers that hang in the air with every shot that leaves the CSRX, pointing a clear line to Kali's position.
Wamai, the new defender
Kali deserves lots of attention and scrutiny, but she'll be joined by Wamai, a new defender who will probably have a greater impact than Goyo and Warden, the two most recently-added defenders.
The MAG-NET snags enemy grenades out of the air from a distance of several meters. He's meant as an alternative to Jäger, the popular defender who typically sticks his grenade-zapping mini-turrets in the objective room and runs off to roam the rest of the round. But unlike Jäger, Wamai's magnetic frisbees don't destroy grenades. Once they're scooped up, their fuse is reset, after which they detonate normally and destroy the MAG-NET.
This mechanic opens up new, devious possibilities for using enemies' throwables against them. Pull a frag grenade into a Volcàn shield and light the floor on fire unexpectedly. Pull a smoke grenade away from a key chokepoint. Pull a Fuze puck back toward the ceiling, killing anyone unlucky enough to be standing above it.
MAG-NETs redirect a wider set of projectiles than Jäger's ADS—even Ying's Candela and Capitão's bolts are up for grabs. Hibana's X-KAIROS, which it doesn't target at all, is the main exception. Otherwise MAG-NETs can be thrown onto any surface and charges up on a timer like Lesion's Gu mines.
Jäger's high pick rate motivated Ubisoft to build a character with a similar ability. Like Jäger, he doesn't carry an ACOG for either the MP5K or AUG A2. But as a two speed, two armor operator, he's more of an anchor than his German counterpart. It'll be interesting to see what creative MAG-NET positions players come up with—the gadget's long reach should make it viable at all skill levels, but Wamai players will have to place the gadget carefully to avoid Magneto-ing enemy grenades onto teammates.
Image 1 of 9
Image 2 of 9
Image 3 of 9
Image 4 of 9
Image 5 of 9
Image 6 of 9
Image 7 of 9
Image 8 of 9
Image 9 of 9
Theme Park gets a renovation
The other thing coming in Shifting Tides will be a "surgical" rework of Theme Park. The map's upper floor trainyard has been cut, replaced with a new, segmented bombsite that sits between Initiation Room and Daycare. Although plenty of other exterior windows and doors have also been removed or altered, and the map has been brightened throughout, this is the main layout change, making Theme Park 2 far less of a transformation than Kafe, but one that should make the map competitively viable. Theme Park's train section took ages to clear and made attackers too vulnerable to flanks.
Led by Kali, I expect Shifting Tides to seriously impact the meta. Ubisoft hasn't announced when it'll go live, but says it should be playable on the test server soon.


§353-16 Transfer of committed felon to federal institution. The director may effect the transfer of a committed felon to any federal correctional institution for imprisonment, subsistence, care, and proper employment of such a felon. [L 1987, c 338, pt of §3; am L 1992, c 267, §2]
Cross References
Interstate compact for the supervision of adult offenders, see chapter 353B.
Interstate corrections compact, see chapter 355D.


Toggle navigation
Ludotheken
Lend
Profile
Administration
Employees
Organisations
Games
Logout
Name
City
Zip
Street
Streetnumber
Edit
Add organisation
×
Modal Header
Some text in the modal.


June 18, 2015 - AppNexus
An object in JavaScript is just a collection of key-value pairs.
(They're associative arrays like Ruby's Hash and Python's Dictionary.)
Each key-value pair in an object represents a property of that object.
Property values can be of any type, and when a value is a function the property is specifically referred to as a method.
Any value used as an object property key is converted according to the rules of JavaScript's internal ToString abstract operation which can have unexpected results.
var obj = {};
var arr = [1, 2, 3]; // Coerced to "1,2,3".
var str = "1,2,3";
obj[str] = "abc";
obj[arr] = "xyz";
obj[str]; // "xyz"
var obj1 = {};
var obj2 = {
a: 1,
b: 2
}; // Coerced to "[object Object]".
var obj3 = {
foo: "bar"
}; // Coerced to "[object Object]".
obj1[obj2] = "abc";
obj1[obj3] = "xyz";
obj1[obj2]; // "xyz"
var obj = {
a: 1,
get b() { // Getter methods cannot have any parameters.
return this.a * 2;
}
};
obj.b; // 2
obj.a = 5;
obj.b; // 10
var obj = {
a: 1,
set b(x) { // Setter methods must have exactly 1 parameter.
this.a = x / 2;
}
};
obj.a; // 1
obj.b; // undefined
obj.b = 4;
obj.a; // 2
var obj = {
a: 1,
get a() {
return this.a * 2;
},
set a(x) {
this.a = x / 2;
}
};
(We can define this object, but any attempt to read or write a
will suck.)
var obj = {};
Object.defineProperty(obj, "a", {
configurable: true,
enumerable: true,
value: 1,
writable: true
});
Object.defineProperty(obj, "b", {
configurable: false,
enumerable: false,
get: function () {
return this.a * 2;
},
set: function (x) {
this.a = x / 2;
}
});
=
). Defaults to false.Every property defined via Object.defineProperty
must have the configurable
and enumerable
attributes (both default to false) and can have either data or accessor attributes.
Every object has an internal [[Prototype]]
property that points to another object that it "inherits" from.
An object's prototype is essentially a set of default properties.
var arr = [];
var func = function () {};
var obj = {};
arr.push("a"); // Works even though `arr` doesn't have a `push` method.
func.call(null); // Works even though `func` doesn't have a `call` method.
obj.toString(); // Works even though `obj` doesn't have a `toString` method.
There is a fundamental prototype for every type of value. For example, all arrays "inherit" methods such as shift
, push
, join
, and concat
from the fundamental Array.prototype
object.
The Object.prototype
object is the prototype for all other fundamental prototypes. Its prototype is null
.


Retrieve the providers that were collected from the module graph and used to create the primary injector.
Get the runtime's dependency injector. This injector can provide all dependencies specified
in the imported modules' providers
definitions.
True if the --self-test
option was used to launch the application.
Perform runtime configuration steps
Iterate over the module definitions which are part of this runtime and append to the given array the set of dependency injection providers which are specified in the module definitions.
An array which will be populated
Fire an event to all modules which understand it.
Retrieve the ModuleAnnotation for a given Module definition, whether it be a class annotated
with @Module()
or a plain object with $module
which configures a module class.
This is an alias of ModuleAnnotation.getForClass(module)
Get a specific service from the dependency injector.
Instantiate the modules of this runtime using the given dependency injector.
The injector will be inherited into an injector that provides the dependencies
specified in the imported modules' providers
definitions.
Stop all running services and shut down the process
Start any services, as defined by modules. For instance, if you import WebServerModule from @alterior/web-server, calling this will instruct the module to begin serving on the configured port.
This will send the OnStart
lifecycle event to all modules, which triggers the altOnStart()
method of any module
which implements it to be called. It also instructs the RolesService to start roles as per it's configuration.
For more information about Roles, see the documentation for RolesService.
Stop any services, as defined by imported modules of this runtime. For instance, if you import WebServerModule from @alterior/web-server, calling this will instruct the module to stop serving on the configured port. Also builds in a timeout to allow for all services and operations to stop before resolving.
This will send the OnStop
lifecycle event to all modules, which triggers the altOnStop()
method of any module
which implements it to be called. It also instructs the RolesService to stop any roles which are currently running.
For more information about Roles, see the documentation for RolesService.
Generated using TypeDoc
Used to construct a runtime environment for a given entry module. Handles resolving the module tree into an injector as well as constructing the module instances and running lifecycle events.


Hello {{ email }},
Thank you for registering! Please login here: {{ site_url }} Please be sure to check in regularly to see the latest updates!
Thanks,
CRC


DALI
A framework used by DALI Lab members to access the internal API, which stores all information about DALI’s projects, members, and events.
Getting Started
Authenticate
The API protects its data using two methods: private API key and Google OAuth2. This is done to support two different use cases: static installment or user-personal device.
Google OAuth2 (User-Personal)
A user-personal product could be an iOS app, Watch OS app, or anything that is personal to a user. This type of authentication uses the user’s login credentials with Google to authenticate and identify them.
Qualifications:
- The application acts on behalf of a single member
- The application modifies member information
- The application needs access to protected member information
Authenticating Using Google Signin:
- Choose a method of Google sign-in. Some good options are:
- When the user has signed in successfully with Google, extract their accessToken and refreshToken
- Using GoogleSignIn the information is stored in
user.authentication
- Using GoogleSignIn the information is stored in
- Use those tokens to sign-in with the API
swift DALIapi.signin(accessToken: accessToken, refreshToken: refreshToken) { (success, error) in if success { // Continue into the app // Your api will handle authenticated requests from here on } else if let error = error { // There was an error // Most likely the user didn't use a @dali.dartmouth.edu email } }
Althernate Method: Google OAuth2:
Some Google Signing sign-in systems (Not GoogleSignIn) may not sign the user in all the way, and instead of giving access and refresh tokens gives an authCode. In this case use DALIapi.signin(authCode: authCode) { ... }
.
API Key Auth (Static-Installment)
A static-installment product could be an Apple TV app, a kiosk-type desktop application, or pretty much anything that doesn’t need user sign-in. Its up to your imagination 😀!
Qualifications:
- The application does not act on behalf of any single member
- The application does not need to modify member information
Authenticating Using API Key:
- Contact an API administrator to register for an API key to be made for your app.
- The key’s access will be limited to the routes you need, but you can request more routes later if you need them
- Keep the key you get secret! It is an all access pass to the routes you were granted
- Create a plist file (sample shown below) to store the key and add it to .gitignore
- Load the file and load the config:
swift let file = NSDictionary(contentsOfFile: "path/to/your/file.plist") let config = DALIConfig(dict: file)
- Configure the API with your credentials
swift // ... let config = DALIConfig(dict: file) DALIapi.configure(config)
Done! Now you may make all the requests you are authorized to.
Events
Now that you have authenticated your system you can move on to Events. The event route is one of the simplest because it requires no special data and no requirements on authentication usage.
Get all events
DALIEvent.getAll { (events, error) in
if let error = error {
// Encountered a problem
// Check the type;
if error == DALIError.General.Unauthorized {
// ...
}else if ... {
// ...
}
return
}
// The events list is a [DALIEvent]? object
}
Get events within a week of now
DALIEvent.getUpcoming { (events, error) in
// ...
}
Create an event
DALIEvent.create { (success, error) in
// ...
}
Location
DALI uses bluetooth beacon technology to identify when a device is in the lab. You can use this to gain access to the location flag (in DALI or not) for Tim or any other member.
Get Tim’s Location
DALILocation.Tim.get { (tim, error) in
if let error = error {
// Encountered error...
return
}
if tim.inDALI {
// ...
}else if tim.inOffice {
// ...
}
}
Get shared users in DALI
DALILocation.Shared.get { (members, error) in
if let error = error {
//...
}
guard let members: [DALIMember] = members else {
return
}
// ..
}
Installation
DALI is available through CocoaPods. To install it, simply add the following line to your Podfile:
pod "DALI"
Example
Example project is still in alpha
To run the example project, clone the repo, and run pod install
from the Example directory first.
Author
John Kotz<EMAIL_ADDRESS>Requirements
Usage Requirements
You must be a member of the DALI Lab or be working on behalf (with the permission) of the DALI Lab to use this pod. By using this cocoapod you acknowledge this requirement.
Dependencies
- SwiftJSON
Function Specific Requirements
Some routes will intentionally crash your app if you use them without proper permission. Check out the docs on Protected Functions.
License
DALI is available under the MIT license. See the LICENSE file for more info.


Graphical Representation of My Model Data Ie Charts in Ruby on Rails Using Highcharts
We all need to see whats going on with my website. Is it running smooth, Whats the status of the users signup etc.
Take a look on these two graphs (Live demo).
- Graphs for total records (users, activities) on each day in the range of last 30 days.
- Graphs for total daily records (users signed up that day, activities done that day) in the range of last 30 days.
So for building these graphs, which are pretty useful, there are just few steps
- Include Jquery Highcharts Libray.
- Include rails module in your lib file.
- Include module in specific models for which you need to show graphs.
- Paste some js code and you are done.
Step 1
Include jquery library and exporting.js and highcharts.js files which you can easily find here
Step 2 Include act_as_coutable.rb in your lib directory and specify these in your application.rb file.
#lib/modules/act_as_coutable.rb
module ActAsCountable
def self.included(base)
base.extend(ClassMethods)
end
module ClassMethods
def total_records_counts_array_in_past_n_days(range = 30.days)
total_records = []
counts = self.group('Date(created_at)').count
(30.days.ago.to_date..Date.today).each do |day|
total_records.push((total_records.last || ) (counts[day] || ))
end
total_records
end
def daily_records_counts_array_in_past_n_days(range = 30.days)
counts = self.group('Date(created_at)').count
(range.ago.to_date..Date.today).map {|date| counts[date] || }
end
end
end
Auto load this module
/config/application.rb
config.autoload_paths = %W(#{config.root}/lib)
config.autoload_paths = Dir["#{config.root}/lib/**/"]
config.autoload_paths = Dir["#{config.root}/lib/modules/**"]
In models, include the module
class User < ActiveRecord::Base
include ActAsCountable
# other methods etc.
end
class Activity < ActiveRecord::Base
include ActAsCountable
# other methods etc.
end
So now all we need is the view file and here is the code for the same: For Daily Growth Chart ie first one:
$(function () {
var chart;
$(document).ready(function() {
chart = new Highcharts.Chart({
chart: {
renderTo: 'daily_growth'
},
title: {
text: 'Incremental Growth Charts - Gifts'
},
xAxis: {
type: 'datetime'
},
yAxis: {
title: {
text: 'Counts'
}
},
tooltip: {
formatter: function() {
return ''
Highcharts.dateFormat('%e. %b', this.x) ' -> ' this.y;
}
},
plotOptions: {
spline: {
lineWidth: 4,
states: {
hover: {
lineWidth: 5
}
},
marker: {
enabled: false,
states: {
hover: {
enabled: true,
symbol: 'circle',
radius: 5,
lineWidth: 1
}
}
}
}
},
series: [
{
name: 'Total Signups Today',
pointInterval: ,
pointStart: ,
data:
}, {
name: 'Total Activities Tday',
pointInterval: ,
pointStart: ,
data:
}
]
,
navigation: {
menuItemStyle: {
fontSize: '10px'
}
}
});
});
});
For Total Records Chart ie second one:
$(function () {
var chart;
$(document).ready(function() {
chart = new Highcharts.Chart({
chart: {
renderTo: 'growth_rate'
},
title: {
text: 'Growth Charts - Users and User Activities'
},
xAxis: {
type: 'datetime'
},
yAxis: {
title: {
text: 'Counts'
}
},
tooltip: {
formatter: function() {
return ''
Highcharts.dateFormat('%e. %b', this.x) ' -> ' this.y;
}
},
plotOptions: {
spline: {
lineWidth: 4,
states: {
hover: {
lineWidth: 5
}
},
marker: {
enabled: false,
states: {
hover: {
enabled: true,
symbol: 'circle',
radius: 5,
lineWidth: 1
}
}
}
}
},
series: [
{
name: 'Total Signups Today',
pointInterval: ,
pointStart: ,
data:
}, {
name: 'Total Activities Tday',
pointInterval: ,
pointStart: ,
data:
}
]
,
navigation: {
menuItemStyle: {
fontSize: '10px'
}
}
});
});
});
One more last thing. If you want to see stat counters on graph itself ie:
Change the plot options in javascript code to this:
plotOptions: {
line: {
dataLabels: {
enabled: true
},
enableMouseTracking: false
}
},


--- layout: page title: ! 'Secure Dynamic State Estimation via Local Estimators' comments: true ---
Yilin Mo and Emanuele Garone
IEEE Conference on Decision and Control, 2016
Link to the paper
If you want to leave any comments, you can annotate the pdf. I will try to be responsive. You can also annotate this page or leave comments below.
We consider the problem of estimating the state of a linear time-invariant Gaussian system using \(m\) sensors, where a subset of the sensors can potentially be compromised by an adversary. We prove that under mild assumptions, we can decompose the optimal Kalman estimate as a weighted sum of local state estimates, each of which is derived using only the measurements from a single sensor. We then propose a convex optimization based approach, instead of the weighted sum approach, to combine the local estimate into a more secure state estimate. Our proposed estimator coincides with the Kalman estimator with certain probability when all sensors are benign and is stable when less than half of the sensors are compromised. Numerical simulations are provided to illustrate the performance of the proposed state estimation scheme.


Things I learned Today - VoIP Hacking
Date - 3rd of January 2016
I always wanted to spoof calls and see if I can pretend to be someone and and looking at other people first reaction. Scenario: I spoofed my aunt number and called my uncle to see his reaction.
I have known this well known spoofing site called spoofcard.com. However, it doesn’t allow VoIP spoofing.
Hacking VoIP system would very interesting in social engineering engagement. Scenario:Performing internal penetration testing + Physical testing + Social Engineering sort og gig. (In short, red teaming).
Set-up:
- Kali-OS
- Softphone: It is a program for making telephone calls over the Internet
- To fake calls: Both parties in the scenario must support the same protocol (VoIP/SIP) or atleast once common audio codec.
- Metaspolit
- SIP Invite Spoof module: This module will create a fake SIP invite request making the targeted device ring and display fake caller id information.
Steps:
- Install Softphone application on Kali using apt-get install sflphone-gnome
- Open application by clicking next..next button
- Once the application is running click on Edit from the menu bar and follow path as Accounts-ip2ip-edit and select advanced tab.
- Select appropriate network interface (eth0) and keep rest of the settings as it is.
- Start Metasploit with msfconsole command
- Use the auxiliary/voip/sip_invite_spoof module in Metasploit
- show options - rest is self explanatory
Reference:
https://www.rapid7.com/db/modules/auxiliary/voip/sip_invite_spoof
Yay!!!! I am happy!!!!! :)


Make your printouts (File | Print) nice and informative with the help of keywords.
For example, use $DATE$ and $TIME$ to specify the exact date and time of the printout.


Mayo welcome for marine planning strategy
Mayo County Council has welcomed launch of the draft National Marine Planning Framework by Minister Eoghan Murphy and Minister of State Damian English.
The framework document sets out the forward planning component of the new Marine Planning system.
Peter Hynes, chief executive of Mayo County Council, who attended today's launch, said: “This document is a very crucial step in developing a thriving sustainable blue economy, particularly for the west of Ireland.
“Mayo’s strategic position along the Atlantic Coast, in addition to having the longest coastline should ensure that Mayo benefits from this initiative. I look forward to seeing the potential of a blue economy being realised in Mayo”.
The cathaoirleach of Mayo County Council, Councillor Brendan Mulroy, also welcomed this initiative by government, stating: “Mayo has always had a rich marine heritage and this framework will be key to enhancing that heritage for generations to come”.
There will be a consultation day in Westport in the Town Hall Theatre on Tuesday, November 26, from 2 to 4 p.m. and from 6 to 8 p.m. for those who wish to comment or find out more about the draft framework.


public abstract class ServiceCom
extends java.lang.Object
| Modifier and Type | Field and Description |
|---|---|
protected MTClientBaseCom |
dcb |
protected java.io.BufferedReader |
input |
private LogCom |
log |
protected java.io.PrintWriter |
output |
protected java.net.Socket |
socket |
protected ServiceStreamReaderCom |
streamReader |
protected java.lang.Thread |
thread |
| Constructor and Description |
|---|
ServiceCom(MTClientBaseCom callerDcb)
Constructor, it prepare the structure, but it neither creates any connection
nor spawns any thread
|
| Modifier and Type | Method and Description |
|---|---|
(package private) void |
checkHeartbeat()
Check if the Heartbeat signal has been received
|
(package private) void |
close()
close this service, disconnect any connection and stop the thread
|
(package private) void |
d__println(java.lang.String cmd)
Low level function.
|
(package private) void |
d_DARWINSTATUS()
Low level call.
|
protected void |
enableStreamOutput(boolean doPrintStream)
Control if received messages must be shown in console
|
abstract int |
getPort() |
boolean |
isOpen() |
abstract void |
onClose()
Deprecated.
|
abstract void |
onOpen()
Deprecated.
|
(package private) void |
open()
open this service, creating necessary connections
|
private LogCom log
protected java.net.Socket socket
protected java.io.BufferedReader input
protected java.io.PrintWriter output
protected ServiceStreamReaderCom streamReader
protected java.lang.Thread thread
protected MTClientBaseCom dcb
ServiceCom(MTClientBaseCom callerDcb)
callerDcb
- - the client that creating this servicevoid open()
void close()
void checkHeartbeat()
ServiceStreamReaderCom.checkHeartbeat()
void d__println(java.lang.String cmd)
cmd
- - the String containing the commandpublic boolean isOpen()
public abstract int getPort()
void d_DARWINSTATUS()
@Deprecated public abstract void onOpen()
@Deprecated public abstract void onClose()
protected void enableStreamOutput(boolean doPrintStream)
doPrintStream
- - true to print data in console


Delete selection
Ungroup selection
Group selection
Deselect
{{my_tree.get_anchor_node() | json}}
Based on Angular Tree DnD


Preparation time
less than 30 mins
Cooking time
10 to 30 mins
Serves
Serves 4
Roast lamb accompanied by peas, mint and lettuce, this recipe captures Spring's sweetness and freshness.
This meal provides 451 kcal, 37g protein, 5.5g carbohydrate (of which 2.5g sugars), 31g fat (of which 14.5g saturates), 2.3g fibre and 1.9g salt per portion.
For the lamb, preheat the oven to 160C/325F/Gas 3.
Season the lamb well with salt and pepper.
Place a heavy-based, oven-proof frying pan over a medium heat. When it is hot, add one tablespoon of the vegetable oil.
Put the lamb into the pan and colour it all over, turning it so that all sides brown evenly. Don’t rush this, the dish will have much more flavour and a deeper colour if you take your time.
Transfer the lamb, in the frying pan, to the oven, and bake for 8-10 minutes.
Remove the lamb from the oven, take it out of the frying pan and set aside to rest for 10-15 minutes.
In another frying pan over a medium heat, add the remaining vegetable oil and fry the bacon until crisp and golden-brown.
Add the chopped onion and cook for a further two minutes. Then pour over the lamb stock to cover the bacon and onion and bring to the boil.
Add the peas, butter, the lettuce and the mint, and season with salt and pepper to taste. Simmer for a minute or two until the lettuce is cooked.
To serve, slice the lamb, pour the pea, bacon and pesto mixture into a large bowl or individual serving dishes, and arrange the lamb slices on top.


×
Tracked Satellites:
click to select
Daily Satellite Schedule
Change Satellite
Time
|
Time
Satellite
Sensor
Orbit
Node
AOS time
LOS time
{% for acquisition in content %}
{{ acquisition }}
{% endfor %}


You can paste multiple ints at a time if you want! For example, -1953028026,-856931226,-1240793240,-1598231354.
-1953028026,-856931226,-1240793240,-1598231354
View on GitHub


We are the student branch for IEEE, the world's largest organization for technical professionals, at VGEC. IEEE VGEC Student Branch gives students the opportunity to meet and learn from fellow students, as well as faculty members and professionals in the various fields.
No matter what your background, if you are a student at VGEC, you are eligible for active IEEE student membership or you can join as a volunteer also.
Event description
Event description
Event description


Participate from wherever you are by contributing to a do-a-thon project or challenge. You can also browse according to: issue area, region, or skills needed.
Projects are ideas that are being put into action and need specific types of contributions. Project leads will specify what kinds of support, skills, and contributions they are looking for in their project Github thread.
Challenges are broader problems that don't yet have a concrete idea proposed on how to solve them. Groups working on challenges will work together to deeply understand a problem, the system that problem operates in, and who it affects, before diving into designing a solution. Proposed solutions to challenges can eventually turn into projects.
Once you've found a challenge or project you're excited about, it's time to get involved! Make sure you know how to contribute, stay up to date and be supportive before getting started.
Tip: Clicking on the "Help Needed" column will lead you to a discussion thread with more information about the type of support the project needs, and instructions on how you can contribute! See which projects have been most recently updated here.
| Project Name | What's this project all about? | Help Needed |
|---|---|---|
| {{Project Name}} | {{Project Summary}} | {{What aspects of the project need support during the do-a-thon? }} |
Unless requested, projects submitted in prevous years aren't listed above, but can be found here.
What problems are our community members trying to address today? Explore them below! Clicking on each 'challenge' will lead to a longer discussion thread about the topic. Or jump directly to our Github page to see what challenges have been most recently updated.
| What are we trying to solve? |
|---|
| {{Problem Statement}} |
Unless requested, challenges submitted in previous years aren't listed above, but can be found here.
On this page you can find lots of different ways to find something to get involved with. Once you find something, we'll take you to Github. The page you land on is a bit scary, but all you need to worry about is clicking on a topic that interests you. Then you'll be able to get involved. If you're not ready to get involved yet, but want to get updates on what happens, subscribe for notifications over email. There is a button on the sidebar for this when you're signed in!
Github is a platform for open source, collaborative working. We'll be using it as a space to work together on do-a-thon projects and challenges. Specifically, we are doing this through Github "issues". Each issue will act as a mini discussion thread for each project or challenge people are working on. If you don't already have one, you'll need to create a Github account. It only takes 5 minutes (top tips: try and use your name as your username, you only need the free plan, and you can skip step 3)!
After that, getting involved is as easy as posting a comment on the project or challenge you've chosen. You can explore projects and challenges right on this page. In your comments you can paste an image, make a link to Gdoc to flesh something out, anything. Just remember to bring it all back to the issue regularly to keep people up to date.
After you've commented once, you can keep up to date from your inbox automatically!
Doing activism is hard work, but knowing the community cares can get you a long way. Leave a comment saying you love someones idea or work, leave a smily face reaction, or share their idea on Twitter. It all helps. Finally, remember that all do-a-thon participants must comply with OpenCon's Code of Conduct — which does not tolerate discrimination or harassment.


On the mainland opposite the island of Hvar, about 25NM NW of Ploce. It is a busy tourist town.
Position 43°14.5'N, 17°04.9'E.
The harbour has been reconstructed and there are berths for yachts on pontoons here.
It is well sheltered although it can be subject to surge in SW winds.
Last updated February 2010.


Returns detailed error information when it is called after a previous XLODBC.XLA function call has failed. If this function is not available, you must install the Microsoft ODBC add-in (XLODBC.XLA).
Syntax
SQL.ERROR()
Calling SQL.ERROR returns detailed error information in a two dimensional array. Each row in the array describes exactly one error. If a function call generates multiple errors, a row will be created for each error. When SQL.ERROR is processed successfully, all SQL.ERROR information is cleared. Also, all SQL.ERROR information is automatically removed whenever an ODBC function completes successfully.
Each row will have exactly three fields. The information in these three fields is obtained through the SQLERROR API function call. These fields are:
A textual message describing the error.
The ODBC error class and subclass as a character string.
The data source native error code as a numeric value.
If one or more of these fields is not available for the type of error that was encountered, the field will be left blank. For more information on the meaning of these three fields, refer to Chapter 24, "ODBC Function Reference", in the Microsoft Open Database Connectivity Programmer's Reference for the SQLError API function. See also Appendix A, "ODBC Error Codes" in the same manual.
Remarks
SQL.ERROR cannot provide information on Excel errors.
If no error information is available when SQL.ERROR is called, then it well return the error value #N/A but does not post any error information to SQL.ERROR.
SQL.ERROR stores and returns error information by processing SQL.ERROR (in the ODBC API reference) in a loop until SQL_NO_DATA_FOUND is encountered. In the SQL.ERROR function, the error information is automatically defined and stored in memory whenever an XLODBC.XLA function fails. If the call is successful then SQL.ERROR will return the error information available. If SQL.ERROR fails, it will return the error value #N/A.
Example
When entered as an array formula, the following example will return error information about each argument in, for example, SQL.GET.QUERY.
SQL.ERROR()
Related Functions
SQL.OPEN Establishes a connection with a data source
SQL.EXEC.QUERY Sends a query to a data source
SQL.BIND Specifies storage for a result column
SQL.RETRIEVE.TO.FILE Retrieves query results and places them in a file
SQL.RETRIEVE Retrieves query results
SQL.CLOSE Closes a data source connection
Return to index


| NumberOfParameters |
annotation class NumberOfParameters Created by Tom Needham on 12/03/2016. |
| Query |
abstract class Query Created by Tom Needham on 12/03/2016. |
| ResultSet |
class ResultSet Created by Tom Needham on 12/03/2016. |
| Statement |
abstract class Statement : StatementType Created by Tom Needham on 10/03/2016. |
| StatementType |
interface StatementType Created by Tom Needham on 12/03/2016. |
| ValueQuery |
class ValueQuery : Query Created by Tom Needham on 13/03/2016. |
| WhereStatement |
class WhereStatement : Statement, StatementType Created by Thomas Needham on 12/03/2016. |


pso: Particle Swarm Optimization
The package provides an implementation of PSO consistent
with the standard PSO 2007/2011 by Maurice Clerc et al.
Additionally a number of ancillary routines are provided for
easy testing and graphics.
| Version: |
1.0.3 |
| Depends: |
R (≥ 2.10.0), methods |
| Suggests: |
numDeriv |
| Published: |
2012-09-02 |
| Author: |
Claus Bendtsen. |
| Maintainer: |
Claus Bendtsen <papyrus.bendtsen at gmail.com> |
| License: |
LGPL-3 |
| NeedsCompilation: |
no |
| In views: |
Optimization |
| CRAN checks: |
pso results |
Downloads:
Reverse dependencies:
Linking:
Please use the canonical form
https://CRAN.R-project.org/package=pso
to link to this page.


Code coverage of Cart
Global code coverage
18.34%
87.5%
book\cart\Cart
100%
book\cart\storage\SessionStorage
0%
yii\base\Component
57.14%
yii\base\Object


This is the administration zone
Only authenticated users with role ADMIN are allowed to see this page.
Add User
Incorrect LP
Groups
Roles
Add Menu
Back to home page


⍌ 2021-03-14
Anna drumming
Anna does her busking best
Fuji X-H1 35mm
⍌
Anna drumming
Anna does her busking best
Fuji X-H1 35mm
⍌ 2021-03-15
Anna drumming
Anna does her busking best
Fuji X-H1 35mm


Welcome to the Materials and Megabytes podcast!
Exploring the development of machine learning for materials science, physics, and chemistry applications through conversation with researchers at the forefront of this growing interdisciplinary field.
Episode 0
Start here for a brief introduction to this podcast!
Episode 1
Our guest on this episode is Professor Kieron Burke from the University of California, Irvine.
Episode 2
Our guest on this episode is Dr. Ekin Doğuş Çubuk from Google Brain.
Episode 3
Our guest on this episode is Professor Evan J. Reed from Stanford University.


FacetView Pure Javascript Frontend for SOLR and ElasticSearch
FacetView is a pure javascript frontend for ElasticSearch or SOLR search indices.
It lets you easily embed a faceted browser and search front end into any web page. It also provides a micro-framework you can build on when creating user interfaces to SOLR and ElasticSearch.
Demo
Use It Yourself
See the README on the GitHub repo.


Hits to draw Markush structures:
1. Draw a R atom
2. Right click on the atom and choose "Create R Definition" menu item. It will create "R1=" label there.
3. Right click on the "R1=" label, and select "Add Structure" menu item, and it will create a substructure
4. You can edit the substructure
5. To change R index number, mouse-hover R atom, and press +/-.


Operational Status
| Status | Action |
|---|---|
|
|
Airlines
| Airline | Status | Action |
|---|---|---|
| First Airline | Participant |
|
| LATAM | Unknown |
|
Register Flight
| Airline | Flight Code | Departure | Contract Status | Action |
|---|---|---|---|---|
| First Airline | FA1111 | 23:30 PM |
|
|
| LATAM | LT0001 | 23:59 PM |
|
Passenger/Buy Insurance
| Passenger | Flight | Value (up to 1 ether) | Actions |
|---|---|---|---|
|
Select a flight
|
Value must be between 0 and 1 ether
|
|
Passenger/Withdraw
| Passenger | Balance | Actions |
|---|---|---|
|
|


Video player with search (server-side)
Search terms are provided to the player using the data-search attribute. In this hypothetical example, we have entered the search term "you" into a search field. After the user submits the form, their input would be sanitized by the web application and Able Player would be loaded with the following attributes:
- data-search - the search term, expressed as one or more words, separated with space. Able Player will search for any of these words (using OR logic).
- data-search-div - contains the id of a <div> in which to display the search results.
- data-search-lang - optional, specifies the language of the caption or subtitle track to search. If omitted it will search the caption track for the default language.
- data-search-ignore-caps - true to ignore case; false for case sensitive search.
Also in this example, data-include-transcript is set to "false", since there isn't room on this page for both search results and a transcript. A better design would accommodate both features.
See also the client-side search demo.


Timing and scheduling
The Lua language itself does not have means to control time, however this has been added in LuaAV via the scheduler module. It allows us to schedule functions that can be paused and resumed in the process of generating audio. It is thus strongly timed in a similar manner to the ChucK live-coding language.
The main scheduler follows the cpu clock as closely as possible; however when slow functions are called (such as loading files and creating complex resources such as windows), the scheduler may experience a temporary drop-out, from which it will attempt to recover as soon as possible.
The scheduler preserves deterministic ordering and logical timestamps to high accuracy, and is used for many messages to the audio system (such as adding/removing synths). These functions are very useful for building up musical structures because of the temporal accuracy.
When scripts are run within the LuaAV application, the main scheduler functions are already available as globals. When run from a LuaJIT command line console, they will need to be loaded manually:
local av = require "av" local now, go, wait, event = av.now, av.go, av.wait, av.event
The now() function
Printing out now() in a script will return the logical time in seconds since the script was loaded. Until we start scheduling with time, all script actions occur immediately, so now() will return 0.
print(now()) -- prints 0
The go() function
The function go() allows us to schedule functions to run in the future. It will convert a function into a coroutine and add it to the scheduler. An optional first argument can specify the time (in seconds) to wait before this function is run, and additional arguments are passed to the function when it first runs.
go(print, "life") go(2, print, "and everything") go(1, print, "the universe") -- prints: "life" -- after 1 second, prints: "the universe" -- after 1 second more, prints: "and everything"
Of course you can put your own function instead of using print:
local function myprint(msg) print(msg) end go(myprint, "hello") -- or even create an anonymous function: go(1, function() print("world") end)
Coroutines are Lua’s way to provides parallelism within a script. One way of thinking about a coroutines is that it is like a parallel function or script state; another way to think about it is as a function that can be paused in mid execution, while Lua goes off to execute some other code, and to later returned to (resume) at the point at which it paused. (Lua is single-threaded by design, which means that only one actual function is executing at any time.) The go() and wait() functions connect coroutines with the LuaAV timing scheduler.
The wait() function
So far we can use go() to precisely choose when a function starts. This could be enough to create a sequencer, for example.
But since the functions are run as coroutines, we can also pause them in the middle, and resume them again later. We do this using wait(). The wait() function allows us to pause the execution of a function for a number of seconds, after which it will continue:
go(function() print("life") wait(1) print("the universe") wait(1) print("and everything") end)
What makes this more powerful is that it can be combined with other kinds of control flow such as for loops, while loops, nested function calls, and so on. Here’s a simple example of an infinite process that prints “tick” every 1 second:
go(function() while true do -- loop forever print("tick") wait(1) end end)
Combine this with now() to create a clock:
go(function() while true do -- loop forever print("tick at", now()) wait(1) end end)
Parallelism
When a coroutine is paused, other coroutines can continue to run. So we can launch multiple coroutines to create parallel processes, like multiple players in an ensemble, multiple voices in a drum machine, and so on.
Here’s a very simple example; it prints out a tick every 1 second, and a TOCK every 4 seconds:
function clockprinter(name, period) while true do print(now(), name) wait(period) end end go(clockprinter, "TOCK!", 4) go(clockprinter, "tick", 1)
Remember, the go() function can also take an optional first argument (delay in seconds), which allows us to schedule it to occur at some point in the future:
go(1.75, clockprinter, "tickety", 2) -- will start 1.75 seconds later
So we can create many parallel copies of the same function that can be scheduled alongside each other, each with potentially distinct timing, but without losing deterministic accuracy.
In this way you can easily create musical patterns like Steve Reich’s Clapping Music or the phasing patterns of his Drumming for example.
Note that the even if the initial delay argument to go() is 0, or is not given, the coroutine will not run immediately; go() simply adds the coroutine to the internal scheduler. The function will run as soon as the scheduler next activates, which is either at the end of the script (in av.run() for console-based scripts), or when the next wait() call is made:
-- this code prints out "hello world": go(print, "world") print("hello")
Nested coroutines
Withing a scheduled coroutine we can continue to call other functions, and the thread of execution will follow the calls until either a wait() is reached, or the original function returns. This allows us to decompose a complex pattern into smaller functions.
We can also launch new coroutines from within another, spawning many parallel threads of execution. Putting these together, here’s an implementation of Steve Reich’s Clapping Music:
--[[ An attempt to implement Steve Reich's "Clapping Music" --]] function clap1() -- implement clap sound here print("clap1") end function clap2() -- implement clap sound here print("clap2") end local dur = 1/8 -- clap N times: function claps(sound, n) for i = 1, n do -- humanize: local jitter = math.random() * 0.01 -- run the clap sound as another sub-process independent of main time: go(jitter, sound) -- note length: wait(dur) end end function rest() wait(dur) end -- this is the main pattern that is repeated over and over by each player: function pattern(sound) claps(sound, 3) rest() claps(sound, 2) rest() claps(sound, 1) rest() claps(sound, 2) rest() end -- the process of each player: function clapper(sound, shift) while true do for i = 1, 4 do pattern(sound) end if shift then rest() end end end -- player 1 does not shift: go(clapper, clap1, false) -- player 2 shifts: go(clapper, clap2, true)
The event() function
Sometimes we want to schedule activity to occur not at a given time, but when a given situation occurs. To support this, the go() and wait() functions can also take a string argument (instead of a duration). The string represents the name of a unique event.
-- schedule a function to call when the "foo" event next occurs: go("foo", function print("the foo happened") end)
The event() function can then be used to resume ALL coroutines that were scheduled against or waiting upon a particular event.
-- trigger it: event("foo")
A common use-case of this is to schedule sequences to arbitrary rhythmic patterns:
-- launch a background process to trigger "beat" events with a 1/0.5/0.5 pattern: function rhythm() while true do event("beat") wait(1) event("beat") wait(0.5) event("beat") wait(0.5) end end go(rhythm) -- launch another process to respond to these events by alternating AAA and BBB: function printer() while true do print("AAA") wait("beat") print("BBB") wait("beat") end end go(printer)
Event arguments
The event() function can also take additional arguments; these arguments are received by (as return values of) any corresponding wait(). In this way an event handler can respond with more nuance.
go(function() while true do local result = wait("foo") print("received", result) end end) go(function() while true do event("foo", math.random()) wait(0.5) end end)
Events and the window draw() callback
Another common use of event() is to make sure that graphical rendering commands only execute during a window’s draw() method, which is the only place they are valid.
The following example shows how a function drawstuff() is scheduled to execute only when the draw event occurs, and once it does, to wait until subsequent drawevents to continue rendering:
local draw2D = require "draw2D" win = Window() -- the window rendering function function win:draw() -- resume any functions waiting on the "draw" event event("draw") end function drawstuff() -- run forever: while true do draw2D.line(0, 0, -math.cos(now(), math.sin(now())) -- wait for the next frame wait("draw") -- now wait for a random fraction of a second wait(math.random()) end end -- start drawstuff() when the next "draw" event occurs: go("draw", drawstuff)
Regardless of the frame-rate requested of a window, the actual timing of draw() calls can vary widely. If you want to preserve accurate timing in a coroutine, launch draw event handlers as sub-coroutines instead:
function drawstuff() -- run forever: while true do -- render on the next frame (do not wait) go("draw", function() draw2D.line(0, 0, -math.cos(now(), math.sin(now())) end) -- now wait for an accurate amount of time: wait(0.25) end end
Note that it is not valid to wait() inside any of the window callbacks such as draw. Also, be careful not to wait() in the middle of a gl.Begin/gl.End pair, which would leave OpenGL in an inconsistent state.
Pausing the main script
From within the LuaAV application, the main script is already running as a coroutine, so it is possible to wait() at the top-level of code. When launched from a command line, this is not possible; but to achieve the same result you can launch your script via another:
go(dofile, myscriptname)
Script-controlled schedulers
You can also create your own schedulers, which are independent of CPU clock, using the scheduler.create() function. A scheduler is an object that provides its own now(), wait() and go() functions. Unlike the main scheduler, the logical time of this user-controlled scheduler is not tied to the CPU clock, but instead is advanced within the script using the advance() or update() functions of the created scheduler.


Source code for discordSuperUtils.Spotify
import asyncio
from typing import (
Optional,
List,
Dict,
Union
)
import spotipy
from spotipy import SpotifyClientCredentials
FIELD = "items.track.name,items.track.artists(name),total"
[docs]class SpotifyClient:
def __init__(self, client_id: str, client_secret: str, loop=None):
self.sp = spotipy.Spotify(auth_manager=SpotifyClientCredentials(client_id=client_id,
client_secret=client_secret))
self.loop = asyncio.get_event_loop() if loop is None else loop
[docs] @staticmethod
def get_type(url: str) -> Optional[str]:
"""
This function receives a url and returns the type of the URL.
Return examples: playlist, user, album, etc.
:param url:
:return:
"""
url = url.replace("https://open.spotify.com/", "")
return url.split("/")[-2]
[docs] @staticmethod
def make_title(song: Dict[str, dict]) -> str:
"""
This function receives a song and creates a title that can be used for youtube_dl searching.
Return example: Never Gonna Give You Up by Rick Astley
:param song:
:return:
"""
artists = " ".join([artist['name'] for artist in song.get('artists')])
return f"{song['name']} by {artists}"
[docs] async def fetch_playlist_data(self, url: str, offset: int) -> Dict[str, Union[int, list]]:
"""
This function receives a URL and an offset and returns 100 tracks from that offset
Example: Offset: 50, the URL has 160 tracks, returns tracks from 50-150 (limit is 100).
:param url:
:param offset:
:return:
"""
return await self.loop.run_in_executor(None, lambda: self.sp.playlist_items(playlist_id=url,
fields=FIELD,
offset=offset))
[docs] async def fetch_full_playlist(self, url: str) -> List[Dict[str, dict]]:
"""
This function receives a url and returns all the tracks in that URL.
:param url:
:return:
"""
initial_request = await self.fetch_playlist_data(url, 0)
total_tracks = initial_request.get('total')
requests = list(
await asyncio.gather(*(self.fetch_playlist_data(url, offset) for offset in range(100, total_tracks, 100)))
)
requests.insert(0, initial_request)
result_tracks = []
for request in requests:
result_tracks += request.get('items')
return result_tracks
[docs] async def get_songs(self, url: str) -> List[str]:
"""
This function receives a URL and returns all the tracks in that URL.
:param url:
:return:
"""
playlist_type = self.get_type(url)
songs = []
if playlist_type == "playlist":
return [self.make_title(song['track']) for song in await self.fetch_full_playlist(url)]
if playlist_type == "track":
songs = [await self.loop.run_in_executor(None, lambda: self.sp.track(track_id=url))]
if playlist_type == "album":
album = await self.loop.run_in_executor(None, lambda: self.sp.album_tracks(album_id=url, limit=50))
songs = album.get("items")
return [self.make_title(song) for song in songs]


A small group convened at Q42 in Amsterdam on May 2, 2017 to continue the conversation. This meetup was less structured than the previous two. There was no formal agenda. But the conversation roughly covered the following topics:
Some us want to do things as a tech worker that have societal value, that are impactful and that do this in a structural way, not an incidental way. Others want to make a difference without having to go into politics. Still others have crossed over from industry into education to make a difference through the people we teach.
At Q42 they want to improve the diversity and inclusivity of the tech scene. One thing that they started to do this is Girl Code, a meetup for women in tech. They also initiated CodeUur, programming classes for primary education. (CodeUur has since joined forces with Dreamery Foundation and FutureNL.) The basic idea is to prepare young people for the digital world and to make sure people from a wide range of backgrounds are included.
Someone mentions seeing Peter R. de Vries talk about allowing the justice department to access medical records of hospitals. They would like to see programmers refusing to work on stuff like that.
One way to promote professional ethics is to make it part of education programs.
But professional ethics also need to be put into practice. We talk about how in a way it might be a privilege to be able to turn down jobs or gigs that do not align with our values. One perspective is that not everyone has the luxury to exclusively work on things that we would deem ethical. Another perspective is that this certainly could be the case for a given definition of ethics.
At some companies employees are free to refuse to work for particular clients because of personal ethics. Such companies have a culture where these things can be discussed and sufficient resources to deal with such matters flexibly.
It is suggested that awareness of ethics, and a literacy about it are lacking. We talk about how it seems very few higher education explicitly train designers and programmers to think and talk about ethics as it relates to their practice.
If we really want to change this we would need to attack it through the national frameworks that prescribe the things that need to be included in programs.
Interestingly, the legal side of things does get attention in education. Things like security, intellectual property, liability.
It also seems that at least to some extent companies are getting wise to the need to deal with privacy concerns in a structural way. But there are plenty of examples where privacy is dealt with in a problematic way. Someone asks the question, how do you deal with this as an individual worker, when you discover your employer is making bad decisions.
Also, when someone has bought into the need to do things the right way, how do they then actually go about it? Practical guidelines for ethical tech are not easily available. Working ethically takes more time than just doing whatever. Some things are simply hard or impossible to do with today’s technologies. Someone mentioned having databases encrypted at rest is a good idea but it is hard to work with.
We explore the parallel of web accessibility for a while. One person feels huge strides have been made among other things because there are copious guidelines and the tech has improved. Someone else disagrees and claims accessibility is still done poorly more often than not.
On the topic of accessibility the project Empat.io is mentioned. A website with stories from disabled people about their experience using technology. It helps designers and programmers understand the need for doing the right thing more acutely.
Empat.io is a good example of how we also need to appeal to people’s emotions when it comes to these things. If we want people to care about tech solidarity they need to have a sense of how it makes difference in people’s lives.
Telling stories about how tech can help or hinder solidarity might not be a bad place to start.
Also, as with ethical tech, sometimes accessibility is at odds with aesthetics and takes longer to get right. So to make it happen you need to make the business case for it.
We review the golden circle model and try to map what we discussed so far to it.
The ‘why’ is still promoting an open society.
The ‘how’ is promoting professional ethics among tech workers.
The ‘what’ is storytelling, education, and tools and guidelines.
We might find allies in the InfoSec community. They are good with tech but a bit hard to get into. They do lack design resources so we might be of help there.
In general if we have desired behaviours we should work to make those easier for tech workers. As the old saying goes: organise, educate, agitate. The educate aspect is actually very useful. But before we get to it we can get much better at the organise aspect.
A final though offered by someone is to come up with manifesto. Examples include the IoT Manifesto and the never again pledge.
Finally, we discuss how to make it easier for people to be involved with our little nascent movement. One obvious thing to do is to have a regular schedule for the meetups. We’ll settle on a monthly meetup on the same day of the month. Let’s say the first Monday of every month.
In this stage we don’t necessarily need massive turnout because smallish groups are better at having deeper conversations. However at some point we want to scale up a bit so we can have more impact.
We should make it easier to collect and share the resources we find useful in our individual practices. For this, we need better tooling than the current static website and GitHub pull requests.
An example includes the Resistance Manual, which has a ton of resources. But it lacks context. Someone suggests any resource linked to needs a sentence or two providing a summary of some sort. A TLDR so that people can decide wether they need to look into it further. This also applies to links shared in the Signal group.
Speaking of the Signal group, we feel it does not work well to foster a sense of community because it lacks presence, identity and such things. It woud be nice to have a more sophisticated alternative without having to buy into a death star platform. Maybe have another look at Mattermost?
Some final things shared before we wrapped up. Attendees agreed it’s nice to see ideas related to what to do firm up. At the same time it is appreciated we are taking the tame to create common ground. We agree we are all inspired to continue this thing.
We have the sense that for some people, now that we are in the post-election lull and waiting for a new government to be formed, a sense of urgency is lacking. This will surely change once the formation period is behind us. But we can also work ourselves to maybe foster a sense of urgency. At some point we need a purpose, a why, for people to rally around.
Some more examples of tech for good initiatives are mentioned: Zeekat, Hack the Planet, Greenpeace using UAVs to capture footage of Indonesia forest fires.
As mentioned before, there are a lot of initiatives related to our cause. Shouldn’t we collect and disseminate them? Couldn’t we be a clearing house for alternatives?
We end the meetup with renewed resolve to continue the work.


We formulated them as questions and answered them as if a kid had asked them:
--- layout: default type: intro title: "ELI5" description: "The Horizen Academy is a free educational platform on blockchain technology, cryptocurrency, and privacy. In this chapter, we explain blockchain and related topics in a simple and easily understandable way." permalink: /eli5/ topic: eli5 css: | .site-content-wrapper { background: url(/assets/img/bkg/bg-eli5-p1.jpg) no-repeat top left; } .site-content-wrapper > .container-fluid { background: url(/assets/img/bkg/bg-eli5-p2.jpg) no-repeat bottom right; } @media (max-width: 991px) { .site-content-wrapper > .container-fluid { background-size: 55% auto; } } .post-section .post-title { font-size: 2.5rem; } .welcome-text { font-size: 1.2rem; } .list-eli5-articles a { color: #041742; font-weight: bold; } ---
ELI5 - or Explain it Like I'm 5 - articles are meant to provide the shortest and easiest explanation of a topic. Using analogies and abstractions they should convince the basic idea behind a concept so that even children understand what is being talked about.
We have picked a few important concepts and technologies and broke them down as much as we could.
We formulated them as questions and answered them as if a kid had asked them:


Your first priority when tuning archiving is to ensure that LGWR never gets stuck on a log switch waiting for ARCn to finish archiving a log file. Your second priority is to minimize the impact that ARCn has on foreground processes when it is active. Of course, these two priorities are opposed to one another. Our preference is to tune ARCn to run quickly, and only slow it down if there is evidence that it is impacting foreground performance.
In addition to following the disk configuration principles outlined in our series of database creation tips, the key areas to tune are the size and number of buffers available for archiving, and the number of ARCn processes.
ARCn reads buffers of _log_archive_buffer_size, specified in log blocks, from the online log file, and writes them to the archive destinations. Therefore, ARCn's performance is maximized, and its load on the I/O subsystem is minimized if _log_archive_buffer_size is set to the maximum value possible under your operating system. If this parameter is unlimited on your operating system, then it is best set to several times the maximum physical I/O size.
If multiple _log_archive_buffers are available and if asynchronous reads are possible from the online log files, then ARCn will use the aio_read() system call to read the redo into multiple buffers in parallel. If multiple log members are available, then parallel asynchronous reads will be addressed to distinct log file members in order to spread the disk I/O load. If hardware or software mirroring is used in preference to log file multiplexing, then similar load balancing is performed automatically by the operating system or hardware. Therefore, you should plan for the parallelism of archiving reads to be equal to the number of disks used for each log file, whether mirrored or multiplexed, and configure that number of _log_archive_buffers up to a maximum of three.
Note that multiple _arch_io_slaves cannot be used to simulate parallel asynchronous reads from the log file members. ARCn always performs this task itself and only uses the I/O slaves for writing.
To sustain asynchronous archiving writes if possible, two more _log_archive_buffers should be made available, over and above those required for parallel reading from the log files. This allows for maximum archival performance. However, if your system is so CPU bound so that foreground performance is noticeably affected during archival, and if there is no risk of archival backlogs, then the number of buffers may be reduced, to spread out the CPU impact of archival over a longer period.
As explained in Disk Configuration for Archived Log Files, it is normal to require multiple ARCn processes if heavy redo generation will be sustained, or if archiving to multiple destinations. From release 8.1, this is allowed for by setting the log_archive_max_processes parameter.  This command has very little impact if there is no archival backlog. It just takes a shared lock on the CF enqueue briefly. However, if an archival backlog is developing, this command effectively spawns an extra ARCn process to help catch up the backlog.
The ability to run multiple ARCn processes is your most important insurance against LGWR getting stuck behind archival backlogs. However, for this strategy to be effective, it is essential that the disks for the online files and archive destinations be configured appropriately.
Because manual archiving is always possible, Oracle holds an exclusive WL (writing log) enqueue lock on any online log file while archiving it, regardless of the log_archive_max_processes setting. Operations against these enqueues are protected by the archive control latch. Archival activity can be inferred from standard performance reports (such as those produced with utlbstat.sql and utlestat.sql) by examining the gets against this latch.
Yes, there are two more dangers to be aware of that can impact ARCn performance.
In a parallel server environment, when an instance is not up, its thread is closed but remains enabled. If the current SCN of a closed, enabled threads falls behind the force SCN, then a log switch is forced in that thread and the ARCn process of an active instance archives the log file on behalf of the inactive instance. Of course, this distracts the ARCn process in that instance from doing its own job. While that ARCn process will suspend this work to archive a log for its own instance if posted by its LGWR, this should be avoided entirely either by keeping the idle instance up, or by disabling its redo thread.
Archival is also disabled entirely during the roll forward phase of instance and media recovery. So try to ensure clean shutdowns, and keep redo generation to a minimum during and shortly after online recovery.
| Copyright © Ixora Pty Ltd |
|