The content pages should not contain anything usually needed for the html envelope of a webpages - do not use "<html>", "<head>" "<body>". For a fact, you can even omit the "<title>" tag as it is purely optional for mksite.sh - the shell script will scan the content page looking for the html header markups "<h1>", "<h2>",... "<h6>" and use the first one for the page title.
Example:
<H4> Lorem Ipsum </H4>
<P>
Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet.
</P>
That's all - just a header line and some text.
Mark them as "H4"eader and "P"aragraphs.
The rest is done in the sitefile.
The text above is used quite usually in typography to denote a blind text, i.e. text that is not readily available. A typograph may create a style for a book and in order to show it around some helper text must be inserted as a placeholder for the real text to be added later. To use "lorem ipsum" is a very old habit going back right to the 1500s as the first days of "industrial" book printing. The text itself is latin, an excerpt of "De Finibus et Malorum" by the great Cicero - it speaks about ethics and the first line translates roughly to "There is no one who loves pain itself, who seeks after it and wants to have it, simply because it is pain.". Actually, you may use any other blind text at hand but take notice that modern Desktop Publishing systems will detect the words "Lorem Ipsum" and before sending it to the printer (creating ten thousand copies) it will warn harshly "hey there is some blind text left". And there: use Lorem Ipsum.


Over winter break, I took a study tour class called Digital Publishing. For the class, we traveled 11 days to New Zealand to create videos to showcase our technical and creative skills. Below are just some of my favorite still photographs I took while I was there.


@@include('./partials/single-content.html')
@@include('./partials/topbar.html') @@include('./partials/left-sidebar.html') @@include('./partials/middle-content.html')


The well-known and oft-used Linux networking tool, iptables, is something that eventually in the career of a Linux sysadmin or developer, will require manual configuration. From the man page:
iptables/ip6tables - administration tool for IPv4/IPv6 packet filtering and NAT
In more recent years an IPv6 variant of this tool has been implemented, uncreatively denoted ip6tables for the sake of simplicity.
Admittedly, filtering IPv6 addresses is perhaps worthy of an article itself due to the current prevalence in the industry for IPv4 addresses and the commonality of IPv6 addresses in use among hackers and other smaller online communities.
Instead, the focus will be on using the original IPv4 variant. Start by printing a verbose list of the current filtering rules in place on a given host. Type the following into a terminal:
iptables -vL
Upon doing so, the various uniquely defined filtering groups, called chains, will be printed out with their name (e.g. INPUT, OUTPUT) and their policy (e.g. ACCEPT, DROP) and their subrules (i.e. for individual IPs or CIDR ranges). Specifically, output similar to the below will be displayed:
Chain INPUT (policy ACCEPT x packets, y bytes)
pkts bytes target prot opt in out source destination
0 0 ACCEPT all -- any any anywhere anywhere
Chain FORWARD (policy DROP 0 packets, 0 bytes)
pkts bytes target prot opt in out source destination
Chain OUTPUT (policy ACCEPT x packets, y bytes)
pkts bytes target prot opt in out source destination
0 0 ACCEPT all -- any any anywhere anywhere
Where x and y are the number of packets and total size in kilobytes or megabytes, respectively. Immediately below the chain definition are the columns labels, which are:
To add a rule, decide which chain to append to, the protocol, the port and the intended action. For example, to allow any SSH traffic into the given system, type the following:
iptables -A INPUT -p tcp --dport ssh -j ACCEPT
Afterwards, the iptables INPUT chain looks like the following:
Chain INPUT (policy ACCEPT x packets, y bytes)
pkts bytes target prot opt in out source destination
0 0 ACCEPT tcp -- any any anywhere anywhere tcp dpt:ssh
To delete a rule, use the -D flag and type the number of the rule, like so:
iptables -D INPUT 1
Packets that are incoming from a certain port can be blocked as well to prevent traffic from being accessed. This can be done by setting the DROP action:
iptables -A INPUT -p udp --dport 35353 -j DROP
Rules can also be edited by specifying the -I flag with the chain and number. Then the other flags may be specified alongside to set the different attributes of the rule.
iptables -I OUTPUT 4 -p tcp -i enp4s0 -j DROP
Another action that can be assigned to rules is logging. Say you wanted to tweak a rule to allow for a hard limit of 10 responses from a given IP address per second, and then have it log all of the information to file. This can be done as follows:
iptables -I INPUT 1 -m limit --limit 10/sec -j LOG --log-prefix "iptables denied: " --log-level 7
If there are multiple groups of IP addresses that are being rate limited for different reasons, consider setting the log-prefix to something meaningful than simply the "denied" text used above.
Now, all of the iptables rules that were implemented will by default disappear at the next reboot or shutdown of the host. To store these rules more permanently, use the save commandline utility as follows to dump it to file:
iptables-save > /etc/iptables/iptables.rules
The rules will now be loaded on startup. To immediately have them loaded, merely restart iptables via systemctl.
systemctl restart iptables
Please note that it is possible to accidently break a connected session and be locked out of a system, say if the session is connected via ssh and port 22 is now blocked. Consider testing the rules file on a non-critical local machine first to prevent unforeseen consequences.
If you change the rules later on and want to reset them to the default, the rules may then be reloaded using the restore program like so:
iptables-restore < /etc/iptables/iptables.rules
There are quite a few other features in iptables, however, this covers all of the basics. Perhaps at some later date a post that details further scenarios will be written.


