EQ and IQ
I think that Emotional Intelligence is the strength of the mind to enable the awareness and management of emotions and thoughts. It can be trained so that a person can consciously act in a situation instead of simply reacting.
IQ has to do with a person’s intellect, and their cognitive abilities. It is a measure of how well a person can retain knowledge. Whereas EQ has more to do with mental stability, clarity of thoughts and emotions.
Headspace
I regularly practice mindfulness and I find it be very calming, it can help put my mind at ease or give clarity in some situations.
With meditation/mindfulness, I am able to separate my thoughts from emotions, let go of the thoughts and it's judgements, and simply notice the emotions without being overwhelmed by them. (Well not all the time, but more often than not, it takes practice.)
I meditate almost daily. It’s not always the same type of meditation; for example – some days I will listen to guided meditation, while others I will simply practice the breathing technique or body scan.
Partner Loop reflection
What was it like to be fully listened to?
I actually really enjoyed this experience. I noticed that I get really nervous when I know that someone is actually paying attention to what I am saying. I think we as modern humans, have become fairly used to creating ways for ourselves to be heard. We can dress to how much we want people to pay attention to us, or use repetitive texts, tweets, likes, volume, emojis, flashing gifs etc. to get a response from someone. This is why when you know someone is listening, without interrupting with their own opinion, we almost run out of content as we are used to using additional methods as a form of communication.
At least that was my outtake of that exercise
What was it like to fully listen?
I thought I would be good at this but realized that I am quick to summarize a persons’ thoughts and feelings into a sentence. And from that sentence, I analyze that person. In doing this, I lose out on the details of what the person told me, and just remember their feelings on the topic. I guess this explains why I remember that I am upset, but don’t know what I was upset about.


Davola Mitchner
<EMAIL_ADDRESS>40 Endicott Street #2 Canton, MA 02021
(781) 828-3103
(857)258-1407 mobile
Summary
IT professional Technical Trainer
20 years plus experience training individuals on the use of various computer platforms, software and technologies Including curriculum design >
knowledge of multiple Technology disciplines, platforms and Industries including Ellucian used on 90% of College and Universities
Virtualization
Security
Documentation and Regulatory Compliance and Risk Management
Analysis/Design
Project Management
Cloud Computing
TechnologySkills Summary
Data Center/Systems Administration/Technical support:
Data Center Administration, Storage, Application Infrastructure Administration. Backup
System Administration (AIX,OSX, Linux, Windows) Power (APC), CCNA(route/switch, security) system updates, account security (GPO, Active Directory LDAP, AFP ACL),asset management, performance monitoring.
Virtualization:
VMware (datacenter, desktop, cloud), Virtual Box, KVM, Hyper-V
Application Infrastructure/DEVOPS
Provisioning of Services
Administration of Development Infrastructure
Maintenance of Development Environment
Network Administration :
Routing/Switching, wireless, Security, Windows,Linux MAC OS-X servers, Active Directory, DNS,
Network Protocol/Traffic Analysis, SIEM
Configuration Management:
Puppet, Chef, Docker, Vagrant, Git
Storage Area Network:
EMC CSX SAN,, knowledge switching environment internal to SAN connection to network
Provisioning of zones storage
IBM AIX
Cloud computing:
EMC Cloud, Azure, OpenStack, AWS Google cloud
Database/CRM:
Sales Force, SQL server, Access , MYSQL,UNIQUERY for AIX
Email:
Account Maintenance and provisioning( Exchange, IMAP, SMTP, POP3}
Analysis and Design:
System Modeling, Network Design, Application Evaluation
Web:
Software Engineer, Web server configuration,Webpage design. HTML, XML, CSS java script, PHP, Dreamweaver,
FTP. Web server configuration (Apache and IIS and AWS)
Storage/Backup:
EMC Storage Management, NetApp, Fiber channel, ISCSI,SAN,NAS. Backup (disk, tape, and SAN). CommVault
Programming:
JAVA , Python,Web
Security:
ACL, Firewalls (Linux, Cisco) IDS, IPS, VPN, IPSEC, CISSP, Ethic Hackings,SIEM
Business Administrative and Finance skills
Financial:
Budget reporting. Payroll. Bookkeeping. Strategic Planning. Project management and Business Analysis
Financial Statements.Ratio Analysis. Payroll Federal Taxes. QuickBooks. PEACH-TREE.
Preparation of expense and budget reports. Knowledge of MASS State Accounting System(MMARS)
Business /Technical Writing:
Technical/procedural and Project Management/Business Analysis documentation Policy manuals.
Curriculum development.
Project Management:
Developed program model for technical trainings and Assessment planning. Volunteer recruitment and matching. Project reporting and documentation
Regulatory Compliance:
Familiar with standards for regulatory compliance (SOX, CMR, PCI, HIPPA, GLBA, FERPA and COBIT, ITL) and the design of control framework for governance
Teaching/Training :
Technical course Instructor. Curriculum development and Evaluation
Trained companies (non profits) in the use of and decisions of technology for capacity building
Additional Highlights
Knowledge of Administration and Support of all components of Major Academic System used in over 90% of American University and College systems Ellucian (formally Colleague)
Lead member on Database server project for ticketing System
Lead Support on Set up of various modules of ERP system (Development, Training, Production)
Sole Technical support for Developers in main ERP systems
Responsible for update management/ Monitoring and troubleshooting. Sole Vendor liaison for inquiries/solutions
Managed AIX/UNIX based updates for Development environment
Cabled residence for connectivity to ISPCreated training documentation for technical proceduresCabling/Configuration of Data Center equipment (Servers, UPS, Storage)Project Manager and Facilitator for Technical trainings and Skills Based Volunteer placementeveloped program plan for Technology Assessment and Planning for Non Profits
Work History
Network Technology Academy- Academic Alliance Coordinator/Administrator
2013-2018
HandsOn Tech Boston – Technical Project Manager
2012-2013
Berklee College of Music- System Administrator/Data Center 2006-2012
PREP -Assistant System Administrator/Support Tech/Instructor 2003-2005
Project Place - Computer Instructor
2003-2003 IBA-ETC/Villa Tech Project –IT Support Technician 2000-2002
Massachusetts Water Resource Authority -Graphic Artist/Content Updater
2000-2001
Project Place - Budget/Finance Director
1998-2000
Education
University of Massachusetts Lowell
Courses work towards M.S. in Information Technology
2015 - 2017
Northeastern University B.S. Information Technology
January 2013
Additional Studies
CISCO Networking Academy SIEMCISCO Network Academy CCNA
CISCONetwork Academy CCNA security EMC Information Storage Management (ISM)
EMC cloud computing (CIS)VMware (VCP 5x) Administration and Configuration
VMware Horizon ViewMCSE
Security + /Ethical HackingCISSP
CompTia Linux+ LPIC 102-102AIX /IBM - System Administration