Sources
pub-server
uses content stored in sources to generate your site.
Most sources are directories in your project or inside a theme package. Source directories are scanned, and new files picked up automatically when the source is read.
File-system sources can be watched and automatically re-read when changes are detected.
Source modules
In addition to the default file-system sources, pub-server supports pluggable npm modules which can read and write files from github, dropbox etc.
These are configured configuring source.src
with the source module name E.g. 'pub-src-github'.
The source API is able to glob directories recursively, and return an ordered set of files, optionally matching a glob pattern.
For more information see pub-src-fs and pub-src-github
pub-src-redis can also serve as a cache for other sources.
Source modules are resolved and loaded by pub-resolve-opts at startup time.
Markdown fragments
pub-server content is maintained in markdown fragments inside files which originate in sources.
Fragments in the same file are separated by a delimiter like
---- /page-1 ----
For an overview of why we use fragments see the blog post pub-server Fragments.
Handlebars templates
Handlebars templates are also just files (or fragments) in sources. For templates, pub-server looks an .hbs
extension.
Templates are the key to separating HTML from content stored in markdown, making the content maintainable by non-developers.
pub-server compiles and invokes specific templates when it generates each page in a site. The templates use built-in Helpers to call javascript functions for things like page-variable interpolation and markdown rendering. Custom helpers can be defined using Generator Plugins.
Sample config
The sample below is used in a complex environment to run locally and on a Heroku server for staging. The hosted server uses a redis cache and pulls sources from GitHub.
var ifLocal = opts.localhost;
var ghTest = process.env.TEST_GH;
opts.sources = [
{ name: 'markdown',
src: (ifLocal && !ghTest) ? 'pub-src-fs' : 'pub-src-github',
path: (ifLocal && !ghTest) ? '../<repo>/md' : '/md',
repo: '...', // for pub-src-github
glob: '**/*.md',
depth: 4,
cache: (ifLocal ? null : 'pub-src-redis'),
leftDelim: '----',
rightDelim: '',
headerDelim: '----',
slugify: {allow:'_'},
writable: true,
fragmentDelim: true },
{ name: 'templates',
path: './templates',
compile: 'handlebars',
cache: ifLocal ? null : 'pub-src-redis' },
{ name: 'schedule',
path: '...',
src: 'pub-src-http',
cache: (ifLocal ? null : 'pub-src-redis'),
interval: '20m',
timeout: '10s',
type: 'JSON',
log: true }
];
notes:
source.writable
is required for the editor to save files back to the source.source.name
enables use ofgenerator.sourcePage$[name]
in helpers.leftDelim
,rightDelim
,headerDelim
customizes fragment header syntax.- setting
source.compile
to 'handlebars'` forces all fragments to be treated as handlebars templates, irrespective of extensions. - setting
source.type
to something other than 'FILE' causes the source to be treated as an opaque JSON object instead of an array containing file objects. - setting
source.defaultExt
to.htm
or.html
will create hrefs with one of those extensions, instead of no extension.


Challenge your friends to Strava.com segments.
Select your opponent, segment and completion date to get started.


#import <NTSolidLayer.h>
Instance Methods | |
| (id) | - initWithColor: |
| (id) | - initWithBitmap: |
| (NTColor *) | - getColor |
| (void) | - setColor: |
| (NTBitmap *) | - getBitmap |
| (void) | - setBitmap: |
| (float) | - getBitmapScale |
| (void) | - setBitmapScale: |
| (BOOL) | - isUpdateInProgress |
| (NSString *) | - swigGetClassName |
| (void *) | - swigGetDirectorObject |
| Instance Methods inherited from NTLayer | |
| (BOOL) | - isEqual: |
| (NSUInteger) | - hash |
| (int) | - getUpdatePriority |
| (void) | - setUpdatePriority: |
| (void) | - setCullDelay: |
| (BOOL) | - isVisible |
| (void) | - setVisible: |
| (NTMapRange *) | - getVisibleZoomRange |
| (void) | - setVisibleZoomRange: |
| (void) | - update: |
| (void) | - refresh |
Class Methods | |
| (NTSolidLayer *) | + swigCreatePolymorphicInstance:swigOwnCObject: |
A solid layer that displays predefined color or bitmap and does not depend on actual view settings.
| - (NTBitmap *) getBitmap |
Returns the bitmap of this layer.
| - (float) getBitmapScale |
Returns the bitmap scaling factor.
| - (NTColor *) getColor |
Returns the color of this layer.
| - (id) initWithBitmap: | (NTBitmap*) | bitmap |
Constructs a SolidLayer object from a bitmap.
| bitmap | The bitmap for the layer. |
| - (id) initWithColor: | (NTColor*) | color |
Constructs a SolidLayer object from a color.
| color | The color for the layer. |
| - (BOOL) isUpdateInProgress |
Tests whether this layer is being currently updated.
Reimplemented from NTLayer.
| - (void) setBitmap: | (NTBitmap*) | bitmap |
Sets the bitmap of this layer.
| bitmap | The new bitmap for the layer. Can be null, in that case the layer color is used. |
| - (void) setBitmapScale: | (float) | scale |
Sets the bitmap scaling factor.
| scale | The new bitmap scaling factor. Default is 1, which corresponds to 1:1 mapping between bitmap pixels and screen pixels. |
| - (void) setColor: | (NTColor*) | color |
Sets the color of this layer.
| color | The new color for the layer. Note: if bitmap is defined, the color is multiplied with the bitmap. |
| + (NTSolidLayer *) swigCreatePolymorphicInstance: | (void*) | cPtr | |
| swigOwnCObject: | (BOOL) | cMemoryOwn | |
Creates a polymorphic instance of the given native object. This is used internally by the SDK.
| cPtr | The native pointer of the instance. |
| cMemoryOwn | The ownership flag. |
Reimplemented from NTLayer.
| - (NSString *) swigGetClassName |
Returns the actual class name of this object. This is used internally by the SDK.
Reimplemented from NTLayer.
| - (void *) swigGetDirectorObject |
Returns the pointer to the connected director object. This is used internally by the SDK.
Reimplemented from NTLayer.


AWC
Responsive Tag - test
Just scroll down!
Display container:
Container One
Container Two
Container Three
Container Four
Container Five


Dec 14, 2010 8:21 PM
Ryan Baker from Worcester Polytechnic will join us to discuss his work on educational data mining. Increasingly, students’ educational experiences occur in the context of educational technology, creating opportunities to log student behavior in a fashion that is both longitudinal and very fine-grained. These data are now available to the broad learning sciences research community through large public data repositories such as the Pittsburgh Science of Learning Center DataShop (cf. Koedinger et al, 2008). In this talk, Professor Baker will discuss how the emerging Educational Data Mining community is combining these data sources with data mining methods in order to scalably use this data to make basic discoveries about learners and learning. Professor Baker will illustrate the use of Educational Data Mining methods through two recent analyses his group has conducted. The first investigates how small-scale details in educational software design have large impacts on how seriously Ryan Baker from Worcester Polytechnic will join us to discuss his work on educational data mining. Increasingly, students' educational experiences occur in the context of educational technology, creating opportunities to log student behavior in a fashion that is both longitudinal and very fine-grained. These data are now available to the broad learning sciences research community through large public data repositories such as the Pittsburgh Science of Learning Center DataShop (cf. Koedinger et al, 2008). In this talk, Professor Baker will discuss how the emerging Educational Data Mining community is combining these data sources with data mining methods in order to scalably use this data to make basic discoveries about learners and learning. Professor Baker will illustrate the use of Educational Data Mining methods through two recent analyses his group has conducted. The first investigates how small-scale details in educational software design have large impacts on how seriously students take the software, and in turn how much they learn, using data from one school of students using educational software for Algebra for an entire year. The second analysis uses data from students using educational software for Middle School Mathematics to develop models that can predict not only whether a student has learned, but also when the learning occurs. This model in turn allows researchers to develop models of the "spikiness" of student learning that can be used to investigate the differences between skills learned through insight and "eureka" moments, and skills learned more gradually. Biography Ryan S. J. d. Baker is Assistant Professor of Psychology and the Learning Sciences at Worcester Polytechnic Institute, with a collaborative appointment in Computer Science. He graduated from Carnegie Mellon University in 2005, with a Ph.D. in Human-Computer Interaction. He is the former Technical Director of the Pittsburgh Science of Learning Center DataShop, the world's largest public repository for data on the interaction between students and educational software. He is Associate Editor of the Journal of Educational Data Mining, and in summer 2010, he was the conference chair of the Third International Conference on Educational Data Mining. He was also co-editor of the Handbook of Educational Data Mining, published in the Fall of 2010. His article 'Detecting Student Misuse of Intelligent Tutoring Systems' was, as of September 2009, the third-most cited article in the first ten years of Educational Data Mining. He received the Best Paper Award at the Intelligent Tutoring Systems Conference in 2006, and received the Best Oral Presentation Award at the Intelligent Tutoring Systems Conference in 2010. Open to all members of the University community. Please let us know if you are coming from outside the EdLab so we order enough lunch.


# Sensitive secrets
## Using .secrets files
To safely store sensitive data Dynaconf also searches for a .secrets.{toml|py|json|ini|yaml} file to look for data like tokens and passwords.
example .secrets.toml:
`ini
[default]
password = "sek@987342$"
`
The secrets file supports all the environment definitions supported in the settings file.
> IMPORTANT: The reason to use a .secrets.* file is the ability to omit this file when committing to the repository so a recommended .gitignore should include .secrets.* line.
## Using Vault server
The [vaultproject.io/](https://www.vaultproject.io/) is a key:value store for secrets and Dynaconf can load variables from a Vault secret.
Run a vault server
Run a Vault server installed or via docker:
`bash
$ docker run -d -e 'VAULT_DEV_ROOT_TOKEN_ID=myroot' -p 8200:8200 vault
`
Install support for vault in dynaconf
`bash
$ pip install dynaconf[vault]
`
In your .env file or in exported environment variables define:
`bash
VAULT_ENABLED_FOR_DYNACONF=true
VAULT_URL_FOR_DYNACONF="http://localhost:8200"
VAULT_TOKEN_FOR_DYNACONF="myroot"
`
Now you can have keys like PASSWORD and TOKEN defined in the vault and dynaconf will read it.
To write a new secret you can use http://localhost:8200 web admin and write keys under the /secret/dynaconf/< env > secret database.
You can also use the Dynaconf writer via console:
```bash # writes {‘password’: 123456} to secret/dynaconf/default $ dynaconf write vault -s password=123456
# writes {‘password’: 123456, ‘username’: ‘admin’} to secret/dynaconf/default $ dynaconf write vault -s password=123456 -s username=admin
# writes {‘password’: 555555} to secret/dynaconf/development $ dynaconf write vault -s password=555555 -e development
# writes {‘password’: 777777, ‘username’: ‘admin’} to secret/dynaconf/production $ dynaconf write vault -s password=777777 -s username=produser -e production ```
then you can access values normally in your program
```py from dynaconf import settings
settings.PASSWORD == 555555 # if ENV_FOR_DYNACONF is the default development settings.USERNAME == ‘admin’ # if ENV_FOR_DYNACONF is the default development
settings.PASSWORD == 777777 # if ENV_FOR_DYNACONF is production settings.USERNAME == ‘produser’ # if ENV_FOR_DYNACONF is production ```
You can also ask settings to be loaded from specific env with from_env method:
`py
settings.from_env('production').PASSWORD == 777777
settings.from_env('production').USERNAME == 'produser'
`
## Additional secrets file (for CI, jenkins etc.)
It is common to have an extra secrets file that is available only when running on specific CI environment like Jenkins, usually there will be an environment variable pointing to the file.
On Jenkins it is done on job settings by exporting the secrets information.
Dynaconf can handle this via SECRETS_FOR_DYNACONF environment variable.
ex:
`bash
export SECRETS_FOR_DYNACONF=/path/to/secrets.toml{json|py|ini|yaml}
`
If that variable exists in your environment then Dynaconf will also load it.


Overview | Reports | Quarter | Contract
| Vendor Name: | BARBARA PERSONNEL INC. |
| Reference number: | K8A30-09-0005 |
| Contract Date: | 2009-04-17 |
| Description of work: | 0813 Temporary help services |
| Contract period: | 2009-05-04 to 2009-08-21 |
| Delivery Date: | |
| Contract Value: | $15,600.00 |
| Comments: |


The Seedwater Consulting Approach
Seedwater Consulting is a facilitator of uncommon collaboration and thinking across historical barriers. When possible, non-profit organizations, non-governmental organizations, and other agencies should be encouraged to collaborate, share best practices, and work together to achieve common goals. This is often the most efficient way to generate lasting change, both in institutional settings and in the lived experience of local communities on the ground.
Seedwater is different than other development consultancies that are unable to bridge disciplines and critically identify, analyze, and engineer the essential elements of multi-faceted projects. We strongly believe in targeted, context-specific, community-driven and led development, and the principles of rigorous design, implementation, monitoring, and adjustment of programs through cutting-edge qualitative and quantitative methods.
Seedwater Consulting works both in the United States and abroad, as we believe that there are communities around the world in need of support and resources to further their own visions for a sustainable, healthy, and just future. Read about some of our past projects here, and the expertise of our team here.


Master Luther:
The very chaos that attracts hunters to this village threatens to overwhelm it now...
A host of self-made "lords" now vie for supremacy, heedless of the consequences of their rash actions. I am sickened by them!
Are you sure you wish to remain here?
Learn skills.
Ask about Skill Enchanting.
Quest


{% extends "layout.html" %} {% block content %}
{{post.tags}}
The Hurry-Up Limited Offer
Here’s a great example of a hurry-up limited offer, also known as a limited-period offer, from our community. Here's huge discount of 20 percent off for premium plan. This offer is valid till “31st December, 2019!”
This is your absolute last chance to get a discount on our Premium Plan, take advantage of this great offer !
You haven't written any posts yet!
Write your first post.
New Post


|
| Local Properties | ||
| Managed Object Types | Data Object Types | All Properties | All Methods |
The object entity-relationship diagram is modeled below:
0..N 0..N 0..N Plugin -----> Device ------> Path <------ Adapter <------ | ------> 0,1 | 1 | | 0,1 \|/ TargetDescription and reasoning behind the relationships:
When a storage device driver is loaded, it claims a PCI device as a host bus adapter. This host bus adapter is represented as an Adapter. The PCI device identifier is a property on the HostBusAdapter in the Adapter.
Once the host bus adapter is on the system, the hardware bus is scanned. If a storage Device is found on the bus, the communication path to the Device from the the host bus adapter is represented by a Path. A Device may have more than one Path. How those Paths are composed to create a Device is determined by a storage Plugin.
When a storage Plugin is loaded, it claims a set of Paths. It groups these Paths into a set of Devices. Devices are hence associated with a set of Paths that might be used to provide a single logical device such as in the case of multipathing. Devices may be also composed of zero Paths meaning that they do not directly use a host bus adapter for communication with underlying storage.
The purpose of this data object is to represent the topology of storage as seen by the base plug-store system. There is some overlap with information in other objects such as ScsiTopology which is only applicable when a particular "native multipathing" plugin is used. This data object provides the complete inventory of Devices and Paths. Hence it provides a superset of Device mappings over data object such as ScsiTopology and Multipa
The use cases that this data object accommodates includes the following non-exhaustive list:
Properties
| Name | Type | Description |
|---|---|---|
| adapter* | HostPlugStoreTopologyAdapter[] |
List of host bus adapters in the plug store inventory.
|
| device* | HostPlugStoreTopologyDevice[] |
List of devices in the plug store inventory.
|
| path* | HostPlugStoreTopologyPath[] |
List of paths in the plug store inventory.
|
| plugin* | HostPlugStoreTopologyPlugin[] |
List of plugins in the plug store inventory.
|
| target* | HostPlugStoreTopologyTarget[] |
Partial list of targets as seen by the host. The list of targets
may not be exhaustive on the host.
|
| Properties inherited from DynamicData | ||
| None |
| Top of page | Local Properties | ||
| Managed Object Types | Data Object Types | All Properties | All Methods |


]
def _forward(self, x, **condition_kwargs):
x = self._maybe_assert_valid_x(x)
out = x
for layer in self.layers:
out, _ = layer.forward_and_jacobian(out)
]
def _forward(self, x, **condition_kwargs):
self._maybe_assert_valid_x(x)
observations = condition_kwargs["observations"]
out = x
for layer in self.layers:


This game is part of a research study conducted by Leah Nicolich-Henkin at Carnegie Mellon University. The purpose of the research is to study people's preferences for different types of notification systems.
Procedures
The study involves three parts. First, participants will first complete a basic Digit Span cognitive test. Then they will play a game, including receiving spoken notification instructions for other tasks. Finally, they will complete a survey. The entire study will take approximately 15 minutes.
Participant Requirements
Participation in this study is limited to individuals age 18 and older.
Risks
The risks and discomfort associated with participation in this study are no greater than those ordinarily encountered in daily life or during other online activities. There is a minor risk of disclosure of personal information.
Benefits
There may be no personal benefit from your participation in the study but the knowledge received may be of value to humanity.
Compensation & Costs
Participants will be paid $2 for completing the study. There will be no cost to you if you participate in this study.
Confidentiality
In some game conditions, the system may record your voice as you respond to the dialog system. These audio recordings and your Amazon Mechanical Turk Worker ID are the only personal identifiers collected in the study.
By participating in this research, you understand and agree that Carnegie Mellon may be required to disclose your consent form, data and other personally identifiable information as required by law, regulation, subpoena or court order. Otherwise, your confidentiality will be maintained in the following manner:
Your data and Worker ID will be kept separate. Your ID and any recordings will be stored on a secure server on Carnegie Mellon property and will not be disclosed to third parties. Sharing of data with other researchers will only be done in such a manner that you will not be identified.
By participating, you understand and agree that the data and information gathered during this study may be used by Carnegie Mellon and published and/or disclosed by Carnegie Mellon to others outside of Carnegie Mellon. However, your name, address, contact information and other direct personal identifiers will not be mentioned in any such publication or dissemination of the research data and/or results by Carnegie Mellon. Note that per regulation all research data must be kept for a minimum of 3 years.
Right to Ask Questions & Contact Information
If you have any questions about this study, you should feel free to ask them by contacting the Principal Investigator now at
Leah Nicolich-Henkin, Graduate Research Assistant
Language Technologies Institute
5000 Forbes Avenue, Pittsburgh, PA, 15213
917-576-0221
<EMAIL_ADDRESS>If you have questions later, desire additional information, or wish to withdraw your participation please contact the Principal Investigator by mail, phone or e-mail in accordance with the contact information listed above.
If you have questions pertaining to your rights as a research
participant; or to report concerns to this study, you should contact
the Office of Research integrity and Compliance at Carnegie Mellon
University.
Email<EMAIL_ADDRESS>Phone:<PHONE_NUMBER> or<PHONE_NUMBER>.
Voluntary Participation
Your participation in this research is voluntary. You may discontinue participation at any time during the research activity.


[requester_name] has nominated you as the cover-up for the [leave_type]. [he_she]' needs to obtain from below days.Please click below to agree or reject [his_her] request.
Leave Date [leave_dates]
10 Jun 2016
15 Jun 2016
10 Jun 2016
0.5
10 Jun 2016
1
10 Jun 2016
1.5
|
|
This is auto generated Email if you need more clarification please contact HR Department.
Thank you.


Index of /Ripplect3/Beta/assets/global/plugins/amcharts/amcharts
Parent Directory
amcharts.js
pie.js
radar.js
serial.js
themes/


About
the Add Total Row and Column Tool:
The Add Total Row and Column tool adds a total column and a total row onto your data table.
Configuration Properties:
The tool has two configuration properties:
First select which columns you want to sum.
Second select if you want row and column totals or just one of them.
Version History:
Version 1.0 - Initial release.
Version 2.0 - Updated to Alteryx 9.0 macro interface.
___________________________________________________________________________________
www.ChaosReignsWithin.com


Which of the following is not a fundamental capability of a dictionary?
Insert, search, and delete are things that you want to do to most "container" data structures.
Traverse is something that you normally do to a tree.


The Java EE 7 Tutorial
37.2 Entity Inheritance
Entities support class inheritance, polymorphic associations, and polymorphic queries. Entity classes can extend non-entity classes, and non-entity classes can extend entity classes. Entity classes can be both abstract and concrete.
The roster
example application demonstrates entity inheritance, as described in Entity Inheritance in the roster Application.
37.2.1 Abstract Entities
An abstract class may be declared an entity by decorating the class with @Entity
. Abstract entities are like concrete entities but cannot be instantiated.
Abstract entities can be queried just like concrete entities. If an abstract entity is the target of a query, the query operates on all the concrete subclasses of the abstract entity:
@Entity public abstract class Employee { @Id protected Integer employeeId; ... } @Entity public class FullTimeEmployee extends Employee { protected Integer salary; ... } @Entity public class PartTimeEmployee extends Employee { protected Float hourlyWage; }
37.2.2 Mapped Superclasses
Entities may inherit from superclasses that contain persistent state and mapping information but are not entities. That is, the superclass is not decorated with the @Entity
annotation and is not mapped as an entity by the Java Persistence provider. These superclasses are most often used when you have state and mapping information common to multiple entity classes.
Mapped superclasses are specified by decorating the class with the annotation javax.persistence.MappedSuperclass
:
@MappedSuperclass public class Employee { @Id protected Integer employeeId; ... } @Entity public class FullTimeEmployee extends Employee { protected Integer salary; ... } @Entity public class PartTimeEmployee extends Employee { protected Float hourlyWage; ... }
Mapped superclasses cannot be queried and cannot be used in EntityManager
or Query
operations. You must use entity subclasses of the mapped superclass in EntityManager
or Query
operations. Mapped superclasses can't be targets of entity relationships. Mapped superclasses can be abstract or concrete.
Mapped superclasses do not have any corresponding tables in the underlying datastore. Entities that inherit from the mapped superclass define the table mappings. For instance, in the preceding code sample, the underlying tables would be FULLTIMEEMPLOYEE
and PARTTIMEEMPLOYEE
, but there is no EMPLOYEE
table.
37.2.3 Non-Entity Superclasses
Entities may have non-entity superclasses, and these superclasses can be either abstract or concrete. The state of non-entity superclasses is nonpersistent, and any state inherited from the non-entity superclass by an entity class is nonpersistent. Non-entity superclasses may not be used in EntityManager
or Query
operations. Any mapping or relationship annotations in non-entity superclasses are ignored.
37.2.4 Entity Inheritance Mapping Strategies
You can configure how the Java Persistence provider maps inherited entities to the underlying datastore by decorating the root class of the hierarchy with the annotation javax.persistence.Inheritance
. The following mapping strategies are used to map the entity data to the underlying database:
-
A single table per class hierarchy
-
A table per concrete entity class
-
A "join" strategy, whereby fields or properties that are specific to a subclass are mapped to a different table than the fields or properties that are common to the parent class
The strategy is configured by setting the strategy
element of @Inheritance
to one of the options defined in the javax.persistence.InheritanceType
enumerated type:
public enum InheritanceType { SINGLE_TABLE, JOINED, TABLE_PER_CLASS };
The default strategy, InheritanceType.SINGLE_TABLE
, is used if the @Inheritance
annotation is not specified on the root class of the entity hierarchy.
<IP_ADDRESS> The Single Table per Class Hierarchy Strategy
With this strategy, which corresponds to the default InheritanceType.SINGLE_TABLE
, all classes in the hierarchy are mapped to a single table in the database. This table has a discriminator column containing a value that identifies the subclass to which the instance represented by the row belongs.
The discriminator column, whose elements are shown in Table 37-2, can be specified by using the javax.persistence.DiscriminatorColumn
annotation on the root of the entity class hierarchy.
Table 37-2 @DiscriminatorColumn Elements
| Type | Name | Description |
|---|---|---|
|
|
|
The name of the column to be used as the discriminator column. The default is |
|
|
|
The type of the column to be used as a discriminator column. The default is |
|
|
|
The SQL fragment to use when creating the discriminator column. The default is generated by the Persistence provider and is implementation-specific. This element is optional. |
|
|
|
The column length for |
The javax.persistence.DiscriminatorType
enumerated type is used to set the type of the discriminator column in the database by setting the discriminatorType
element of @DiscriminatorColumn
to one of the defined types. DiscriminatorType
is defined as follows:
public enum DiscriminatorType { STRING, CHAR, INTEGER };
If @DiscriminatorColumn
is not specified on the root of the entity hierarchy and a discriminator column is required, the Persistence provider assumes a default column name of DTYPE
and column type of DiscriminatorType.STRING
.
The javax.persistence.DiscriminatorValue
annotation may be used to set the value entered into the discriminator column for each entity in a class hierarchy. You may decorate only concrete entity classes with @DiscriminatorValue
.
If @DiscriminatorValue
is not specified on an entity in a class hierarchy that uses a discriminator column, the Persistence provider will provide a default, implementation-specific value. If the discriminatorType
element of @DiscriminatorColumn
is DiscriminatorType.STRING
, the default value is the name of the entity.
This strategy provides good support for polymorphic relationships between entities and queries that cover the entire entity class hierarchy. However, this strategy requires the columns that contain the state of subclasses to be nullable.
<IP_ADDRESS> The Table per Concrete Class Strategy
In this strategy, which corresponds to InheritanceType.TABLE_PER_CLASS
, each concrete class is mapped to a separate table in the database. All fields or properties in the class, including inherited fields or properties, are mapped to columns in the class's table in the database.
This strategy provides poor support for polymorphic relationships and usually requires either SQL UNION
queries or separate SQL queries for each subclass for queries that cover the entire entity class hierarchy.
Support for this strategy is optional and may not be supported by all Java Persistence API providers. The default Java Persistence API provider in GlassFish Server does not support this strategy.
<IP_ADDRESS> The Joined Subclass Strategy
In this strategy, which corresponds to InheritanceType.JOINED
, the root of the class hierarchy is represented by a single table, and each subclass has a separate table that contains only those fields specific to that subclass. That is, the subclass table does not contain columns for inherited fields or properties. The subclass table also has a column or columns that represent its primary key, which is a foreign key to the primary key of the superclass table.
This strategy provides good support for polymorphic relationships but requires one or more join operations to be performed when instantiating entity subclasses. This may result in poor performance for extensive class hierarchies. Similarly, queries that cover the entire class hierarchy require join operations between the subclass tables, resulting in decreased performance.
Some Java Persistence API providers, including the default provider in GlassFish Server, require a discriminator column that corresponds to the root entity when using the joined subclass strategy. If you are not using automatic table creation in your application, make sure that the database table is set up correctly for the discriminator column defaults, or use the @DiscriminatorColumn
annotation to match your database schema. For information on discriminator columns, see The Single Table per Class Hierarchy Strategy.