G20 foreign ministers, including South Korea's Kang Kyung-wha, gather in Nagoya for Japan's last turn as host
by Reiji YoshidaNAGOYA – Foreign ministers from the Group of 20 major economies gathered in Nagoya on Friday, where they were set to discuss free trade, sustainable development and how to best assist rapidly growing economies in Africa.
The two-day event — the last of the eight ministerial G20 meetings to be chaired by Japan this year — will be attended by Chinese Foreign Minister Wang Yi, Russian Foreign Minister Sergey Lavrov and U.S. Deputy Secretary of State John Sullivan.
A big question had been whether South Korean Foreign Minister Kang Kyung-wha would show up.
Kang didn’t reveal whether she would attend the G20 sessions until the last minute but indeed landed in Nagoya on Friday night.
The same day, a key intelligence-sharing pact between them was extended in the hours before it was due to expire.
RELATED STORIES
Meanwhile, the attention of most Japanese diplomats appeared to be focused on bilateral meetings to be held on the sidelines of the summit. There was no plan to issue a joint statement, according to a Japanese diplomat.
The G20 meeting in Nagoya will likely see the foreign ministers briefly explain their official positions on issues rather than seek a consensus on any particular hot topic issue, a senior Japanese diplomat said, noting that Wang, for example, is not scheduled to address major economic or trade issues.
Still, the plenary session on Saturday will provide a good opportunity for participants to discuss controversial reform proposals being put forward by the World Trade Organization, the official said.
On Monday, Wang and Motegi plan to hold a bilateral session in Tokyo, together with other Cabinet-level officials to discuss human and cultural exchanges between the two countries, including the promotion of tourism, Japanese officials said.
In recent months, Beijing and Tokyo have tried to further cement their recently improved bilateral relationship in preparation for a planned visit by Chinese President Xi Jinping to Japan next spring.
Amid a trade war with the U.S., China has tried to improve ties with other countries.
GET THE BEST OF THE JAPAN TIMES IN FIVE EASY PIECES WITH TAKE 5
JOIN THE CONVERSATION