SENDIT
Login
Signup
Home
SENDIT
A package delivery solution you can trust
Check us out
Signup Form
x
First Name:
Last Name:
Username:
Other Names:
Your Email:
User type
User
Admin
Password:
Confirm Password:
Signup
Login Form
x
Your Email:
Password:
Login
successful


Huanted is the game I made for the final project for game design class. It features a first person controller in a 3D environment.
In this game, the player plays a ghost that is haunting this house in the middle of the woods. Using ghost power to interact with objects in the house, the player will try to scare the man reading by his bookshelf. The goal is to scare the man out of his house.
NPC tries to trun off the record player that started by the ghost (i.e. the player)
I used a state machine to controll the movement of NPC over time. The red bar on left side of the screen indicates the current "scared level" of the NPC, corresponding to the state of NPC. There are total of 5 states for the NPC:


|
SETUP - Each player drops a King on any
empty cell, except on his 2nd row.
|
|
INVALID POSITIONS
|
Kings may not stand on the left/right edge of
the board, while adjacent to a friendly pawn on the same column. |
|
Kings may not stand on the first row, while
adjacent to a friendly pawn on the same row. |
|
Kings may not stand on the second row, while
adjacent to a friendly pawn on the first row. |
|
|
TURN - On each turn, each player moves one
of his pieces producing a valid position:
|
The pawns may move to any empty cell. |
|
The Kings may slide (orthogonally or
diagonally) any number of empty cells (like the chess Queen). |
|
CAPTURE - Besides moving, any piece
may capture adjacent enemy pieces by jumping over them, landing on
the immediate empty cell. Captures are not mandatory and are not
multiple. |
|
|
GOAL - Wins the player that captures
the enemy King or moves his own King to the last row. |
|


Dat Protocol
Dat Enhancement Proposals (DEPs)
This page contains a series of "Dat Enhancement Proposal" (DEP) documents, part of the Dat Protocol development and standardization process.
These documents might be interesting reading to anybody wanting to learn more about protocol nitty gritties or the consensus process, but the documentation at docs.datproject.org is specifically written with end-users and application developers in mind.
DEPs:
- [Draft] DEP-0001: The Dat Enhancement Proposal Process
- [Draft] DEP-0002: Hypercore
- [Draft] DEP-0003: HTTP Pinning Service API
- [Draft] DEP-0004: Hyperdb
- [Draft] DEP-0005: DNS
- [Draft] DEP-0006: Session Data (Extension Message)
- [Draft] DEP-0007: Hypercore Header
- [Draft] DEP-0008: Multi-Writer
- [Draft] DEP-0009: Hypercore SLEEP Headers
- [Draft] DEP-0010: Hypercore Wire Protocol
View pre-draft DEPs on GitHub.


Software Developer
I'm an experienced information technology professional (mainly network support and security) aspiring to become a software developer. I've dabbled around with a few web technologies, but after a year of attending Meet Ups in Seattle and researching the job market, I decided to make the jump into software development.


Preparation time
overnight
Cooking time
30 mins to 1 hour
Serves
Serves 8
Dietary
For the gingerbread, preheat the oven to 160C/320F/Gas 3 and grease and line a 900g/2lb loaf tin.
Sift the dry ingredients into a large bowl. Mix the milk, honey, eggs and sugar in another bowl with the citrus zest and vanilla seeds, then add to the dry ingredients and mix well until evenly combined. Spoon the mixture into the prepared tin. Bake for 45 minutes or until a skewer inserted in the centre comes out clean. Cool in the tin for about 30 minutes, then remove and leave to cool on a wire rack.
To make gingerbread crumbs (you need 100g/4oz), cut the gingerbread into 5mm/¼in-thick slices and leave to dry on a tray overnight. The next day, grind the slices to fine crumbs in a food processor. Store in a plastic container until ready to use. (The rest of the gingerbread can be eaten as a cake; wrapped in foil it will keep for a week or more.)
For the stock syrup, put the lemon slice in a heavy pan with the sugar, liquid glucose and 300ml/½ pint water. Heat gently, stirring occasionally, until the sugar has dissolved, then bring to the boil and boil for five minutes. Cool. Remove the lemon slice, then pass the syrup through a fine sieve. Chill in a covered container in the fridge.
For the raspberry sorbet, put the raspberries in a heavy pan, sprinkle lightly with caster sugar and two tablespoons of water, and cook over a low heat for about five minutes or until the raspberries soften. Tip into a fine sieve set over a bowl and push the purée through to remove the seeds. Cover and chill in the fridge.
Set 100ml/3½fl oz of raspberry purée aside in the fridge for later. Combine the remaining purée with 250ml/9fl oz of the chilled stock syrup, the liquid glucose and lemon juice. Churn in an ice cream machine until thickened, according to manufacturer's instructions, then decant into a clean container and store in the freezer until ready to use.
For the cheesecakes, stand eight metal chefs' rings, each measuring 5.5cm/2¼in tall and 4.5cm/1¾in across, on a non-stick mat or baking sheet lined with cling film. Combine the soft cheese, cream, crème fraîche, sugar and vanilla seeds in a large bowl. Whisk together well until thick, then put the mixture in a plastic piping bag and pipe neatly into the rings. Make sure there are no gaps or air pockets and pipe right up to the tops, then smooth the tops with the back of a flat knife. Refrigerate for two hours or until set firm.
Meanwhile, make scoops of sorbet and transfer to a tray lined with baking parchment. Place in the freezer. Put the raspberries in a bowl with the reserved 100ml/3½fl oz raspberry purée and lightly mix with a fork. Set aside at room temperature.
About five minutes before serving, remove the cheesecakes from the fridge. One at a time, lift each cheesecake off the mat and dip both ends in the gingerbread crumbs, then warm the ring in your hands for 30 seconds (or very quickly flash round the ring with a blowtorch). Now hold the ring over a plate and carefully lift it up so the cheesecake drops out onto the plate.
To finish, put a spoonful of the raspberries to the side of each plate and sprinkle a line of gingerbread crumbs between the cheesecake and the raspberries. Top each cheesecake with a scoop of sorbet and serve immediately.


Creative Commons
<
Sites for Creative Common Images
- You can easily filter Google Images by License:
- Pics4Learning- Over 35000 images for educational purposes
- Wikimedia Commons (4 million images in the public domain)
- World Images (80,000 photos from the California State University IMAGE project, under a non-commercial CC license)
- CC Image Search Engine
- Hubspot Stock Images
Sites for Creative Common Sound Files & Music


{% extends "layout_bsa.html" %} {% block page_title %} Prepay for NHS prescriptions {% endblock %} {% block content %} {% include "includes/phase_banner_beta.html" %} You already have an existing prescription prepayment You can view your existing prescription prepayment in the return service. Return to NHS Business Services home {% endblock %}
You can view your existing prescription prepayment in the return service.
Return to NHS Business Services home


Explore by using the inconvenient method of typing "/projects" or "/about" after localhost:5000 in your browser


In this assignment you will begin developing your backend server and complete the implementation of your frontend web application. Your frontend webapp from this assignment will be reviewed by your peers to provide you user feedback.
Separations of concerns instructs us to divide our application into separate front and back end processes. In this way our application is modular, can be selectively scaled, and we have indepdence to change each at their own pace. In this assignment we will separately host our frontend and backend applications on Surge and Heroku respectively.
The remaining implementations missing from our frontend web app are the ability to upload articles with and without images, register new users, edit a user's profile including uploading a new profile avatar, adding a new followed users, and removing followed users. For our first implementation of the backend server we will implement the headlines and articles endpoints, and provide stubs for a collection ofthe others.
In the previous assignment we implemented the ability for users to login to our webapp, and pulled from the dummy server the user's status headline, their profile avatar, their feed of articles, and their list of followers. Now we add the missing functionality to create a fully functioning social networking web application frontend.
For uploading images on articles as well as to upload profile avatars, see this section of the API page.
For this assignment we will use Selenium and write end-to-end tests to validate functionality of our web app. Serve your frontend site locally and have Selenium run against your locally running frontend site similar to the inclass exercise. The required tasks for your end-to-end tests are listed in the requirements section below.
We will have separate frontend and backend applications. Your frontend app is currently talking to my dummy server, and eventually we want it talking to your server. But there's a lot of work to get that done!
Getting started you should do your development for your backend in it's own directory separate from your frontend and separate from your inclass submission directory. Because we use git to communicate to Heroku you will want a separate git repo for your backend server -- if you "git init" inside your regular git repo used for inclass submissions then you will create a git submodule. If you go this route you are responsible for assuring everything works. It is far easier to have a separate git repo just for your backend server. Recall you can submit *any* git repo for your assignments so long as it has the appropriate subdirectory.
Most of the backend has already been developed through inclass exercises. "npm start" should spin up your server at http://localhost:3000 and you can use your browser, a browser extension (such as Advanced REST Client or Postman), or use curl on the commandline to test your server.
Stubs are "pieces of code used to stand in for some other programming functionality." For this assignment we will create stubs for all of the desired endpoints of our API. After the stubs are created, then we will implement selected functionality in this assignment.
Here is the recommended breakout by endpoint for each source file in your backend server
| endpoint | verbs | source file |
|---|---|---|
| /login | POST | auth.js |
| /logout | PUT | auth.js |
| /register | POST | auth.js |
| /password | PUT | auth.js |
| /articles | GET, PUT | articles.js |
| /article | POST | articles.js |
| /headline | GET, PUT | profile.js |
| /headlines | GET | profile.js |
| GET, PUT | profile.js | |
| /dob | GET | profile.js |
| /zipcode | GET, PUT | profile.js |
| /avatars | GET | profile.js |
| /avatar | PUT | profile.js |
| /following | GET, PUT, DELETE | following.js |
// this is profile.js which contains all user profile // information except passwords which is in auth.js const profile = { headline: 'This is my headline!', email<EMAIL_ADDRESS>zipcode: 12345, avatar: 'https://upload.wikimedia.org/wikipedia/en/thumb/4/4e/DWLeebron.jpg/220px-DWLeebron.jpg', } const getHeadlines = (req, res) => { // we will want middleware to supply this value // for now we provide a default if (!req.user) req.user = 'Scott' const users = req.params.users ? req.params.users.split(',') : [req.user] // this returns only one headline, but we want to send // an array of all the requested user's headlines res.send({ headlines: [ { username: users[0], headline: headlines[users[0]] } ] }) // Implement the logic to return headlines for all requested users // each user has a default value. Only the "req.user" value ever changes. } module.exports = (app) => { app.get('/headlines/:users*?', getHeadlines) }The API for the endpoints is the same as for the dummy server (i.e., this way we don't need to change any of the frontend code). That api is found here
GET /sample
Just as for the previous assignment, we will employ test driven development as we implement our backend server. Therefore start by writing unit tests for each unit of functionality we desire to implement, and then implement that functionality, thereby satisfying the test criteria. You might have these tests already written from inclass exercises.
Use https://www.clear.rice.edu/comp431/sample/RiceBookServer/ as an example Node application with testing enabled. We used this example for the inclass backend testing exercise.
For this assignment, write tests for, and then implement, the following endpoints (see the API page for specification)
GET /headlines
GET /headlines/sampleUser
(should always return a value)PUT /headline
(updates value in memory for default user, so a GET call returns new value)GET /articles
(should return at least 3 articles)GET /articles/id
(where id is a valid article id as well as when it is an invalid article id)POST /article
(test that adding an article increments the article id, validate the contents of the new article)We do not yet have a database for storing the information the server needs to provide to the client. Therefore we keep all data in memory. The only data that can change is the data for the currently logged in user. This user has some default user name ('Scott' in my example code above). I recommend you have a profile object in memory that you use for updating the headline. Subsequent calls of PUT /headline and GET /headlines should return updated values. I.e., PUT /headline with payload "Hello" will update the in memory profile object and then GET /headlines will return me "Hello". GET /headlines/foo will return a default value for the user "foo".
Make the zipcode and email endpoints also persistent, i.e., PUT /zipcode should update the zipcode value returned by GET /zipcdode. PUT /avatar is just a stub.
Similar to the headline, we'll have an array for articles. We should start with 3 hardcoded articles in this array, you can use the sample data provided from the dummy server. When a new article is added, it should be added to this array. An article has the following schema:
const article = { _id: int, author: string, text: string, date: new Date(), comments: [ ] }A new article will arrive with only the text in the payload. The timestamp is the current time on the server, the author is the currently logged in user (some default value), and the _id is a unique value determined by the server (the length of the article array would be sufficient for now). The response to
POST /article
is an array of the newly added article, i.e., with it's timetsamp, author, and id values supplied.
The newly added article will automatically be available in the list of all articles
returned by a call to the GET /articles
endpoint.
For now you can supply whatever username you want, just as for the headlines endpoint above.
Check that your backend works. For example you can perform the following commands (either using curl as shown here or Advanced Rest Client or similar)
curl https://ricebookserver.herokuapp.com/articles # you should receieve 3 articles curl -H 'Content-Type: application/json' -d '{ "text": "My first message!"  I assume the value is 12345, let's verify getById works: curl https://ricebookserver.herokuapp.com/articles/12345 # you should get your new article again curl https://ricebookserver.herokuapp.com/articles # you should get 4 articles now
We will use an automated test similiar to these commands to check the functionality of your backend.
When you have completed the implementation of the required pieces of your
backend server you are ready to publish your server to Heroku.
Note that the git repo sent to Heroku should only contain
your backend application, not any inclass exercises or other homework assignments.
Be sure you have node_modules
excluded from your git repo but by adding it to the gitignore file
(Heroku will automatically install these libraries for us because they are in our package.json file).
In the example below I have named my server "ricebookserver" -- you will want
to pick your own name, or omit and Heroku will supply a name for you
git init heroku create ricebookserver echo web: node index.js > Procfile echo node_modules >> .gitignore echo npm-debug.log >> .gitignore git add .gitignore Procfile package.json index.js git commit -m 'initial commit' git push heroku master
Heroku should automatically recognize that we have a NodeJS application.
Similar to before, create a file README.json
that has contents similar to what is below
(we will read this programmatically so make sure you follow this style and it is proper json)
{ "netid": "sep1", "frontend": "https://ricebookapp.surge.sh", "backend": "https://ricebookserver.herokuapp.com" }
replace "ricebookapp" and "ricebookserver" with the names of your frontend and backend applications, and replace "sep1" with your netID.
We finish the implementation of the frontend of our webapp while continuing to use the dummy server as a backend data store.
Your end-to-end tests will run against your web app running on your localhost. Here are the tasks for your end-to-end test
Include a XML juit report of your end-to-end tests: e2e/results.xml
-- note that you are responsible for the file contents to receive credit for your tests.
Your backend server will be hosted on Heroku, we will use a grading robot to validate your implementation, so be sure you test your deployed server before you submit.
GET /headlines
returns headline message for default userGET /headlines/:user*?
returns a headline message, one for each user in urlPUT /headline
updates default user's headlineGET /articles/
returns all articles, 3 hardcoded and any additional that are addedGET /articles/:id
returns the article with the requested id if it exists, none otherwisePOST /article
adds a new article to the list of all articles. Returns the newly added articleInlucde a JUnitXML report of your backend unit tests.
Using mocha add "-R xunit" and then pipe the results
to a file, e.g., results.xml
-- note that you are responsible for the file contents to receive credit for your tests.
Your frontend and backend applications are each within their own separate repository. You will submit each separately. It is your responsibility to correctly submit your frontend to the frontend submission selection and the backend to the backend submission selection on the grading site. Because the backend is hosted on Heroku, there is no "hw" directory in that repo. The README.json file should be same in both submissions.
Your frontend submissionhw{{vm.hwid}}-frontend [this directory is optional] |-- .babelrc |-- .eslintrc |-- .gitignore |-- README.json |-- package.json |-- coverage | `-- ... |-- e2e | |-- ... | `-- results.xml ...Your backend submission might look like this (notice no root directory)
. |-- README.json |-- .gitignore |-- index.js |-- mocha.opts |-- package.json |-- Procfile |-- results.xml `-- src |-- auth.js |-- articles.js |-- articles.spec.js |-- following.js |-- profile.js `-- profile.spec.js
Note that I have placed the headline endpoints in profile.js
as a look ahead to
the way in which we will be persisting the data: the headline of a user will be stored along
with their other profile information.


My journey as a software developer started already at the age 21 when attending University of Johannesburg for Software Design, Network configuration and Electronics. My stay at the university has helped me to widen my range of knowledge and gather experiences through various disciplines, such as front-end development, 2D game development and many more. Fast forward few years, I’m now adding more knowledge to my skillset with CTU where i am enrolled for a System Development course.


MUSIC APP
Select a song..
Or you can drag a song into below
please drag a song file into this rectangle


interface DisableWifiCallbacks : BaseCallback
Callbacks for disabling a device's wifi.
See Also
com.isupatches.wisefy.WiseFy.disableWifi
Author
Patches
Since
3.0
abstract fun failureDisablingWifi(): Unit
Called when there is an issue disabling Wifi on the device. |
|
abstract fun wifiDisabled(): Unit
Called when WiseFy has successfully disabled Wifi on the device. |
abstract fun wisefyFailure(wisefyFailureCode: Int): Unit
Called when com.isupatches.wisefy.WiseFyPrechecks determines that there is an issue and an operation cannot be completed. |


SceneJS
- canvas texture - drawing
Here, a canvas texture is used to allow drawing to the texture being used.
Click and drag on the surface to draw.


What knowledge exists on the impacts of metal mining (and its mitigation measures) on social ecological systems in Arctic and Boreal regions?
This Formas-funded project is led by researchers and experts at Stockholm Environment Institute in collaboration with Carleton University.
By synthesising multiple knowledge systems, this topic will break new ground in developing methods for integrating diverse forms of evidence. It will also attempt to collate and understand the nature of knowledge from research, planning documents, and indigenous and local knowledge systems.
You can read the full project documentation on the Open Science Framework mini site here.
As mining in the Arctic increases, there is an urgent need to assess social and environmental impacts as well as mitigate negative impacts.
This project will develop a multiple evidence base methodology combining systematic review approaches with mapping of indigenous and local knowledge (ILK), applying this approach in a case study of the impacts of metal mining (iron, copper, nickel, lead, zinc, gold, silver, molybdenum) in Arctic and boreal systems.
Systematic reviews are ‘gold standard’ summaries of research evidence, but cannot include other forms of knowledge, e.g. ILK. Theoretical frameworks for synthesising multiple evidence bases have been proposed but see limited practical application.
This project develops a co-synthesis methodology to concurrently map research evidence, proposed impacts in environmental and social impact assessments (EIAs/SIAs), and ILK co-produced with Sami communities in Sweden. It will assess available knowledge on the impacts of base metal mining in boreal and arctic regions and the effects of mitigation measures in Sweden.
In spite of an increase in mining, evidence of impacts on social-ecological systems is patchy: there has been no review of impacts on Sami lands for example. Similarly, evidence on the direct and indirect effects of mitigation measures is disparate and spread across disciplines. This issue is therefore well-suited to a multiple evidence base approach to provide an enhanced knowledge base for decision-making.
This project will produce an interactive knowledge map, displaying the type and volume of evidence, highlighting knowledge gaps and clusters, and suggesting topics warranting further research or management.