[@table_select serviceName="phoenixSaleService" pageNum="${pageNum!'1'}" expireFlag='1']
[#if couponList??]
[#list couponList as coupon]
Coupon Code: ${coupon.couponCode!''}
Go to use
[/#list]
[#else]
[@web_image pid="29551491" pname="优惠券为空.jpg" width="" height=""/]
[/#if]
[/@table_select]


I am a GMP cleaner who wants to be either a web developer or a software engineer
I started this type of job about 10 years ago. It's been a great experience so far.
But my true passion and love is for soccer.I have been playing it and watching it since I was a little boy (A long time ago)


This tab summarizes some display and editing functions:
This sections axplains the various functions.
The grid overlays the current document. It does not persist in the document. Changing grid properties does not change the content.
The following snippet from demo code shows how the ribbon controls set the various Grid options through the Html Editor's Grid property.
void _spinnerGridSize_ExecuteEvent(object sender, ExecuteEventArgs e) { EditorDocument.HtmlEditor.Grid.GridSize = new Size((int)_spinnerGridSize.DecimalValue, (int)_spinnerGridSize.DecimalValue); } void _buttonShowGrid_ExecuteEvent(object sender, ExecuteEventArgs e) { EditorDocument.HtmlEditor.Grid.GridVisible = _togglebuttonShowGrid.BooleanValue; _spinnerGridSize.Enabled = _togglebuttonShowGrid.BooleanValue; _comboboxGridStyle.Enabled = _togglebuttonShowGrid.BooleanValue; _dropdownGridColor.Enabled = _togglebuttonShowGrid.BooleanValue; } void _comboboxGridStyle_ExecuteEvent(object sender, ExecuteEventArgs e) { EditorDocument.HtmlEditor.Grid.GridVisualisation = (GuruComponents.Netrix.WebEditing.Behaviors.GridType)Enum.Parse(typeof(GuruComponents.Netrix.WebEditing.Behaviors.GridType), _comboboxGridStyle.StringValue); } void _dropdownGridColor_ExecuteEvent(object sender, ExecuteEventArgs e) { EditorDocument.HtmlEditor.Grid.GridColor = _dropdownGridColor.Color; }
Hint: You can show the Grid's properties in the PropertyGrid control to access all properties at once.
In absolute position mode the editor runs in what we call "Grid Layout". Once you have few objects that overlay each other, you can set the order by several options. The HtmlSelection class exposes several features, such as BringToFront or SendToBack, as shown in the demo. Several more are available as public methods.
Among the various options the demo shows the MultipleSelectionAllowed property. If on, the user can select more than one element and move, resize, or change its z-order.
You can turn scrollbars on and off, set the color, retrieve the scroll position and set the current scroll position programmatically. Scrolling appears if the document size exceeds the available space. If the content fits into the window, you cannot scroll, neither using the scrollbar not programmatically.


| Date/Time | {{payment?.firstPartTimestamp | date:'dd/MMM/YYYY HH:mm'}} | ID |
{{payment.id}}
|
Destination |
{{payment.recipientNodeAlias}}
|
Amount (Sats) | {{(payment?.recipientAmount) | number}} |
|
No payment available. Getting payments... {{errorMessage}} |
Total Attempts: {{payment?.parts?.length}}
|
{{payment.id}}
{{part.id}}
|
{{payment?.recipientNodeAlias}}
{{part.toChannelAlias}}
|
{{payment?.recipientAmount | number:'1.0-0'}} {{part.amount | number:'1.0-0'}} |
|
|---|


Anitas Kitchen is a web page about a Restaurant going by the same name and showcasing the different kinds of meals they have to offer.
Technologies Used HTML,CSS
This was a collaborated work on a website that helps travellers get proper guidance on where to vivit while in Kenya and places to stay.
Technology used HTML,CSS,GIT,GITHUB
This is a website page that gives records and tracks sales in a Dairy farm in relation to the production of milk for the whole year.
Technologies used HTML,CSS,JAVASCRIPT,GIT,GITHUB


Beta This is a test version of the layout of this page. Take the survey to help us improve it
Promotional material
Links to streamed videos which schools can use for teaching free of charge.
The list of links in this guide will take you to websites where you will be able to stream schools programmes at no cost. The 15-minute programmes were originally shown on Teachers TV.


Contents
GEODEMO_2
Using VSLICEG to create a vertical section from a 3D field
% OpenDAP dataset: url='http://geoport.whoi.edu/thredds/dodsC/usgs/vault0/models/examples/bora_feb.nc';
Use nj_tbx legacy functions in NCTOOLBOX
here we'll use a convenience function nj_tslice that returns a full 3D field and grid (t,z,y,x) at a particular time step
itime=1;
[data,grd] = nj_tslice(url,'temp',itime);
Plot the surface temperature from this data
here we are using ROMS output, where the last level(end) is the surface
figure; pcolorjw(grd.lon,grd.lat,double(data(end,:,:))); colorbar
Create a vertical cross section through the gridded dataset
specify a lon,lat track along which to calculate the vertical slice:
track=[ 12.7950 45.4588 12.9280 44.9895 13.1773 44.3736 13.8090 43.9190 14.8562 43.2444]; lon=track(:,1); lat=track(:,2); hold on; plot(lon,lat,'k-o') hold off; title('Surface temperature and track for vertical section');
calculate the vertical section using VSLICEG
[x,y,vdata] = vsliceg(data,grd,lon,lat); figure; pcolorjw(x,y,vdata);ylabel('m');xlabel('km'); colorbar title('Along-track vertical section of temperature'); shading interp
griddata_lite is triangulating data ... Warning: TSEARCH will be removed in a future release. Use DelaunayTri/pointLocation instead. ... triangulation complete griddata_lite is triangulating data ... Warning: TSEARCH will be removed in a future release. Use DelaunayTri/pointLocation instead. ... triangulation complete


Yes, you were called impatient, hasty and quick if you wanted to look at the samples. Well it was a joke (perhaps a weak one). Or maybe it was deemed important to read the conceptual overview. In any case, the rest of this guide assumes you've looked at the samples. Using Couch Potato is actually pretty easy, and without seeing it in action it may feel more complicated and confusing than it needs to be or is.
So have a look at the source and its readme and see them in action!
Since Couch Potato component definitions run outside of the Angular context, there are two things we need to "do to" the app in order to be able to reach back into it to register components. Let's take them in order of when they occur in the lifecycle of the application.
When the application module is declared, we want to define the registerXXX functions that Couch Potato components use.
The easiest and best way is probably to let Couch Potato do it for us. When you declare your module and its dependencies, ask Couch Potato to configure the app.
Two examples follow. The first assumes you've used <script> tags to load Angular and Couch Potato and the second uses the AMD-style. It's important to realize that the choice does not impact the way Couch Potato components are authored.
Using <script> tags:
var myApp = angular.module('myApp', ['scs.couch-potato']); couchPotato.configureApp(myApp);
Using AMD:
define(['angular','couch-potato'], function(angular, couchPotato) { var myApp = angular.module('myApp', ['scs.couch-potato']); couchPotato.configureApp(myApp); });
Pretty easy.
So what just happened? Couch Potato has assigned some functions as variables on the app. Specifically:
It is these functions that the Couch Potato components call to accomplish registration. More on their inner workings below.
The second thing we want to do occurs when the application enters run-time.
myApp.run(['$couchPotato', function($couchPotato) { myApp.lazy = $couchPotato; //note that you need to use the name 'lazy' });
This little assignment gives those register functions that were assigned above the capability of asking Couch Potato to do its work. Remember that the RequireJS AMD modules do not run in an Angular context -- hence we wouldn't be able to use dependency injection to grab the $couchPotato service. Latching onto it in module.run works around this.
So back to those registerXXX functions. In fact, they contain branches. Each one looks something like this (we'll use registerController but they're all doing the same thing). Keep in mind you don't write these, Couch Potato assigns them to the app module for you when you call configureApp.
function registerController(name, controller) { if (app.lazy) { app.lazy.registerController([name, controller]); } else { app.controller(name, controller); } }
Why the branch? It enables calls to registerController (or registerDirective, etc.) to function at at configuration time or at run time. This is really handy. In practical terms, you can author all of your components as Couch Potato components, whether you want to compile them into your eventual app.js using r.js optimization or you want to load/register them lazily.
What follows assumes you're using RequireJS to load your app and is relatively advanced. It is likely to be confusing to those who do not know RequireJS well. (If you're using <script> tags then you're probably compiling certain components directly into your application module anyway.)
You've been warned. If you want to skip this section you can move straight on to Lazy Loading Via Routing.
The distinction between whether r.js will compile Couch Potato components
or whether they will be lazy-loaded/registered is effected by whether or not you require
(as in
use the RequireJS require function on) them within your RequireJS main.js
file (or wherever it is that you have your RequireJS entry point). An example is probably necessary to flesh out this concept.
Let's say your (over)simplified main.js looks like this -- relatively normal RequireJS configuration for an Angular app:
require.config({ paths: { 'angular': '//somecdn/angular.min.js', 'angular-ui-router': '//somecdn/angular-ui-router.min.js', 'couch-potato': '/js/angular-couch-potato.min.js' } }); require(['app', 'run'], function(app) { angular.element(document).ready(function() { angular.bootstrap($('html'), [ app['name'], function() { $('html').addClass('ng-app'); } ] }); });
'app' is your AMD module that defines the Angular app module.
'run' is your AMD module that causes the Angular app to be run.
This main.js just initializes the app and runs it, then attaches the bootstrap function to the document ready event. As said, this is basic RequireJS/Angular stuff. Uses jQuery, but that's not important.
Everything in main.js will be compiled by r.js -- including the components that are required, and the ones they require, etc.
So anything that 'app' depends on, and anything that 'run' depends on -- those will be compiled into your output from r.js (if they are not prevented by being loaded from a CDN or otherwise exluded from the r.js compile process).
Let's look at app.js:
define(['angular', 'couch-potato', 'ui-router'], function(angular, couchPotato) { var app = angular.module('myApp', [ 'ui.state' 'scs.couch-potato' ]); couchPotato.configureApp(app); // return app so you can access it using RequireJs return app; } );
Aside from configuring the app for Couch Potato, this is all still normal RequireJS/Angular. Don't get bored -- we're getting toward the point here...
Let's look at run.js:
define(['app', 'config', 'someService'], function(app) { app.run(['$couchPotato', 'someService', function($couchPotato, someService) { app.lazy = $couchPotato; } ]); } );
So this causes the app to go into run mode, and assigns $couchPotato to app.lazy. For the present exposition, what matters is that 'config' is required.
Here's config.js:
define(['app', 'couch-potato', 'compiled-components'], function(app) { app.config('$couchPotatoProvider', function($couchPotatoProvider) { // nothing really needed here except the rest of your app.config logic }); });
So, because it's necessary, $couchPotatoProvider is injected. But the point here is that 'compiled-components' is required. This is the module in which you specific which of your Couch Potato components will not be lazy loaded, and instead will be compiled into your app by r.js.
One approach here is to bail on lazy loading filters and decorators. You may also have some directives that are used all over the place and not worth tracking as individual dependencies or lazy loading them.
In which case, 'compiled-components.js' could look like:
define( [ 'filters', 'decorators', 'common-directives' ], function() { });
Since all of the modules in this exposition are required down from main.js, r.js is going to build them into the compiled output.
Components that are not required by this tree of dependencies will be lazy loaded as disussed in Lazy Loading Via Routing.


Zorium v1.0.0 (╯°□°)╯︵ ┻━┻
The CoffeeScript Web Framework
Zorium (source) is the web framework we use at Clay.io.
Today it has finally reached version v1.0.0 (╯°□°)╯︵ ┻━┻
This has been one of the most challenging projects I've worked on, with many great lessons learned. What follows is how Zorium came to be what it is today, and an explanation of design decisions in the framework.
With Zorium (or any framework), the code is the easy part. The hard part is the design and architecture of an application. This is where Zorium stands out from the rest. Just start with Zorium Seed.
For the full documentation: https://zorium.org
Special thanks to Matt Esch and Jake Verbaten, without whom Zorium would not exist.
Example
Because every framework should start with code:
z = require 'zorium'
class AppComponent
constructor: ->
@state = z.state
name: 'Zorium'
render: =>
{name} = @state.getValue()
z 'div.zorium',
z 'p.text',
"The Future is #{name}"
z.render document.createElement('div'), new AppComponent()
#

The Future is Zorium

Notice:
- Components are just CoffeeScript classes
- There is no magic pre-processor (i.e. JSX)
- It's simple, intuitive, and idiomatic. No magic.
API Overview
The two most important methods in Zorium are z()
and z.state()
.
z()
is simply an extension of virtual-hyperscript, which understands Zorium components.
The most difficult implementation detail here was constructing an in-memory cached tree for efficient rendering.
Eventually this was solved with Thunks and traversing the virtual-tree (source).
# Component composition example
class Brick
render: ({name}) ->
z '.z-brick'.
"Hello #{name}"
class House
constructor: ->
@$brick = new Brick()
render: =>
z '.z-house',
z @$brick, {name: 'Zorium'}
z.state()
creates an instance of Rx.BehaviorSubject(),
with a set()
method for diffing the current value (and also some lazy-ness to make async more efficient).
Originally a simpler model using observ-struct was used, however it did not provide a declarative syntax for dealing with complex streams of data.
e.g. We want to display the number of likes of the users favorite game.
- If the user changes their favorite game, the value should update.
- If another user likes the game, the value should update.
# Note that we assume the models update themselves and emit streams.
z.state {
numLikes: Models.User.getMe().flatMapLatest ({favoriteGameId}) ->
return Models.Game.getById favoriteGameId
.map (game) ->
return game.numLikes
}
Zorium Paper
Zorium Paper was the first npm-installable set of components for Zorium. Here's what it looks like to use it:
# npm install zorium-paper
Button = require 'zorium-paper/button'
class Clicker
constructor: ->
@$button = new Button()
render: ->
z '.z-clicker',
z @$button,
$content: 'Click Me'
isRaised: true
The key to using an npm module and maintaining efficient css (separable styles for production) is to use webpack. Webpack lets Zorium components declaratively define styles which can be efficiently loaded using webpack without resorting to inefficient inlining or other duplication.
Just having webpack is not enough though. Without shadow-dom we don't have true CSS isolation. In order to let developers use semantic classes without conflicting with each other, a namespace pattern was developed:
if window?
require './index.styl'
class BigDrawer
render: ->
z '.z-big-drawer', # namespace
z '.blue', 'blue'
// index.styl
// namespace
.z-big-drawer
// direct children only
> .blue
background: blue
User-land components should use the z-
prefix, while library authors should namespace under a different prefix.
Server Side Rendering
Efficient server-side rendering is non-trivial. It requires application code to be written statelessly, and thus needs to be considered from the start of a project. In fact, the state issue was so elusive, it wasn't until after Zorium v1.0.0-rc15 that I realized a critical mistake I had made regarding concurrent requests.
After realizing my mistake, I decided to take a page from React, and implement a simpler z.renderToString()
(with async support).
Note that the server simply acts as a pre-renderer. Do not write server-side business logic here.
# server-side
app = express()
app.use (req, res, next) ->
z.renderToString z new App(), {req, res}
.then (html) ->
res.send '<!DOCTYPE html>' + html
.catch (err) ->
if err.html
log.error err
res.send '<!DOCTYPE html>' + err.html
else
next err
The built in router, z.router
, attempts to expose an express-like api. Note the difference in where new App()
is called, as client-side you want a stateful App for transitions.
$app = new App()
z.router.use (req, res) ->
{path, query} = req
res.send z $app, {req, res}
Sometimes it will be necessary to split code between node and client-side. Use window?
to check:
Promise = if window?
window.Promise
else
# Avoid webpack include
_Promise = 'promiz'
require _Promise
Zorium's boldest claim is probably that you can achieve nearly 100% code re-use for client and server-side code. Normally with other frameworks database requests are made and injected at different initialization points within the application.
This doesn't scale well for complex nested structures and requires duplicate effort in marshalling data. Zorium uses lazy-states and a platform-agnostic request library to create a seamless transition from client-side code to server-side code.
This area is probably the most complex because developers usually don't have to worry about state in this way. (e.g. creating singletons client-side is fine, but server-side will cause elusive caching bugs)
Comparison to other virtual-dom libraries
The Zorium framework is a collection of patterns, which are expressed in Zorium Seed. However, as a library is has some key differences from other popular virtual-dom libraries.
- React - The Facebook-backed library that started it all.
- React source-code is a convoluted mess. Extending it is nearly impossible. [1]
- The Flux architecture is unnecessarily complex. [2]
- React still has some clear deficiencies with complex animations. [3]
- The React API makes questionable design choices. [4][5][6]
- React source-code is a convoluted mess. Extending it is nearly impossible. [1]
- Mithril - A micro vritual-dom library which seemed quite promising.
- We initially used this at Clay for a few months (in a fork), but eventually got rid of it entirely.
- Source-code is quite complicated, making extending difficult.
- Manual state-management and rendering updates hurt scalability as our projects grew.
- Lack of structured best-practices lead to a lot of guessing and implementation mistakes.
Both React and Mithril use different virtual-dom implementations. Zorium uses the virtual-dom library, which is the standard behind many other virtual-dom frameworks (e.g. Mercury).
1: Seriously, this is incomprehensible. (vs z.render() for example)
2: Because Zorium supports RxJS Observables in state, async code is declaratively directional (and streaming) and thus avoids the data-binding issues Flux is said to address.
3: Inter-component communication with animations is nearly impossible (without an event-bus and side-effects), whereas Zorium simply uses RxJS observables to handle complex communications in a declarative way.
4: React.createClass()
(and extending React.Component) means non-idiomatic initialization. (vs. explicitly calling new Component()
)
5: JSX magic is not idiomatic code.
6: Mixins are also a mistake, they are opaque and imperative.


|
| | VIPS (int num_dimensions, int num_threads) |
| |
| void | delete_low_weight_components (double min_weight) |
| |
| void | add_samples_to_database (arma::mat new_samples, arma::vec new_target_densities, arma::uvec used_components) |
| |
| void | recompute_densities (bool update_log_densities_on_model_comps=true, bool update_log_densities_on_background_dist=true) |
| |
| void | activate_newest_samples (int N) |
| |
| void | update_targets_for_KL_bounds (bool update_weight_targets, bool update_comp_targets) |
| |
| void | promote_samples_to_components (int N, double max_exploration_bonus, double tau, bool only_check_active_samples, int max_samples) |
| |
| std::tuple< double, vec, vec > | update_weights (double epsilon, double tau, double entropy_bound) |
| |
| arma::vec | adapt_KL_bound_for_comp_update (double max_kl_bound, double factor) |
| |
| arma::vec | update_components (double max_kl_bound, double factor, double tau, double ridge_coefficient, vec entropy_bounds, double max_active_samples, bool dont_learn_correlations) |
| |
| void | add_components (arma::vec new_weights_total, arma::mat new_means, arma::cube new_covs) |
| |
| double | get_entropy_estimate_on_active_samples () |
| |
| double | get_entropy_estimate_on_gmm_samples (int num_samples=10000) |
| |
| std::tuple< arma::mat, arma::vec, arma::mat, arma::mat, arma::vec, arma::mat, arma::mat, arma::mat, arma::mat > | get_debug_info () |
| |
|
int | getNumSamples () |
| |
|
|
int | num_threads |
| |
|
int | num_dimensions |
| |
|
int | num_samples |
| |
|
arma::mat | samples |
| |
|
arma::vec | target_densities |
| |
|
arma::mat | log_densities_on_model_comps |
| |
|
arma::mat | log_joint_densities |
| |
|
arma::vec | log_densities_on_model |
| |
|
arma::mat | log_responsibilities |
| |
|
arma::mat | log_densities_on_background_dist |
| |
|
arma::rowvec | offsets_for_model_joint_densities |
| |
|
arma::rowvec | sum_of_joint_densities_with_offsets |
| |
|
arma::mat | importance_weights |
| |
|
arma::mat | importance_weights_normalized |
| |
| VIPS::VIPS |
( |
int |
num_dimensions, |
|
|
int |
num_threads |
|
) |
| |
Main class implementing the Learn-To-Sample algorithm
- Parameters
-
| num_dimensions | - dimensionality of the sampling problem |
| num_threads | - number of threads to use |
| void VIPS::activate_newest_samples |
( |
int |
N | ) |
|
Selects the N most recent samples and activates them (i.e. uses them for the upcoming learning iteration).
Makes sure, that all relevant data (e.g. densities, importance weights, etc.) gets updated
- Parameters
-
| N | - the maximum number of recent samples to be activated, actually number of activated samples might be less, iff the sample database does not contain sufficient samples. |
| vec VIPS::adapt_KL_bound_for_comp_update |
( |
double |
max_kl_bound, |
|
|
double |
factor |
|
) |
| |
Adapts the KL bound based on the number of effective samples.
The KL bound for each component is set to min(max_kl_bound, factor * num_eff_samples(o))
- Parameters
-
| max_kl_bound | - hard upper bound for KL |
| factor | - factor for computing the KL bound based on the number of effective samples |
| void VIPS::add_components |
( |
arma::vec |
new_weights_total, |
|
|
arma::mat |
new_means, |
|
|
arma::cube |
new_covs |
|
) |
| |
Adds new components.
- Parameters
-
| new_weights_total | - new weights of the GMM (including existing components) |
| new_means | - matrix of size N_dimensions x N_newComponents specifying the means of the new components |
| new_covs | - cube of size N_dimensions x N_dimensions x N_newComponents specifying the covariance matrices of the new components |
| void VIPS::add_samples_to_database |
( |
arma::mat |
new_samples, |
|
|
arma::vec |
new_target_densities, |
|
|
arma::uvec |
used_components |
|
) |
| |
Adds new samples to the database. Note that the samples will not be used for learning, until they have been activated (see activate_newest_samples).
The samples are assumed to have been drawn from the current model and the indices of the relevant components are to be provided for computing background distributions when necessary.
- Parameters
-
| new_samples | - a matrix of size N_dimensions X N_samples |
| new_target_densities | - a vector of size N_samples containing the unnormalized densities on the target distribution |
| used_components | - a vector of size N_samples containing the indices of the components the corresponding samples have been drawn from |
- See also
- activate_newest_samples
| void VIPS::delete_low_weight_components |
( |
double |
min_weight | ) |
|
Removes all components with weight below the given threshold, and renormalized the weights afterwards
- Parameters
-
| min_weight | - threshold for keeping components |
| std::tuple< mat, vec, mat, mat, vec, mat, mat, mat, mat > VIPS::get_debug_info |
( |
| ) |
|
Get various densities, importance weights, etc. for debug purposes.
- Returns
- a tuple, st.
tuple[0] contains the samples
tuple[1] contains the unnormalized target densities
tuple[2] contains the log densities on each model p(s|o)
tuple[3] contains the joint log densities p(s,o)
tuple[4] contains the GMM densities p(s)
tuple[5] contains the log responsibilities p(o|s)
tuple[6] contains the densitis on the background distribution q(s)
tuple[7] contains the importance weights
tuple[8] contains the normalized importance weights
| double VIPS::get_entropy_estimate_on_active_samples |
( |
| ) |
|
Returns a (weighted importance sampling) Monte-Carlo estimate of the entropy of the learned model. The entropy is computed based on the active samples. As this entropy is computed based on precomputed values [importance weights and log(p(x))] th evaluation is very fast. However, if the number of active samples is still low or the samples are not "fresh" (low importance weights), the estimate can be quite bad. see get_entropy_estimate_on_gmm_samples() for a slower, but usually more accurate estimate.
- Returns
- a Monte-Carlo estimate of the entropy of the learned Gaussian Mixture Model
- See also
- get_entropy_estimate_on_gmm_samples()
| double VIPS::get_entropy_estimate_on_gmm_samples |
( |
int |
N = 10000 | ) |
|
Returns a Monte-Carlo estimate of the entropy of the learned model. This methods draws new samples from the learned model and evaluated their log-densities log(p(x)). The entropy of the learned model is then approximated as H(p) -1/N log(p(x)). see get_entropy_estimate_on_active_samples() for a faster, but usually less accurate estimate.
- Parameters
-
| N | - the number of samples that should be drawn for computing the estimate |
- Returns
- a Monte-Carlo estimate of the entropy of the learned Gaussian Mixture Model
- See also
- get_entropy_estimate_on_active_samples()
| void VIPS::promote_samples_to_components |
( |
int |
N, |
|
|
double |
max_exploration_bonus, |
|
|
double |
tau, |
|
|
bool |
only_check_active_samples, |
|
|
int |
max_samples |
|
) |
| |
Selects promising locations among the current samples and create new components at these positions. The covariance matrices are given by the weighted sums of the covariance matrices current model, where the weights are given by the responsibilities of the model components for the new location. Locations are promising if the residual given by residual = log(p_intractable(x)) - log(p_model(x) + exp(max_exploration_bonus)) is high.
- Parameters
-
| N | - the number of samples to be promoted |
| max_exploration_bonus | - maximum bonus for samples that have low density on the current model |
| only_check_active_samples | - if set to true, the residual is computed on the active samples only, otherwise, the resiudal is computed for all samples in the sample database. |
| max_samples | - maximum number of samples to be considered |
| void VIPS::recompute_densities |
( |
bool |
update_log_densities_on_model_comps = true , |
|
|
bool |
update_log_densities_on_background_dist = true |
|
) |
| |
Recomputes the densities of various distributions as well as the importance weights.
Manual invocation is in general not necessary, as the densities are automatic updated, e.g. after weight changes, component changes, adding components, etc.
- Parameters
-
| update_log_densities_on_model_comps | - if this flag is set to false, assume that the density-evaluations for each GMM component is up-to-date, e.g. because only the GMM weights have changed |
| update_log_densities_on_model_background_dist | - if this flag is set to false, assume that the density evaluations for the background distribution are up-to-date, e.g. because it was not changed at all |
| vec VIPS::update_components |
( |
double |
max_kl_bound, |
|
|
double |
factor, |
|
|
double |
tau, |
|
|
double |
ridge_coefficient, |
|
|
vec |
entropy_bounds, |
|
|
double |
max_active_samples, |
|
|
bool |
dont_learn_correlations |
|
) |
| |
Updates the components p(s|o).
- Parameters
-
| max_kl_bound | - hard upper bound for each KL bound |
| factor | - factor for computing the KL bound for each component based on its number of effective samples |
| tau | - entropy coefficient |
| ridge_coefficient | - coefficient used for regularization when fitting the quadratic surrogate |
| entropy_bounds | - lower bound on entropy |
| max_active_samples | - size of the subset of samples that should be used for each component update |
| dont_learn_correlations | - iff true, fit a quadratic surrogate where R is diagonal (experimental) |
| void VIPS::update_targets_for_KL_bounds |
( |
bool |
update_weight_targets, |
|
|
bool |
update_comp_targets |
|
) |
| |
Sets the current components p(s|o) and the current weight distribution p(o) as the target for the respective KL bounds.
- Parameters
-
| update_weight_targets | - only update the weight targets if this is set to true |
| update_comp_targets | - only update the component targets if this ist set to true |
| std::tuple< double, vec, vec > VIPS::update_weights |
( |
double |
epsilon, |
|
|
double |
tau, |
|
|
double |
entropy_bound |
|
) |
| |
update the component weights p(o).
- Parameters
-
| epsilon | is the KL bound |
| tau | is the entropy coefficient |
- Returns
- a tuple, s.t. tuple[0] contains the KL D(p_new(o)||p_old(o)) tuple[1] contains the rewards for each component that was used during the optimization tuple[2] contains a sample-estimate of the expected, unnormalized log-densities of the desired distribution
The documentation for this class was generated from the following files:


[gecode-users] Schedule serialized
Christian Schulte
cschulte at kth.se
Tue Sep 22 15:53:07 CEST 2009
Hi,
You can use cumulatives. In the near future, Gecode will come with
constraints for disjunctive and cumulative scheduling (actually, for
disjunctive scheduling the next release will already contain propagators but
not yet good branchings, even though in experimental quality only).
Christian
--
Christian Schulte, www.ict.kth.se/~cschulte/
From: users-bounces at gecode.org [mailto:users-bounces at gecode.org] On Behalf
Of Maity, Ashis K
Sent: Tuesday, September 22, 2009 3:22 PM
To: 'gecode-users at gecode.org'
Subject: [gecode-users] Schedule serialized
Hello,
Is there anything in Gecode library that is equivalent to
Schedule.serialized of Mozart/Oz (i.e., choose resources across the tasks so
that same resources are not chosen at the same time in two different tasks)?
If not, can some one provide with a couple of pointers as to how to
implement it?
Thanks,
Ashis
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.ps.uni-sb.de/pipermail/users/attachments/20090922/3bdc4845/attachment.htm>
More information about the gecode-users
mailing list


Hotel
Hunt
Home
Admin
Home
Register
Explore
My Account
Admin
Add your review
Insert Details of Resort/Villas
HOTEL NAME:
LOCATION:
ADDRESS:
PRICE PER DAY:
DISCOUNT:
CONTACT NUMBER:
EMAIL ID:
UPLOAD IMAGE:
SELECT MULTIPLE IMAGE:
ENTER DETAILS:
submit
Back


You decide to fall back to gather a larger army, though in doing so you allow the Mongols to gain a beachhead over the city of Fukuoka.
Your loyal Japanese citizens, having been evacuated from the present danger, help establish a camp in which you wait for more reinforcements. One runner comes with word from Kyoto, promising 50,000 men will soon arrive. But back in Kyoto the shogun is building up an army of 300,000 that should be ready within two years.  He claims that the Mongols have at least 100,000 men and you know that the Mongols are great at fighting even with lesser numbers. You only have around 40,000 to 60,000 troops, and you fear that the Japanese stand no chance against the greater numbers. As you worry over your slim chances of surviving grows, the samurai feel your nervousness, becoming more and more agitated.
The next week your reinforcements of 50,000 men march into your camp ready to fight. Every soldier’s morale is boosted with the knowledge that they outnumbered the invaders. You give great motivational speeches and hope that you might be able to win.
One of your trusted advisors recommends that you attack the Mongols in Fukuoka. You realize that a surprise attack might be able to overcome the invasion before they get any farther into Japan. However, if the Mongols have properly built up defences around the city, there would be no hope of your army breaking through. You and all of Japan would fall and the Mongols would take over unopposed. But if you wait too long to attack, more soldiers might come over from China and once more outnumber you.
What do you do? Do you move and attack the Mongols now? Or do you wait for the Mongols to come to you?


Line a large baking sheet with a silicon mat or parchment paper. Set aside.
In a medium bowl, mix together the flour, baking soda, powder, and salt. Set aside.
In a standing mixer fitted with a paddle attachment, beat the butter until it comes together in one lump, about 1 minute. Add in the sugars and beat for another 1-2 minutes, or until the sugar dissolves into the butter.
Lower the speed to medium-low, and mix in the eggs and vanilla and beat until mixed (the batter will be lumpy). Gradually add in the flour mixture, beating until a little flour remains. Add the chocolate chips and mix until they're uniformly distributed.
Divide the dough into 12 even pieces. Shape the dough roughly into a ball, but do not roll it. Place on the prepared baking sheet, spacing 2 inches apart. Freeze for 15 minutes or refrigerate them overnight.
Preheat oven to 375°F. Bake cookies for 15-20 minutes, until light golden brown. When in doubt, take your cookies out early. The cookies will continue to cook as they cool. There's nothing that ruins them more than being overcooked.


There is a problem
Project duration in months
Minimum
Maximum
Include the resubmission question?
Yes
No
Done
Project duration in months
Minimum
Maximum
Include the resubmission question?
Edit this question
Return to application questions


Recitation 6: Deployment¶
Overview¶
Throughout this recitation, students will:
-
Understand the fundamental steps involved in deployment
-
Learn about CI/CD and the basics of how to set it up in a Github repo
-
Get hands on experience deploying with Fly.io (or Vercel as a backup)
-
Set up the Extreme Startup web app for use in Tuesday's (3/14) lecture
Definitions¶
Before we begin, we have to understand our goals with CI/CD. It is a software development approach that utilizes frequent, automated testing and deployment to ensure that changes to the codebase can be rapidly and safely incorporated into the production environment.
Continuous Integration (CI) refers to the practice of automatically building and testing the codebase whenever new changes are introduced. This involves integrating code changes from multiple developers into a shared repository and running automated tests to ensure that the changes do not break the existing functionality.
Continuous Deployment/Delivery (CD) refers to the practice of automatically deploying code changes to the production environment after they have been tested and approved. Continuous Deployment involves automatically deploying changes to the production environment as soon as they pass automated tests, while Continuous Delivery involves deploying changes to a staging environment for further testing and approval before being deployed to production.
Together, CI/CD enables software teams to rapidly and safely develop, test, and deploy changes to the codebase, improving the speed and quality of software delivery while reducing the risk of errors and downtime.
There's quite a lot to learn about CI/CD. If you're interested in learning more, click here!
Task 0: Prep¶
For this recitation, we'll be working with a basic web app built on Next.js that responds to HTTP requests. Your job on Tuesday during the ~Extreme Startup~ game will be to parse these requests and figure out what the correct response is. Today we'll focus on setting up the app so that everything is in place for the game.
The steps to do this are as follows:
Warning
Do not use codespaces for this task, and the rest of the recitation. Everything must be done locally.
-
Fork this repo: https://github.com/CMU-313/basic-web-app.
-
Follow the instructions in the readme to run the development server locally.
-
Install the Fly.io CLI and set up the Fly.io account that you'll use to host your app. Complete steps 1-3 of the instructions here.
-
In your local basic-web-app repo, run
fly launch
followed byfly open
Now check your fly.io dashboard to monitor your app deployment.
This has already been a lot of instructions, so good job for getting this far!!!
Note: Fly.io offers a free tier and you should not be required to enter any credit card info for the purposes of this recitation. If you get a message saying that a credit card is required, you can complete the recitation using Vercel instead. See the backup instructions below.
Task 1: Continuous Deployment¶
Next, we'll setup CD. Our goal is to set up a GitHub action that links to our Fly.io account and automatically redeploys a new version of our app whenever a new change is pushed into the main branch.
The steps to do this are as follows:
-
Get a Fly API token with
flyctl auth token
.
-
Go to Secrets and Variables > Actions and create a repository secret called
FLY_API_TOKEN
with the value of the token from the previous step. This is how GitHub will link to your Fly.io account. -
Double check that
fly.toml
(the config file fly.io uses for deployment) is not listed in your.gitignore
. -
Create a new file
.github/workflows/fly.yml
.This is the file that will outline instructions for the GitHub action. -
Fill the file with the contents listed under step 8 here.
-
Commit and push your changes!
Now let's take a step back and understand what we've done. First, we generated an authorization token and used it to connect Fly.io to our GitHub repo. Then, we created a fly.yml
file setting up a GitHub action that automatically runs the deployment commands whenever a push is made to the main branch. See if you can figure out which lines do what in the code above!
Now, look through the codebase and try to change the header on your app's frontend while testing with the local development server.  Back on GitHub, you should see the Action trigger and your app will redeploy!
With this complete, you'll be able to quickly iterate and any changes you make and push to your fork will be automatically deployed. Cool!
Bonus Task: Continuous Integration¶
While the steps above are all that is required for the ~Extreme Startup~ game, we'll spend the rest of the recitation setting up CI for our repo as well. For our purposes, we'll set up an action that runs ESLint and our Jest tests whenever we push to the repo.
The process will be similar to above.
-
Create a new
.github/workflows/test.yml
-
Copy the following into the files and fill in the blanks appropriately!
name: __BLANK 1__
on:
push:
branches:
- main
jobs:
__BLANK 2__:
runs-on: ubuntu-latest
name: __BLANK 3__
steps:
- uses: actions/checkout@v3
- uses: bahmutov/npm-install@v1
- run: npm run __BLANK 4__ (Run ESLint)
- run: __BLANK 5__ (Run Jest)
Hint: Look at the readme of the basic-web-app repo!
Note: In an ideal world, you would condition the deployment action on this action, such that your app is only deployed if the linter and tests pass. Sadly, our world is not ideal :(, but if you want to learn more, click here and here!
Once this is complete, you will be ready for the game tomorrow. Good job and good luck!
Remember to do Recitation 6 Quiz on Gradescope!
Vercel Backup Instructions¶
Task 0¶
See the instructions here to setup a Vercel deployment.
Task 1¶
To learn how to setup a deployment GitHub action for Vercel, see here.
Task 2¶
Same as above!


gox- Download and compile a Go program from a remote URL:
gox url_1 url_2- Compile current directory for a particular operating system:
gox -os="os"- Compile current directory for a single operating system and architecture combination:
gox -osarch="os/arch"


SHOWGIRLS A film review by James Berardinelli Copyright 1995 James Berardinelli
RATING (0 TO 10): 1.5
United States, 1995 U.S. Availability: 9/22/95 (wide) Running Length: 2:11 MPAA Classification: NC-17 (Nudity, sex, profanity, violence) Theatrical Aspect Ratio: 2.35:1
Cast: Elizabeth Berkley, Kyle MacLachlan, Glenn Plummer, Gina Gershon, Robert Davi, Gina Raveri Director: Paul Verhoeven Producers: Alan Marshall and Charles Evans Screenplay: Joe Eszterhas Cinematography: Jost Vacano Music: David A. Stewart U.S. Distributor: United Artists
In 1990, the MPAA introduced the NC-17 rating to provide an outlet for legitimate adult fare--non-pornographic motion pictures with content deemed too strong for the under-17 crowd. The first movie released with an NC-17 was HENRY AND JUNE, whose financial failure was widely blamed on the new rating. After that, all potentially-lucrative films receiving an NC-17 made the cuts required by the MPAA to earn an R. Now, in 1995, there's SHOWGIRLS, the most significant test of the NC-17's commercial viability to date. Helmed by Paul Verhoeven (TOTAL RECALL, BASIC INSTINCT) and written by Joe Eszterhas (JAGGED EDGE, BASIC INSTINCT), this movie is going into wide release with the adult rating. Too bad it's one of the worst films of the year.
Curiosity will undoubtedly pull in a fair number of movie-goers, especially on the first weekend. Other than that, though, there's nothing about SHOWGIRLS to lure viewers. This film is like a shiny, red apple that's rotten to the core--despite slick direction and a glossy sheen, it reeks of decay. SHOWGIRLS isn't a good drama, a good thriller, or even good pornography. It's hard to imagine that the picture will appeal to anyone, and unclear whether there's any future for the NC-17 rating if SHOWGIRLS rightfully bombs at the box office.
SAVED BY THE BELL actress Elizabeth Berkley has the lead role, and her lack of feature experience shows. She was obviously chosen more for what she would show than for acting ability. And, by the end of the two-hour plus running time, there's very little Berkley hasn't given the audience at least a peek at. Verhoeven has never been a subtle director, and his fixation with naked body parts makes one wonder if he might not have potential as a hard-core director.
SHOWGIRLS is a cold, soulless, misogynistic motion picture. There isn't anything to like about the thinly-drawn, stereotyped characters, and the situations they drift through are far from engrossing.  Artistic integrity, intelligent scripting, heart-felt acting, and sincere film making are all absent. Everything--from the overall plot to individual lines of dialogue--is predictable and poorly-written.
Nomi Malone (Berkley) is a dancer on her way to Vegas with hopes of joining a chorus line.   She starts working as a lap dancer at a strip club, but has her sights set higher. And when the big-name star of a local show (Gina Gershon) and a hotel talent director (Kyle MacLachlan) take an interest in her raw--ahem--abilities, her prospects suddenly appear brighter.
As bad as the first ninety minutes of this film are, the last thirty are worse. The closing quarter of SHOWGIRLS is distasteful in every way--from its gratuitous violence to its illogical plotting. The final scenes are intended to teach something about ethics, but that's a hypocritical stance for a motion picture without a moral compass.
This year's other picture about lap dancing, Atom Egoyan's EXOTICA, was everything SHOWGIRLS is not: sensitive, intelligent, erotic, and well-acted. It's almost a disservice to the fine Canadian film to mention it in the same review as the Verhoeven/Eszterhas monstrosity, but certain superficial similarities are too obvious to ignore. But, where EXOTICA was full of mystery and emotion, SHOWGIRLS is a hollow shell--false, mechanical, and entirely despicable in intent and execution.
- James Berardinelli<EMAIL_ADDRESS>The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Chilean doctors hit the streets amid violent protests
SANTIAGO: Pushing rickety grocery carts as improvised hospital beds, more than 100 Chilean doctors and nurses hit the streets shortly after riots broke out in Chile weeks ago, diving into the fray amid clouds of tear gas and volleys of rubber bullets behind just simple white shields.
Protests that began over a hike in metro fares quickly unravelled into violent riots, looting and arson, and eventually, mass protests demanding an end to social injustices and inequality. Clashes with police and military security forces have escalated.
"Healthcare for the streets," emerged almost spontaneously, its members say, as the need for urgent, on-the-spot medical assistance became clear.
The official statistics tell a grim story: More than 20 dead and nearly 2,000 protesters injured in skirmishes with security forces.
"We alone have assisted at least 500 injured people, and that's with limited capacity," Dr. Juan Villagra told Reuters.
The group has focused its activities around Plaza Italia, a central Santiago square where the country's largest protests have taken place. Along dead end streets and sidewalks, they pile medical supplies, cart the injured to safety and help in any way they can.
Prosecutors are also investigating more than 800 allegations of abuse, including torture, rape and beatings by security forces during demonstrations that have often degenerated into riots.
"We've seen how the response has gotten out of control, and it's led to hundreds of injuries," said Patricia Mieres, the group's director.
Michelle Bachelet, the UN human rights chief and former Chilean president, has sent a fact-finding mission to Chile to interview alleged victims, as has Amnesty International.
Chilean President Sebastian Pinera welcomed their investigations. "We have nothing to hide," he said.


CHANGELOG¶
0.6.2 - June 30th 2021¶
Data updates: ClinVar, PanelApp, GWAS catalog, CIViC, CancerMine, dbNSFP, KEGG, Disease Ontology/EFO, Open Targets Platform, UniProt KB, GENCODE
Software upgrades: R v4.1, Bioconductor v3.13, VEP (104) ++
Improved GWAS track for cancer phenotypes
Changed¶
TOML-based configuration for CPSR is abandoned, all options to CPSR are now configured through the command-line parameters
Added¶
Command-line options
Previously set in TOML file
--pop_gnomad
--report_theme
--preserved_info_tags
(previouslycustom_tags
(TOML))--custom_list_name
--gwas_p_value
--vcfanno_n_proc
(previouslyn_vcfanno_proc (TOML)
)--vep_n_forks
(previouslyn_vep_forks (TOML)
)--vep_pick_order
--vep_no_intergenic
(previouslyvep_skip_intergenic (TOML)
)
New options
--report_nonfloating_toc
(NEW) - add the TOC at the top of the HTML report, not floating at the left of the document--report_table_display
(NEW) - choose level of comprehensiveness in interactive data tables (full versus light (default))
Improved support for noncoding variant interpretation, primarily in the context of variants of uncertain significance (VUS). Annotations will show variants that disrupt/create microRNA target sites (dbMTS), and variants that overlap transcription factor binding sites (critical and non-critical positions). Genomic conservation scores (GERP) are also provided.
Approx. 100 protein-coding genes have been appended to the CPSR superpanel (panel 0)
Removed¶
Command-line Options
--conf
- configuration file
0.6.1 - November 30th 2020¶
Added¶
Increased number of genes in panel 0: All genes in 42 virtual panels related to cancer conditions in Genomics England PanelApp now also contributes toward panel 0
Added option in main script (
--clinvar_ignore_noncancer
) that will exclude any query variants (from HTML report and TSV/JSON output) that have been reported and classified for non-cancer related conditions only (in ClinVar)this to exclude variants associated with non-cancer related phenotypes
For the variant biomarker table, the resolution of the reported biomarker mapping is highlighted with designated background colors for the gene (exact/codon - black vs. exon/gene - orange)
Fixed¶
Bug in GWAS hits retrieval, Issue #30
Custom VCF tags (as specified by user in configuration file) not shown in output TSV files
Changed¶
Removed DisGeNET annotations from output (associations from Open Targets Platform serve same purpose)
Renamed report section Genomic Biomarkers to Variant Biomarkers
Option
--incidental_findings
changed back to--secondary_findings
- recommended term to use according to ACMGRemoved MOD (mechanism-of-disease) from TSV output file
0.6.0rc - September 24th 2020¶
Data updates: ClinVar, GWAS catalog, GENCODE, CIViC, CancerMine, UniProt KB, dbNSFP, Pfam, KEGG, Open Targets Platform, Genomics England PanelApp
Software updates: VEP 101
Fixed¶
Duplicated entries in incidental findings
Changed¶
All arguments to
cpsr.py
are now non-positionalArguments to
cpsr.py
are divided into two groups: required and optionalsecondary_findings
is now coinedincidental_findings
Option gwas:gwas_hits in CPSR configuration file is now optional argument
--gwas_findings
incpsr.py
Option classification:clinvar_cpsr in CPSR configuration file is now optional argument
--classify_all
incpsr.py
Option maf_imits:maf_gnomad in CPSR configuration file is now optional argument
--maf_upper_threshold
incpsr.py
Option secondary_findings:show_sf in CPSR configuration file is now optional argument
--incidental_findings
incpsr.py
Virtual panels is now displayed through HTML (previously static ggplot plot)
Settings section of report is now divived into three:
Sample metadata
Report configuration
Virtual panel
Classifications of genes as tumor suppressors/oncogenes are now based on a combination of CancerMine citation count and presence in Network of Cancer Genes
Added¶
Missing ACMG criterion for classification of silent and intronic variants outside of splice regions (ACMG_BP7)
Missing ACMG criterion for classification of variants in promoter and untranslated regions (ACMG_BP3)
Possibility to create custom virtual panel - any combination of genes from panel 0 provided as a single-column text file with argument
--custom_list
Ensured that non-empty datatables pr. tier (ClinVar and Non-ClinVar) are set as the active tab
Improved documentation of variant classification in the References section
DOIs available for all references
0.5.2 - November 18th 2019¶
Changed¶
Definition of pathogenic range (wrt to variant frequency) takes into account population- and position-specific allele numbers - no longer defined only by allele counts (i.e. AC) but by AC and AN
Moved virtual panel identifier from positional argument to optional argument (
--panel_id
) incpsr.py
Added¶
Ability to analyze custom panels, provided through option
--custom_panel
. Needs to be defined as BED file with four columns, i.e. chromosome, start, stop, genesymbol
0.5.1 - October 14th 2019¶
Fixed¶
Bug in
cpsr_validate_input.py
, GitHub IssueBug when there are zero variants with a ‘PASS’ status in VCF - omitting report generation
0.5.0 - September 23rd 2019¶
Fixed¶
Bug in implementation of ACMG criteria; genes without a known loss-of-function mechanism were handled inappropriately
Bug in assignment of heterozygous/homozygous states (input VCF)
Bug in implementation of ACMG_PS1 - Same amino acid change as previously pathogenic variant
Improved consequence prioritisation for variants with transcript consequences in multiple, distinct cancer predisposition genes
Upper MAF threshold (as given by user) only applied for unclassified (i.e. non-ClinVar variants)
Handling of non-coding variants (synonymous, upstream_variants) in the report, no longer excluded
Added¶
Section on genomic biomarkers; indicating which variants in the query VCF that overlaps with existing germline biomarkers (CIViC)


Oconee County Fire Rescue
Home
Members
Member List
Create Member
Certifications
Certification List
Create Certifications
Add Certification to Member
Reports
Standard report
Expired Certifications
Add a New Member
First Name:
Last Name:
Email:
Date of Birth:
Gender:
Male
Female
Other
Prefer not to disclose
Address:
Station Number:
Choose...
1
2
3
Radio Number:
Choose...
1
2
3
Member is:
Active
Inactive
Start Date:
Position:
Create Member


--- layout: homepage title: Programming Systems Laboratory subtitle: The window through which you see the SW World image: /img/home.jpg hero_image: /img/home.jpg hero_height: is-large ---
Our research aims to develop next-generation programming systems for secure and reliable software. We are building real-world software systems including AI-based program analysis systems for detecting deep semantic software bugs, general-purpose program simplification systems for secure and efficient software, scalable program synthesis systems for automatic software generation and repair. For more detailed information, please see research and publications.
Programming Systems Laboratory, KAIST
Bldg N4, Rm 1424
291 Daehak-ro Yuseong-gu
Daejeon 34141, Korea


This is a mock version of the Verify API you can use for testing.
No data will be submitted anywhere, and no emails will be sent.
See the Verify API docs for details on how to use the API.
This mock API works just like the real API, but at a different root URL.
Loading...


Statistics WebQuest
Introduction
The purpose of this activity is to increase your understanding of statistical modeling and data plotting. You will be researching the composition dates of the complete works of the 19th Century romantic composer, Frédéric Chopin. In addition to researching, organizing, and plotting data, you will have the opportunity to reflect on some theoretical questions involving statistics as well.
The Task
Get together in groups of two. You will need to find a list of Chopin's works. Note that the Opus numbers do not directly correspond to composition dates. Your task is to organize his works in chronological order and make statistical inferences based on patterns you see.
Activities:
- Find a list of Chopin's complete works and composition dates. Just the year is sufficient. Be sure to order them chronologically.
- Make a stem-and-leaf plot of his works, based on year.
- Find the five-number-summary: the lower extreme, lower quartile, median, upper quartile, and upper extreme of the data set.
- Using the five-number-summary, draw a box-and-whisker plot of the data.
- Find the mean, variance, and standard deviation of the data set.
- Find the range and mode of the data set.
- Draw a histogram using your data from the stem-and-leaf plot. Decide on what type of skew the data has.
Questions:
- In the area of Statistics, why might we find it useful to organize Chopin's works chronologically?
- Is this data set a discrete or continuous data set? Explain the difference between the two types.
- Discuss the advantages of using the median value over the mean value.
- Using the histogram, how can the median and mode be interpreted graphically?
- Knowing how to calculate variance and standard deviation is great, but how are they useful? Discuss the importance and meaning of the variance and standard deviation of a data set.
- What do the stem-and-leaf plot and the histogram have in common? What do they show that the box-and-whisker plot cannot?
- Explain how one outlier can dramatically affect the range of a data set. How is the range useful in real life?
The Process
- In groups of two, one partner should take on the statistical activities while the other partner researches the questions. Each partner should be interacting and discussing their processes with the other partner.
- Near the end of the class period, both partners should be familiar with how to complete the activities as well as the findings to the questions.
- Each group will turn in their notes discussing what processes they used to complete the activities. Show your work.
Resources
- Chopin's complete works by Opus number (composition years included)
- stem-and-leaf plots
- five-number summary
- box-and-whisker plots
- mean, variance, and standard deviation
- mean, median, mode, and range
- construct a histogram
- histogram skew
- importance of statistics
- types of data
- statistical values and their importance in real life
- stem-and-leaf plots & histograms
- outliers
Learning Advice
Each group is to jot down notes and findings as they are working. These notes will be turned in, so make sure they are copious. However, quality is more important than quantity. It is more important to obtain the big ideas and concepts involved, and not to focus on the small details. With the number of resources at your disposal, you do not have enough time to read them thoroughly. Observe the titles, subtitles, pictures and captions, and diagrams. It is sufficient to skim long texts for main ideas. Feel free to venture outside the given sources. Do cite any new sources you come across, if you are using important information from them.
Conclusion
This WebQuest should have helped you gain better insight on the usefulness and practicality of statistics and data organizing, as well as practice with data plotting and making statistical inferences. In addition to the statistical aspect, this activity should have enhanced your research skills and your ability to extract, organize, and summarize information from a multitude of resources.