Welcome To SBS
Below is a one-time activation link. After your email is confirmed, you will be shown a highly sensitive QR Code that will help you set up Google Authenticator for you. Be sure not to share it with anyone. This is a required set up. Without this, you will not be able to sign in to your account.
{% if DEBUG %} http://<IP_ADDRESS>:8000{% url 'app:UserConfirmation' uidb token %} {% else %} https://<IP_ADDRESS>:443{% url 'app:UserConfirmation' uidb token %} {% endif %}


Coverage Summary for Class: FaithTrack (it.polimi.ingsw.model)
| Class | Class, % | Method, % | Line, % |
|---|---|---|---|
| FaithTrack | 100% (1/1) | 100% (15/15) | 93,5% (29/31) |
1 package it.polimi.ingsw.model; 2 3 4 import it.polimi.ingsw.client.reducedmodel.ReducedFaithTrack; 5 import it.polimi.ingsw.commons.StateFavorTiles; 6 import it.polimi.ingsw.model.gameEvents.ActivateVaticanReportEvent; 7 import it.polimi.ingsw.model.gameEvents.GameEvent; 8 import it.polimi.ingsw.model.gameEvents.HitLastSpace; 9 import it.polimi.ingsw.Observable; 10 11 import java.util.Arrays; 12 13 /** 14 * This class represents the Faith Track of Maestri del Rinascimento board game. 15 * It is a part of the {@link PersonalBoard} where the player can move his faith marker. 16 * It is composed by 25 cells and 3 Vatican Report Sections. 17 */ 18 public class FaithTrack extends Observable<GameEvent> { 19 /** 20 * The position of the player on the track. 21 */ 22 private int faithMarker; 23 /** 24 * The index of the last passed Vatican Report Section. 25 */ 26 private int passedSection; 27 /** 28 * Each cell of the Faith Track is associated with some victory points, gained by the player 29 * when he reaches that cell. 30 */ 31 private final int[] victoryPoints = new int[25]; 32 /** 33 * The three Vatican Report Sections forming the Faith Track. 34 */ 35 private final VaticanReportSection[] sections = new VaticanReportSection[3]; 36 37 /** 38 * Moves the player forward by the given number of positions. 39 * @param movingPlayer the player to move. 40 * @param pos the number of positions to move the player by. 41 */ 42 public void moveMarker(Player movingPlayer,int pos) { 43 for(int i=0; i<pos; i++){ 44 this.faithMarker++; // moves the marker forward 45 if(sections[passedSection].isPopeSpace(this.faithMarker)){ 46 this.activeVaticanReport(movingPlayer,passedSection);// actives a vatican report 47 } 48 if(this.faithMarker >= sections[passedSection].getPopeSpace()){ 49 if(passedSection < 2) // checks if the current vatican section has been passed 50 this.passedSection++; 51 } 52 if(this.faithMarker == 24) { // conclusion event reached 53 notify(new HitLastSpace()); 54 break; 55 } 56 } 57 } 58 59 /** 60 * Computes the number of victory points earned by the player from his faith track. 61 * @return the number of victory points earned. 62 */ 63 private int calcVictoryPointsFaithTrack() { 64 if(this.victoryPoints[this.faithMarker]!=0) return this.victoryPoints[this.faithMarker]; 65 else { 66 for(int i=this.faithMarker-1;i>=0;i--) { 67 if(this.victoryPoints[i]!=0) return this.victoryPoints[i]; 68 } 69 return 0; 70 } 71 } 72 73 /** 74 * Computes the number of victory points earned by the player from the Favor Tiles. 75 * @return the number of victory points earned. 76 */ 77 private int calcVictoryPointsFavorTiles() { 78 return Arrays.stream(sections).map(VaticanReportSection::getVictoryPoints).reduce(0,Integer::sum); 79 } 80 81 /** 82 * Computes the overall number of victory points earned by the player from his Faith Track. 83 * @return the number of victory points earned. 84 */ 85 public int calcVictoryPoints() { 86 return calcVictoryPointsFaithTrack()+calcVictoryPointsFavorTiles(); 87 } 88 89 /** 90 * Actives a Vatican Report only if the Favor Tile associated with the pope space reached is still faced down. 91 * Notifies the {@link Game} of the activation. 92 * @param triggerPlayer the player who activated the vatican report. 93 * @param vatican_index the index of the section where the vatican report has been activated. 94 */ 95 public void activeVaticanReport(Player triggerPlayer,int vatican_index) { 96 if (this.sections[vatican_index].getState() == StateFavorTiles.FACEDOWN) 97 notify(new ActivateVaticanReportEvent(triggerPlayer,vatican_index)); 98 } 99 100 /** 101 * Sets the Favor Tile at the given index to the given state. 102 * @param index the index of the Favor Tile to set. 103 * @param state the state to set. 104 */ 105 public void setFavorTile(int index, StateFavorTiles state) { 106 this.sections[index].setValidFavorTiles(state); 107 } 108 109 /** 110 * @param index the index of the favor tile to get. 111 * @return the state of the Favor Tile at the index given. 112 */ 113 public StateFavorTiles getStateFavorTile(int index) { return this.sections[index].getState(); } 114 115 /** 116 * Checks if the player has reached a pope space. 117 * @param vatican_index the index of the section where the player is. 118 * @param marker the position of the player on the Faith Track. 119 * @return the check validity. 120 */ 121 public boolean isPopeSpace(int vatican_index, int marker){ 122 if(sections[vatican_index].isPopeSpace(marker)) return true; 123 return false; 124 } 125 126 /** 127 * @return the position of the pope space cell on the given section. 128 */ 129 public int getPopeSpace(int passedSection) { 130 return sections[passedSection].getPopeSpace(); 131 } 132 133 /** 134 * Getter method used for test purposes only. 135 */ 136 public int[] getVictoryPoints() { 137 return victoryPoints; 138 } 139 140 /** 141 * @return the player's position of the Faith Track. 142 */ 143 public int getFaithMarker() { 144 return faithMarker; 145 } 146 147 /** 148 * @return the index of the last passed Vatican Report Section. 149 */ 150 public int getPassedSection() { 151 return passedSection; 152 } 153 154 /** 155 * @return the three Vatican Report Sections forming the Faith Track. 156 */ 157 public VaticanReportSection[] getSections() { 158 return sections; 159 } 160 161 /** 162 * Gets the reduced version of this class in order to be sent through network 163 * and update the client's reduced model. 164 * @return the serializable version of the faith track to send through network. 165 */ 166 public ReducedFaithTrack getReducedVersion(){ 167 return new ReducedFaithTrack(this.faithMarker, Arrays.stream(sections).map(VaticanReportSection::getState).toArray(StateFavorTiles[]::new)); 168 } 169 }


Who we are
Start operating in March 2004 under management of P.T. Samudera Pacific Maju.
With well equipped tools, technology & staff, including IICL certified personnel , we ensure complete container care.
Services available include container depot, reefer, repair & washing, space Availability up to 4500 TEUs, trucking & chassis, reach stacker, side loader, and forklift.
Operations are done 24/7, and full security, including CCTVs around the depot as well as full 24/7 security personnel availability. Extra features include a 296.000 Watts power supply as well as a 147.000 Watts generator.
Vision & Mission
Experience is indeed the best teacher. We believe that in order to provide premium quality services, continuous improvement is a must. That's why we never stop to improve ourselves by learning from decades of experience in order to become Indonesia's most efficient and reliable cargo transportation company. With that vision, we carry a mission to emerge Indonesia as a global trading partner by providing quality International standards services to meet the needs of the world market.


The bulk of the web service documention is built into the ServiceAPI itself however this page gives an overview of how to use the .Net client libraries to connect to the ServiceAPI.
To use the clien libraries install the following two Nuget packages:
The samples repo contains examples of how to use the ServiceAPI Nuget package to builld a client application.


Note: slides may be updated as the course progresses.
Topics: Introductions and course overview. What is Computational Social Science? Introduction to version control and GitHub.
Lazer, D., Pentland, A. S., Adamic, L., Aral, S., Barabasi, A. L., Brewer, D., … & Jebara, T. (2009). Life in the network: the coming age of computational social science. Science, 323(5915), 721-3.
Lazer, D., Hargittai, E., Freelon, D., Gonzalez-Bailon, S., Munger, K., Ognyanova, K., & Radford, J. (2021). Meaningful measures of human society in the twenty-first century. Nature, 1-8.
Grimmer, J. (2015). We are all social scientists now: how big data, machine learning, and causal inference work together. PS: Political Science & Politics, 48(1), 80-83.
Topics: Computational social science: research opportunities and challenges. Ethics of social science research in the digital age. Big data, big bias?
Barberá, P. & and Steinert-Threlkeld, Z. (2020). How to Use Social Media Data for Political Science Research. Curini, L., and Franzese, R. (eds) The SAGE Handbook of Research Methods in Political Science and International Relations, London: Sage, 404-423.
Lazer, D. M., Pentland, A., Watts, D. J., Aral, S., Athey, S., Contractor, N., … & Wagner, C. (2020). Computational social science: Obstacles and opportunities. Science, 369(6507), 1060-1062.
Chapter 6 of Salganik, M. (2017). Bit by Bit: Social Research in the Digital Age. Princeton, NJ: Princeton University Press. Open review edition.
Persily, N., & Tucker, J. A. (2020). Conclusion: The Challenges and Opportunities for Social Media Research. In Social Media and Democracy: The State of the Field, Prospects for Reform, 313-324.
Hargittai, E. (2018). Potential Biases in Big Data: Omitted Voices on Social Media. Social Science Computer Review, forthcoming.
Vlasceanu, M., & Amodio, D. M. (2022). Propagation of Societal Gender Inequality by Internet Search Algorithms. Proceedings of the National Academy of Sciences, 119 (29) e2204529119.
Kramer, A. D., Guillory, J. E., & Hancock, J. T. (2014). Experimental evidence of massive-scale emotional contagion through social networks. Proceedings of the National Academy of Sciences, 111(24), 8788-8790.
Topics: Large-scale online experiments. Data collection: automated data collection from the web.
Bond, R. M., Fariss, C. J., Jones, J. J., Kramer, A. D., Marlow, C., Settle, J. E., & Fowler, J. H. (2012). A 61-million-person experiment in social influence and political mobilization. Nature, 489(7415), 295-298.
King, G., Pan, J., & Roberts, M. E. (2014). Reverse-engineering censorship in China: Randomized experimentation and participant observation. Science, 345(6199), 1251722.
Siegel, A. A., & Badaan, V. (2020).  American Political Science Review, 114(3), 837-855.
Asimovic, N., Nagler, J., Bonneau, R., & Tucker, J. A. (2021). Testing the effects of Facebook usage in an ethnically polarized setting. Proceedings of the National Academy of Sciences, 118(25).
Topics: Introduction to automated text analysis: key concepts; selecting documents and features. Sources of textual data. String manipulation in R. Regular expressions. Text processing with quanteda.
Grimmer, J., Roberts, M. E., & Stewart, B. M. (2022). Text as data: A new framework for machine learning and the social sciences. Princeton University Press. Chapter 2.
Benoit, K. (2020). Text as data: an overview. In Curini, L., and Franzese, R. (eds) The SAGE Handbook of Research Methods in Political Science and International Relations, London: Sage.
Wilkerson, J. and Casas, A. (2017). Large-Scale Computerized Text Analysis in Political Science: Opportunities and Challenges. Annual Review of Political Science, 20, 529:544.
Topics: Describing and comparing textual data.
Grimmer, J., Roberts, M. E., & Stewart, B. M. (2022). Text as data: A new framework for machine learning and the social sciences. Princeton University Press. Chapter 5, 7, and 11.
Denny, M. J., & Spirling, A. (2018). Text preprocessing for unsupervised learning: why it matters, when it misleads, and what to do about it. Political Analysis, 26(2): 168-189.
Carter, E. B., & Carter, B. L. (2021). Questioning More: RT, Outward-Facing Propaganda, and the Post-West World Order. Security Studies, 30(1), 49-78.
Liu, A. H. (2021). Pronoun Usage as a Measure of Power Personalization: A General Theory with Evidence from the Chinese-Speaking World. British Journal of Political Science, 1-18.
Topics: Dictionary methods.
Grimmer, J., Roberts, M. E., & Stewart, B. M. (2022). Text as data: A new framework for machine learning and the social sciences. Princeton University Press. Chapters 15 and 16.
González-Bailón, S., & Paltoglou, G. (2015). Signals of public opinion in online communication: A comparison of methods and data sources. The ANNALS of the American Academy of Political and Social Science, 659(1), 95-107.
Barberá, P., Boydstun, A. E., Linn, S., McMahon, R., & Nagler, J. (2021). Automated text classification of news articles: A practical guide. Political Analysis, 29(1), 19-42.
Engler, S., Gessler, T., Abou-Chadi, T., & Leemann, L. (2022). Democracy challenged: how parties politicize different democratic principles. Journal of European Public Policy, 1-23.
Rathje, S., Van Bavel, J. J., & van der Linden, S. (2021). Out-group animosity drives engagement on social media. Proceedings of the National Academy of Sciences, 118(26).
Tausczik, Y. R., & Pennebaker, J. W. (2010). The psychological meaning of words: LIWC and computerized text analysis methods. Journal of language and social psychology, 29(1), 24-54.
Topics: Supervised machine learning applied to text classification. Crowd-sourcing the creation of training datasets.
Grimmer, J., Roberts, M. E., & Stewart, B. M. (2022). Text as data: A new framework for machine learning and the social sciences. Princeton University Press. Chapters 17, 18, 19, and 20.
Benoit, K., Conway, D., Lauderdale, B. E., Laver, M., & Mikhaylov, S. (2016). Crowd-sourced text analysis: reproducible and agile production of political data. American Political Science Review, 110(2), 278-295.
Theocharis, Y., Barberá, P., Fazekas, Z., & Popa, S. A. (2020). The dynamics of political incivility on Twitter. Sage Open, 10(2),<PHONE_NUMBER>919447.
Mitts, T., Phillips, G., & Walter, B. (2021). Studying the Impact of ISIS Propaganda Campaigns. Journal of Politics, forthcoming. (Read also Appendix.)
Kim, J. Y. (2021). Integrating human and machine coding to measure political issues in ethnic newspaper articles. Journal of Computational Social Science, 1-28.
Eberhardt, M., Facchini, G., & Rueda, V. (2022). Gender Differences in Reference Letters: Evidence from the Economics Job Market. Working paper.
Topics: Unsupervised machine learning (topic models).
Grimmer, J., Roberts, M. E., & Stewart, B. M. (2022). Text as data: A new framework for machine learning and the social sciences. Princeton University Press. Chapters 12 and 13.
Blei, D. M. (2012). Probabilistic topic models. Communications of the ACM, 55(4), 77-84.
Quinn, K. M., Monroe, B. L., Colaresi, M., Crespin, M. H., & Radev, D. R. (2010). How to analyze political attention with minimal assumptions and costs. American Journal of Political Science, 54(1), 209-228.
Barberá, P., Casas, A., Nagler, J., Egan, P. J., Bonneau, R., Jost, J. T., & Tucker, J. A. (2019). Who leads? Who follows? Measuring issue attention and agenda setting by legislators and the mass public using social media data. American Political Science Review, 113(4), 883-901.
Terman, R. (2017). Islamophobia and Media Portrayals of Muslim Women: A Computational Text Analysis of US News Coverage. International Studies Quarterly, 61(2): 489-502.
Motolinia, L. (2021). Electoral Accountability and Particularistic Legislation: Evidence from an Electoral Reform in Mexico. American Political Science Review, 115(1), 97-113.
de Vries, E., Schoonvelde, M. & Schumacher, G. (2018). No Longer Lost in Translation: Evidence that Google Translate Works for Comparative Bag-of-Words Text Applications. Political Analysis, 26(4), 417-430.
Topics: Word embeddings.
Grimmer, J., Roberts, M. E., & Stewart, B. M. (2022). Text as data: A new framework for machine learning and the social sciences. Princeton University Press. Chapter 8.
Rodriguez, P., & Spirling, A. (2021). Word Embeddings: What works, what doesn’t, and how to tell the difference for applied research. Journal of Politics, forthcoming. See also FAQ.
Rodman, E. (2020). A timely intervention: Tracking the changing meanings of political concepts with word vectors. Political Analysis, 28(1), 87-111.
Osnabrügge, M., Hobolt, S. B., & Rodon, T. (2021). Playing to the Gallery: Emotive Rhetoric in Parliaments. American Political Science Review, 1-15.
Card, D., Chang, S., Becker, C., Mendelsohn, J., Voigt, R., Boustan, L., … & Jurafsky, D. (2022). Computational analysis of 140 years of US political speeches reveals more positive but increasingly polarized framing of immigration. Proceedings of the National Academy of Sciences, 119(31), e2120510119.
Yang, E., & Roberts, M. E. (2021). Censorship of Online Encyclopedias: Implications for NLP Models. In Proceedings of the 2021 ACM Conference on Fairness, Accountability, and Transparency (pp. 537-548).
Topics: Basic concepts in social network analysis. Network visualization.
Sinclair, B. (2016). Network Structure and Social Outcomes: Network Analysis for Social Science, in Alvarez, M. (ed.) Computational Social Science. Cambridge: Cambridge University Press. [Full text available through USC libraries]
Chapters 1, 2, and 3 in Easley, D., & Kleinberg, J. (2010). Networks, crowds, and markets. Cambridge University Press.
Steinert-Threlkeld, Z. C. (2017). Spontaneous collective action: Peripheral mobilization during the Arab Spring. American Political Science Review, 111(2), 379-403.
Chetty, R., Jackson, M. O., Kuchler, T., Stroebel, J., et al. (2022). Social capital I: measurement and associations with economic mobility. Nature, 1-14.
Topics: Social contagion processes: homophily vs influence. Collecting social media data.
McPherson, M., Smith-Lovin, L., & Cook, J. M. (2001). Birds of a feather: Homophily in social networks. Annual review of sociology, 27(1), 415-444.
Shalizi, C.R. and Thomas, A. (2011). Homophily and Contagion Are Generically Confounded in Observational Social Network Studies. Sociological Methods & Research, 40(2): 211-239.
Christakis, N. A., & Fowler, J. H. (2007). The spread of obesity in a large social network over 32 years. New England Journal of Medicine, 357, 370-379.
Aral, S., Muchnik, L., & Sundararajan, A. (2009). Distinguishing influence-based contagion from homophily-driven diffusion in dynamic networks. Proceedings of the National Academy of Sciences, 106(51), 21544-21549.
Bakshy, E., Rosenn, I., Marlow, C. and Adamic, L. (2012) The Role of Social Networks in Information Diffusion. ArXiv Preprint: 1201.4145v2
Vosoughi, S., Roy, D., & Aral, S. (2018). The spread of true and false news online. Science, 359(6380), 1146-1151.
Topics: Dimensionality reduction. Latent space network models.
Treier, S., & Jackman, S. (2008). Democracy as a latent variable. American Journal of Political Science, 52(1), 201-217.
Barberá, P. (2014). Birds of the same feather tweet together: Bayesian ideal point estimation using Twitter data. Political Analysis, 23(1), 76-91.
González-Bailón et al (2011). The Dynamics of Protest Recruitment through an Online Network. Nature Scientific Reports, 1: 197.
Topics: Introduction to SQL.
Beaulieu, A. (2009). Learning SQL: Master SQL Fundamentals. O’Reilly Media, Inc.
Stephens, R., Plew, R., & Jones, A. D. (2009). Sams teach yourself SQL in one hour a day. Sams Publishing.
No class: Thanksgiving Holiday.
Topics: Parallel programming with R. Good coding practices


My Name is Yirim (yiddim) Seck work as a hip-hop and visual artist is inspired by exploring the links between arts and sustainability, how artists support other artists in the way of collaborations and contractual services. The discussion in my works is largely centered around artists who are creating alternative incomes in order to further invest in their respected mediums, moving towards becoming living artists and sustaining fully off of their art. I am a Hip-Hop artist and activist of 19 years with a background in the construction trades and social justice, specifically in the green energy sector. Last year I began the process of launching my own contracting company, with the idea of creating a business that serves as a means of supporting my family and community while creating a revenue stream that would allow me to invest in my art, pushing the boundaries of my creativity.
Education
Job History
I am a wordsmith MC whose music both reflects the golden era of hip-hop and holds a roadmap to the future. Not only am I held firm by my roots -- bridging the illustrious musical legacy of Seattle’s Central District and my family’s rich Senegalese heritage -- but propels my insight and drive into a sound and message all-too-relevant for today. Known for his searing lyricism and impassioned performance, Yirim Seck has become one of Seattle’s most well-respected and sought-after MCs. Building on his critically acclaimed debut HEAR ME OUT in 2009, Yirim has performed at venues as diverse as community festivals, upscale nightclubs, college campuses and company parties, connecting with audiences across borders and delivering global discourse through music. My music critiques and calls out shots from the perspective of a dedicated father and community activist, and empowers listeners through storytelling and honest reflection


---
layout: default
---
Summary
I am a design leader with over 7 years of experience both as an individual contributor and a leader. I specialize in working with cross functional groups to ensure user centered design is adhered to by all involved. I love working with multidisciplinary teams to solve complex and difficult problems in elegant and easy to use ways.
Work Experience
Lead UX Designer | Rackspace
October 2017 - Now
I am currently the Lead UX designer for our product design team. I am working on maintaining quality and standards when our team is working across the company. I oversee and provide support for our product designers as they are working through their design process.
Key Responsibilities
- Mentor designers in the design process and consult with key stakeholders throughout the
process
- Review and document projects to inform leadership of progress
- Ensure design consistency and principles are carried out for all products
- Hold bi-weekly sprint reviews with designers and key stakeholders
- Assist with cross-collaboration between products and designers when needed
Accomplishments
- Implemented a design sprint, review, and demo process for all product designers
- Created service blueprints for our support organizations to easily see key processes and how that impacted customer experience
- Evaluated the discover and buy experience using customer experience indexes and heuristic evaluations to identify areas of opportunity
Senior UX Designer | Rackspace
November 2015 - Octobery 2017
In this role, I was responsible for overseeing specified projects that included developing internal tools and enhancing Rackspace’s support capabilities.
Key Responsibilities
- Review and critique design solutions from other designers.
- Ensure all designs were consistent across all projects and utilize our existing framework before going to the developer teams.
- Mentor and assist junior designers to ensure their growth.
- Communicate and work with developers to ensure technical feasibility of design solutions.
- Create, run and analyze user research sessions that included shadowing sessions, usability tests, and user feedback sessions.
- Launched the first consolidated UI that works for all of Rackspace’s customers ticketing back-ends
- Created a consolidated severity and category system that will be used as Rackspace makes the move to ITIL framework
Accomplishments
- Created a system that allowed front-line support to log customer calls. Not only did this combine multiple tools into a single interface, it gave leadership insights they never had before.
- Created a single search to enable employees to easily locate information about customers and employees. This reduced the first point of contact time from five minutes down to under two on average.
- Designed and tested a new interaction model based off the previous global search project. This will increase productivity of employees by providing them a single place to support customers and more context to enable more efficient and accurate support.
UX Designer II | Rackspace
June 2013 - November 2015
My team redesigned all of our support properties and assisted with the main site redesign. Our team consisted of developers, designers and product management.
Key Responsibilities
- Assist with the creation of a new support brand.
- Take the new brand and visual styles and work to implement them across three websites.
- Communicate new designs to all stakeholders.
- Use feedback from stakeholders to ensure the design was what they envisioned.
Accomplishments
- Completely revamped the Rackspace Community site both visuals and page structure for better usability.
- Designed a new ‘Support Drawer’ that went into the public facing control panel.
- Designed a single search across all support documentation sites.
Technical Communication Specialist | Rackspace
January 2012 - June 2013
This job started off being involved with the change release management process, however it was then transitioned into part of a very small team that was responsible for all internal documentation and documentation systems.
Key Responsibilities
- Function as a front-end developer and UX Designer due to small team structure.
- Work with product managers and users to ensure that we were satisfying their needs.
- Come up with unique ideas on sharing knowledge around the company and get tribal knowledge documented.
Accomplishments
- Design and develop internal forum software to capture questions and answers that employees had when we were launching and supporting new products.
- Created a centralized dashboard and page templates for product managers to provide updates to the company on features, bugs and updates.
- Migrated from a legacy wiki into a more robust and modern wiki.
- Was a go-to person around the company for creating and designing documentation for both internal and external consumption.
Relevant Education
University of Texas at San Antonio
Bachelors of Business Administration - Marketing
Graduated 2009
Certifications
Scrum Master Certified - Aug 2019


Buat Account Baru!
Sign Up Form
First name:
Last name:
Gender:
Male
Female
Other
Nationality:
Indonesian
American
Australian
Language Spoken:
Bahasa Indonesia
English
Other
Bio:


| DOSE: |
1.0 g |
insufflated |
Cocaine |
(powder / crystals) |
I was 17 years old when i firsly entered the imaginary world of chemicals. I started with ecxtasy pills, continued with lsd, tried crack, snifed heroin and finally i tried 'the magic dust' as my clubbing friends used to call it...Cocaine.
I remember it was christmas eve 1995. I had taken 2 ecxtasy pills but i still wanted sth more. So my friend elisa's. Had the idea of us trying something different..Cocaine.That was it!! I had just commited the 'biggest crime' of my life.From that moment and on my life had become a battle for finding the coke. I spend any dime i ever got, from my work or parents in purchasing coke.
My friends tried to tell me to slow down but i thought i could control it. My dosage went from 4 lines to 2gr and i lost 20pounds in one month...My hair started to lose its shine, my nails broke easier, my face was like a 30 years old lady. It was terrible until one day i saw one of my best friends die from a stroke provoked my cocaine overdose. That was the beginning of my struggle of rehab. I have been clear for a year now and my life has got a meaning again...
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


_Tarzan_ (G) *** 1/2 (out of ****)
If there were anything in terms of the movie world as certain as death and taxes are in terms of life in general, it's the iron-clad formula for Disney animated features. Tune-heavy musicals ready to be adapted for the Broadway stage, with comic relief broad enough to appeal to wee ones and grown-ups alike and happy endings calibrated for maximum crowdpleasing, The Formula has been sturdy and reliable enough to be worked year after year, like clockwork, to satisfying effect.
Though last year's _Mulan_ put their animation grosses back on the upswing, box office for Disney animated features had been in steadily decline since _The_Lion_King_'s high-water mark in 1994. Factor in the recent raising of the animation ante by DreamWorks's sumptuous epic _The_Prince_of_Egypt_ and to be further elevated, if buzz is to be believed, by the forthcoming _The_Iron_Giant_ from Warner Bros., that Disney formula--as tried-and-true as it is--is looking ripe for reinvention. And that's what the Mouse has done with _Tarzan_, a highly enjoyable adventure that takes risky devations from The Formula--and, for the most part, succeeds.
As can be gleaned from the title, this 37th full-length Disney animated feature is based on Edgar Rice Burroughs's legendary man of the apes (voiced as a child by Alex D. Linz, as an adult by Tony Goldwyn), who was raised by a family of gorillas after his parents were killed when he was an infant. Directors Kevin Lima and Chris Buck memorably cover the backstory--the arrival and settling of Tarzan's parents in the African jungle, their death at the hands (paws?) of a vicious leopard, Tarzan's adoption by gorilla matriarch Kala (Glenn Close)--with an efficient and stunningly animated prologue scored to the rhythmic Phil Collins-penned and -performed tune "Two Worlds." The song effectively conveys the primary theme of the film: that of Tarzan being caught between the world of gorillas and that of humans, a conflict that comes to the forefront when a human expedition team, including the beguiling Jane (Minnie Driver, extremely well-cast), arrives in the jungle.
"Two Worlds" is one of five tunes heard during the course of _Tarzan_, but, unlike nearly all of Disney's animated output, the film is _not_ a musical. It was a daring move, but it was a wise one. Collins's songs function well as an underscore (in terms of music and in terms of the story's themes), and in this story, to have the characters burst into spontaneous song would have simply felt odd--not to mention have been a distraction.
And that's exactly what the film's sole production number, the clumsily integrated "Trashin' the Camp," is--a needless distraction that stands at odds with the rest of the film. The song is a showcase for Tarzan's ape best friend Terk, who is voiced by Broadway's most famous fan, Rosie O'Donnell. As has been widely reported, O'Donnell agreed to do the film only if she were given a song to perform. While her involvement gives _Tarzan_ some negligible marquee name value, it wasn't worth the expense to the film as piece; it not only is out of place, it also stops the film dead in its tracks. Even worse, the number, which (as the song's title implies) has Terk and her pals destroying the humans' camp, is, quite simply, not much fun.
The same can be said for Terk and her elephant pal Tantor (Wayne Knight), the designated comic relief of the film. Plainly said, they just aren't very funny; their phoned-in small guy/big oaf routine is a poor man's imitation of _The_Lion_King_'s classic comic team of Timon and Pumbaa. I cannot think of any good reason for there to be any comic relief in _Tarzan_ other than to make a safe concession to The Formula. Surely Lima, Buck, and screenwriters Tab Murphy, Bob Tzudiker, and Noni White could have seen that there is enough situational comedy built into the story, as clearly evidenced by the hilariously, adorably awkward first meeting between Tarzan and Jane and the refined Jane's clumsiness in the wild forest.
The forest is indeed wild--and wonderfully alive--in the hands of Lima and Buck, for _Tarzan_ signals another advancement for Disney in the visual arts. _Tarzan_ is by far the most inventive Disney effort in terms of animation; the aforementioned opening is a wonder in and out of context, and with none of the restrictions present in the flesh-and-blood world, the exhilarating abandon of Tarzan's vineswinging can truly be captured in its high-flying glory. Because of the interspecies language divide, _Tarzan_ is highly dependent on facial expressions, which the animation crew has refined to an even greater level of precision than previously seen in Disney films.
I wouldn't rank _Tarzan_ among the very best of the recent Disney animation crop, but for all its shortcomings, it is still family entertainment of the highest order, with great appeal to both kids and adults. It also represents a crucial turning point for the Mouse's animation house: a brave step away from The Formula and toward a new, more varied direction for the new millennium.
Michael Dequina
<EMAIL_ADDRESS>|<EMAIL_ADDRESS>Mr. Brown's Movie Site: http://welcome.to/mrbrown
CompuServe Hollywood Hotline: http://www.HollywoodHotline.com
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