--- layout: post title: Fedora/Windows date: 2016-03-15 13:24:34.000000000 +00:00 type: post published: true status: publish categories: - hardware tags: - asus - asusux305 - bios - boot - distribution - fedora23 - linux meta: _edit_last: '1' _wpas_done_all: '1' author: email<EMAIL_ADDRESS>display_name: natseg ---
Today, I will publish details about my personal life.
When my desktop computer sadly passed away June last year, I decided to make the big jump.
Jump into the land of laptop gamers that is.
I had never felt the need or wish to before.
Always thought a desktop left you with the choice to easily upgrade whenever the need arose.
Except, I rarely never got around doing it. Moving to a tiny doubleroom in Central London also made me realize the benefits of owning a laptop.
I use my computer for various purposes - including gaming which did put a minimum configuration and thus price tag on my buy:
MSI GT72 2QE (Dominator Pro)-682UK
Intel® Core™ i7-4720HQ Quad Core Processor
17.3" Full HD Screen, Microsoft Windows 8.1 64-bit, 16GB DDR3 RAM, 128GB SSD + 1000GB HDD, DVD Rewriter, Dedicated GeForce GTX 980M 4GB Graphics, USB3 | HDMI | Bluetooth | DisplayPort, 2 Year MSI Warranty, 9S7-178131-682
I weighed the best value and my focus was mainly - along with a nice graphic card and processor - on getting as much SSD and RAM as possible. Just before it hits the mark where it becomes incredibly costly.
Now, I quickly realized that this 7kg beast of a 'laptop' really is a desktop replacement. As in your laps need to be a desk to feel comfortable about cuddling it.
Coding on the go was thus a big no no. Trust me, being stubborn, I tried.
Months later, I also sized down my phablet to a more normal phone.
All this led me to welcoming a new device into the family (of devices).
After discussing hardware with work colleagues, my heart - heavily guided by my brain - turned to this alternative to a MacBook Air (cheaper):
ASUS Zenbook UX305 13.3" Laptop - White
Here are its specifications:
Processor: Dual-Core Intel Core M-5Y10c,
RAM: 8GB, Size: 324x226x12mm,
Weight: 1.2kg,
Screen size: 13.3 inches,
Screen resolution: 1,920x1,080
Graphics adaptor: Intel HD 5300
Total storage: 128GB SSD
It's quick, light, sleek.
The screen resolution could be better - it is in fact better on later models (3200 x 1800, processor has been upgraded too).
Quality was enough for my needs.
Then I thought, 'hold on, I don't want another Windows and I could do with some experience fiddling with a Linux distribution'.
Yes, for the record, I think like that. S
omeone said the magic word! DUALBOOT - when you can choose to boot on Windows or Linux.
I knew what it meant, just never had used it or set it up.
New==shiny so I tried.
After that I had to make a choice, between the linux distros out there.
After discussing the matter with my privy council, I knew I had to choose between Debian and Fedora.
I went for Fedora (23). My main reasons:
- they are early adopters
- my affinity with software/frameworks used by Fedora backer
I had to get my hands dirty and just move on to install.
I generally prefer formatting my devices to avoid any unnecessary issue.
I wiped my usb drive clean and followed the guide below:
Windows quick start (direct write)
This method will destroy all data on the USB stick.
Download a Fedora image, choose a USB stick that does not contain any data you need, and connect it.
Download and run Rawrite32.
Choose the Fedora image as the Filesystem image (Rawrite32) - if the image file is not shown, you may have to change the file selector options or change the image's extension.
Choose the USB stick in the drop-down box as the Target (Rawrite32).
Double-check you're really, really sure you don't need any of the data on the USB stick!
Click Write to disk... (Rawrite32).
Wait for the operation to complete, then reboot your computer.
Do whatever you need to do to boot from a USB stick - often this will involve pressing or holding down F12, F2 or Del.
On the ASUS Zenbook UX305 here is what you have to do:
- restart computer
- press escape key quickly as computer restarts
- navigate to Security Tab:
- then to Secure Boot Menu:
Disable this control to enable booting via your usb key.
This setting is supposed to help protect against rootkits and other malware infecting the boot loader.
Once the comp boots on the usb where the image has been written, it's a matter of following fedora's instructions and clicking 'Next'.
Tadam!


Reason to have a website for every business
Why every business need a website ? Why i need a website ? Can I grow my biz without having Website ? should i go for a website for small business ? Why Every Business need a Website?These questions are answered in this video given below it will clear your all doubts regarding website.
There are some important points about having website which are mentioned in this video.
1. Your customers expect it.
When you have a business with lot of clients then definitely many of clients have asked you about your business website an when you don't have one your reaction must be like "ummm... sorry i don't have one". Sometime these type of questions create embarrassing situations when a well known business doesn't have a website. So, to avoid these situation everyone should have a business website even your business is large or on small scale.
2. It provides social proof.
Website is a social proof for your business it contains your all social links (facebook, twitter, linkedin, youtube and more) where your business history and many things that clients should know are given.
3. Your competitors all have company websites.
In Digital world there is a lot of business earn online and almost all type businesses have competitors. We know if we want to grow more than our competitors we have to do something better then them and having a website is a great initiative. A website explains your business and attract new customers so, what are you waiting for hurry up and get a website before your competitors have one.
4.You’ll shown up in Google search results.
When a business or a company name shows in google search results then it gives great impact to your new customers when they search for products or services which your business have. Google results always helps you to get more customers and there is no need to tell how it will ? .
5. It showcase your products and services.
Whenever a business add new products or service in their listing they have to update their old customers about it and they also need to promote new products to get more customers via social media, online ads, tv ads etc. but when you have a website there is only need to update your product listing on your website.
6. It’s all your information in one place.
A website contain about section which tell viewers about what is your business about what is your dealing criteria and how you deliver your services and goods. Here you can also mention about your company's history your team/staff and carrier opportunities.
7. Tell customer who and where you are.
Your website help to reach your customer to you by providing contact and contacting person's info. you can also add a map to your website's page to gave proper direction of your office address.
8. It attract new customers.
From these seven points its clear that a website help to gain more customers and how a website helps to give a boost on growth of your business.
So, have a business website to boost your business growth and join the revolution of this digital world.


{% extends "nominations_portal.html" %} {% load bootstrap3 crispy_forms_tags django_bootstrap_breadcrumbs nominations_tags %} {% crispy form form.helper %} {% block page_title %}Our Revolution - Nominate a Candidate{% endblock %} {% block breadcrumbs %} {{ block.super }} {% breadcrumb "Start Application" "nominations-application-create" %} {% endblock %} {% block content %} {{ block.super }}
To start a new candidate endorsement application, you’ll need some basic information about your group and contact information for one group representative.
As an official Our Revolution Group, you are in the unique position of nominating candidates for a National Our Revolution endorsement. Throughout your process, the core Our Revolution values of democracy and inclusivity are fully embraced.
By submitting this nomination, your Our Revolution Group guarantees that:


Recon 2.2
Recon 2.2: from reconstruction to model of human metabolism.Swainston N, et al.
Metabolomics 2016, 12:109.
Recon 2
A community-driven global reconstruction of human metabolism.Thiele I, Swainston N, et al.
Nat Biotechnol. 2013, 31:419-25.
Yeast consensus model
A consensus yeast metabolic network reconstruction obtained from a community approach to systems biology.Herrgård MJ, Swainston N, et al.
Nat Biotechnol. 2008, 26:1155-60.
path2models
Path2Models: large-scale generation of computational models from biochemical pathway maps.Büchel F, Rodriguez N, Swainston N, Wrzodek C, et al.
BMC Syst Biol. 2013, 7:116.
Yeast glycolysis
A model of yeast glycolysis based on a consistent kinetic characterisation of all its enzymes.Smallbone K, et al.
FEBS Lett. 2013, 587:2832-41.


Marissa Adams
About
(current)
Portfolio
(current)
Contact
(current)
Be Healthy App
GitHub Pages Link
GitHub Repo Link
Weather Dashboard
GitHub Pages Link
GitHub Repo Link
Workday Scheduler
GitHub Pages Link
GitHub Repo Link
Forget Me Not App
Heroku Link
GitHub Repo Link
Employee Management System
GitHub Pages Link
GitHub Repo Link
Forget Me Not App
Heroku Link
GitHub Repo Link


| Company Name | Ticker | Sector | # of owners | Market Value | Shares held | Change in Shares | Largest Holder |
|---|---|---|---|---|---|---|---|
| 111111111{{buy.companyName}} | {{buy.ticker}} | {{buy.sector}} | {{buy.numFilers}} | {{buy.sumMarketValue}} | {{buy.sumPrincipalAmount}} | {{buy.sumChangeInShares}} | {{buy.largestHolder}} |
| {{sell.companyName}} | {{sell.ticker}} | {{sell.sector}} | {{sell.numFilers}} | {{sell.sumMarketValue}} | {{sell.sumPrincipalAmount}} | {{sell.sumChangeInShares}} | {{sell.largestHolder}} |


Dashboard Navigation
user name
Dashboard
Edit Profile
Enrolled Course
Change Password
Logout
Edit profile
Enrolled course
Change Password


RenderLayer
Direct Subclass:
Abstract base class for managing and rendering buffers pertaining to a render layer, ie. the base geometries always visible vs. the dynamically visible tiles based on camera orientation.
Static Method Summary
| Static Public Methods | ||
| public static |
calculateBytesUsed(settings: *, nrVertices: *, nrColors: *, nrIndices: *, nrNormals: *): * |
Constructor Summary
| Public Constructor | ||
| public |
|
Member Summary
| Public Members | ||
| public |
|
|
| public |
|
|
| public |
|
|
| public |
gl: * |
|
| public |
|
|
| public |
loaders: * |
|
| public |
|
|
| public |
settings: * |
|
| public |
viewer: * |
Method Summary
| Public Methods | ||
| public |
addCompleteBuffer(buffer: *, gpuBufferManager: *): * Add a buffer that is already prepared |
|
| public |
addGeometry(loaderId: *, geometry: *, object: *, buffer: *, sizes: *) |
|
| public |
addGeometryReusable(geometry: *, loader: *, gpuBufferManager: *) |
|
| public |
addGeometryToObject(geometryId: *, objectId: *, loader: *, gpuBufferManager: *) |
|
| public |
createGeometry(loaderId: *, roid: *, croid: *, geometryId: *, positions: *, normals: *, colors: *, color: *, indices: *, hasTransparency: *, reused: *): * |
|
| public |
createObject(loaderId: *, roid: *, oid: *, objectId: *, geometryIds: *, matrix: *, normalMatrix: *, scaleMatrix: *, hasTransparency: *, type: *, aabb: *, gpuBufferManager: *, node: *): * |
|
| public |
flushBuffer(buffer: *, gpuBufferManager: *): * |
|
| public |
getLoader(loaderId: *): * |
|
| public |
getObject(loaderId: *, identifier: *): * |
|
| public |
|
|
| public |
registerLoader(loaderId: *) |
|
| public |
removeLoader(loaderId: *) |
|
| public |
render(transparency: *, visibleElements: *) |
|
| public |
renderBuffer(buffer: *, programInfo: *, visibleElements: *) |
|
| public |
renderBuffers(transparency: *, reuse: *) |
|
| public |
renderFinalBuffers(buffers: *, programInfo: *, visibleElements: *) |
|
| public |
renderSelectionOutlines(ids: *, width: *, node: *) |
|
| public |
storeMissingGeometry(geometryLoader: *, map: *) |
Static Public Methods
public static calculateBytesUsed(settings: *, nrVertices: *, nrColors: *, nrIndices: *, nrNormals: *): * source
Params:
| Name | Type | Attribute | Description |
| settings | * | ||
| nrVertices | * | ||
| nrColors | * | ||
| nrIndices | * | ||
| nrNormals | * |
Return:
| * |
Public Constructors
public constructor() source
Public Members
public bufferTransformer: * source
public geometryCache: * source
public geometryDataToReuse: * source
public gl: * source
public instanceSelectionData: * source
public loaders: * source
public previousInstanceVisibilityState: * source
public settings: * source
public viewer: * source
Public Methods
public addCompleteBuffer(buffer: *, gpuBufferManager: *): * source
Add a buffer that is already prepared
Params:
| Name | Type | Attribute | Description |
| buffer | * | ||
| gpuBufferManager | * |
Return:
| * |
public addGeometry(loaderId: *, geometry: *, object: *, buffer: *, sizes: *) source
Params:
| Name | Type | Attribute | Description |
| loaderId | * | ||
| geometry | * | ||
| object | * | ||
| buffer | * | ||
| sizes | * |
public addGeometryReusable(geometry: *, loader: *, gpuBufferManager: *) source
Params:
| Name | Type | Attribute | Description |
| geometry | * | ||
| loader | * | ||
| gpuBufferManager | * |
public addGeometryToObject(geometryId: *, objectId: *, loader: *, gpuBufferManager: *) source
Params:
| Name | Type | Attribute | Description |
| geometryId | * | ||
| objectId | * | ||
| loader | * | ||
| gpuBufferManager | * |
public createGeometry(loaderId: *, roid: *, croid: *, geometryId: *, positions: *, normals: *, colors: *, color: *, indices: *, hasTransparency: *, reused: *): * source
Params:
| Name | Type | Attribute | Description |
| loaderId | * | ||
| roid | * | ||
| croid | * | ||
| geometryId | * | ||
| positions | * | ||
| normals | * | ||
| colors | * | ||
| color | * | ||
| indices | * | ||
| hasTransparency | * | ||
| reused | * |
Return:
| * |
public createObject(loaderId: *, roid: *, oid: *, objectId: *, geometryIds: *, matrix: *, normalMatrix: *, scaleMatrix: *, hasTransparency: *, type: *, aabb: *, gpuBufferManager: *, node: *): * source
Params:
| Name | Type | Attribute | Description |
| loaderId | * | ||
| roid | * | ||
| oid | * | ||
| objectId | * | ||
| geometryIds | * | ||
| matrix | * | ||
| normalMatrix | * | ||
| scaleMatrix | * | ||
| hasTransparency | * | ||
| type | * | ||
| aabb | * | ||
| gpuBufferManager | * | ||
| node | * |
Return:
| * |
public flushBuffer(buffer: *, gpuBufferManager: *): * source
Params:
| Name | Type | Attribute | Description |
| buffer | * | ||
| gpuBufferManager | * |
Return:
| * |
public getObject(loaderId: *, identifier: *): * source
Params:
| Name | Type | Attribute | Description |
| loaderId | * | ||
| identifier | * |
Return:
| * |
public prepareRender() source
public registerLoader(loaderId: *) source
Params:
| Name | Type | Attribute | Description |
| loaderId | * |
public removeLoader(loaderId: *) source
Params:
| Name | Type | Attribute | Description |
| loaderId | * |
public render(transparency: *, visibleElements: *) source
Params:
| Name | Type | Attribute | Description |
| transparency | * | ||
| visibleElements | * |
public renderBuffer(buffer: *, programInfo: *, visibleElements: *) source
Params:
| Name | Type | Attribute | Description |
| buffer | * | ||
| programInfo | * | ||
| visibleElements | * |
public renderBuffers(transparency: *, reuse: *) source
Params:
| Name | Type | Attribute | Description |
| transparency | * | ||
| reuse | * |
public renderFinalBuffers(buffers: *, programInfo: *, visibleElements: *) source
Params:
| Name | Type | Attribute | Description |
| buffers | * | ||
| programInfo | * | ||
| visibleElements | * |
public renderSelectionOutlines(ids: *, width: *, node: *) source
Params:
| Name | Type | Attribute | Description |
| ids | * | ||
| width | * | ||
| node | * |
public storeMissingGeometry(geometryLoader: *, map: *) source
Params:
| Name | Type | Attribute | Description |
| geometryLoader | * | ||
| map | * |


Royal Mint unveils £5,000 coin the size of a dinner plate
The UK’s largest ever coin has been released and it is big enough to serve your dinner on.
Royal Mint has today unveiled its 5 kilo record-breaking coin, weighing an incredible 5 kilos and is worth £5,000.
Made from alloy 999 Au Fine Gold, the impressive coin weighs 5010.00g with a diameter of 175mm, and one of them has already been bought for an undisclosed amount.
It is part of a new ‘Great Engravers’ series, that celebrates artists who have worked on British coinage and begins with Royal Academician William Wyon’s Una And The Lion design.
Wyon was the chief engraver at the Royal Mint from 1828 until his death in 1851 and was most famous for his coin and medal portraits of Queen Victoria.
He is also well-known for his design of Una And The Lion, considered by collectors as one of the world’s most beautiful coins.
Advertisement Advertisement
The collection also includes a smaller, 2 kilo coin, which will have a mintage of just four, while the smaller coins will be sold for £119,950.
To create the new giant coin, a combination of traditional engraving methods and modern techniques were applied, such as lasers being used to carefully cut the design before it was hand-polished.
The original die used almost 200 years ago had to be digitally scanned and chief engraver Gordon Summers ensured the relief was accurately reproduced.
Nicola Howell, director of the consumer division at The Royal Mint said: ‘The Great Engravers series celebrates some of the finest artists that have worked on British coinage and we are thrilled to start the series with William Wyon’s Una And The Lion design.
‘This is arguably one of the most admired designs amongst coin collectors across the globe, and remastering it onto five and two-kilo coins allows you to truly appreciate the detail of the design.’
Got a story for Metro.co.uk?
Get in touch with our news team by emailing us at<EMAIL_ADDRESS>For more stories like this, check our news page.


We sell boots, dividing our products into two groups: Short boots and Long boots. Different colors, different sizes...it's right here for you.


Pacific fends off Coppin St. for its third consecutive win
by The Associated PressFOREST GROVE, Ore. (AP) — Jahlil Tripp scored 21 points with 13 rebounds and Pacific held off a furious second half Coppin State rally for a 64-60 win on Tuesday night.
The Tigers improved to 5-2 with their third straight win.
Pacific led 25-15 at intermission before the Eagles proceeded to outscore the Tigers 26-17 in an 11½-minute span and trailed 42-41 on Koby Thomas’ layup with 8:21 remaining. Dejuan Clayton’s layup for Coppin State reduced its deficit to 62-59 with 37 seconds to go. Thomas made 1 of 2 free throws with 14 second left, but Justin Moore sealed it when he threw down a dunk with 10 seconds left for the game’s final margin.
Justin Moore scored 16 points for Pacific and Amari McCray scored 10 with nine rebounds.
Clayton lead Coppin State (1-5) with 21 points and Thomas and Andrew Robinson each scored 10. The Eagles now have dropped three straight.
___
For more AP college basketball coverage: https://apnews.com/Collegebasketball and http://twitter.com/AP_Top25
The Associated Press


Three mains things I have learned and understood more about them, and I believe they will affect my life in different ways.
Growth mindset - learning the concept of growth mindset and reading the relative articles online has opened up my mind on how to see difficulties or failure, it fundamentally changed some of my thoughts like "you wouldn't learn much when you are older and different people good at different things, it is hard to learn things that you are not good at them", now I understand that our brain is growable, the pathway in our brain that connected our brain cells will be thicker and strengthen if we keep practicing on it, so we can be better and learn new knowledges now matter how old we are; we can be better as long as we never give up. All of these thoughts will definitely help me to learn the skills of dealing with frustration and disappointments in the future.
Core learing journey in Foundations has been awesome experience to me, it not only taught me how to train myself on self-manangment including time management, plan well before I start, it also taught me to understand my strengthes and limitations, to understand my emotions, the way to improve my EQ, how to balance my body and my emotion, to practice my brain to be growth mindset, to believe in myself that I can be better.


attend The International Conference, Jeju, South Korea.
2017.08.23 ~ 28
SMMCLab members attend The International Conference on Big data, IoT, and Cloud Computing (BIC-17) and participated in the Membership Training, Jeju, South Korea.
--- layout: index title: News group: navigation tags : [blog, posts, post] author : Pakyoungno css: js: keywords: bootstrap4, UI kit, jekyll canonical: https://pakyoungno.github.io/News --- {% include JB/setup %}
SMMCLab members attend The International Conference on Big data, IoT, and Cloud Computing (BIC-17) and participated in the Membership Training, Jeju, South Korea.


var onChainErrorListener: ((Int, Int) -> Any)?
Callbaqck for reorgs. This callback is invoked when validation fails with the height at which an error was found and the lower bound to which the data will rewind, at most.


{% extends "layout.html" %} {% block page_title %} GOV.UK prototype kit {% endblock %} {% block content %} Select address Select address {% for i in range(1, 11) -%} {{i}} Union Road, New Mills, High Peak, SK22 4QP {% endfor %} None of these are my address {% endblock %}


What is CD?
Continuous Delivery (CD) is about the ability to be Agile in the extreme. Time between code is passed into the version
control system (VCS) to be deployed into production that is not years, months or weeks. At best, it is not even days
but rather it is in hours or minutes.
At first glance CD may seem dangerous and unreachable. But the fact is that big companies
like Facebook, Google and Etsy have been doing CD for many years, so it is absolutely doable for small businesses, as well as
for large ones.
Achieving CD eliminates the biggest problems with waterfall projects.
- Inability to change direction (being agile)
- Long QA feedback loop
- Lack of collaboration
1. In projects doing CD the engineer submits code and tests into VCS. The code has been tested locally and also
reviewed by a co-engineer. Note the submitter is not called a developer because it could just as well be a person
with special skills in testing or management.
2. The Continuous Integration (CI) server triggers a series of automated builds, tests and deploys. This process
is often referred to as the Deployment Pipeline. Automation is the key. No manual fingers do anything...
all the way to the production deploy. This automation is cheap so it will constantly be executed for all of the related changes
being made into the VCS.
3. The engineer loves what she is doing. She wants her users to be happy. So a very crucial part of her work is monitoring the
production servers. If a daily deploy seems to change any of the normal metrics like page loads, network traffic or cpu-usage, the engineer
will act on that.
Notice
The above things absolutely cannot be done without the proper safety measures.
For information on those practices please read
How to do CD?


REVIEW / December 20, 2020
To mark the first UK show of artist Henri Barande, graphic designer Pavel Murren and German studio Schultz have created The Lodge Wooden.
"But I must explain to you how all this mistaken idea of denouncing pleasure and praising pain was born and I will give you a complete account of the system, and expound the actual teachings of the great explorer of the truth, the master-builder of human happiness. No one rejects, dislikes, or avoids pleasure itself, because it is pleasure, but because those who do not know how to pursue pleasure rationally encounter consequences that are extremely painful.
Nor again is there anyone who loves or pursues or desires to obtain pain of itself, because it is pain, but because occasionally circumstances occur in which toil and pain can procure him some great pleasure.
The short answer is yes. According to Kross, whe yoy think of yourself as another person, it allows you give yourself mor objetve, helpful feedback.
But who has any right to find fault with a man who chooses to enjoy a pleasure that has no annoying consequences, or one who avoids a pain that produces no resultant pleasure?".
On the other hand, we denounce with righteous indignation and dislike men who are so beguiled and demoralized.


{% extends 'sheltownstafflogin/StaffLoginBase.html' %} {% block title %}Rental Properties Owners Details{% endblock title %} {% block body %} Home Rental Properties Owner Select Owner to change Download Details Add New Owner


Stop Procrastinating is a FireFox browser extension that limits the amount of time you can spend on certain websites.
Everyday, millions of tasks are delayed by the ever-so-enticing plague that is procrastination.
Despite people's aches for producitivty, they end up entranced by the endless gamut of distractions that the internet has to offer.
No but seriously...
Students nowadays often struggle more than ever trying to stay focused whilst completing schoolwork on a computer. Students can hardly resist the temptation of a scroll down Twitter, a quick playthrough of a Flash game (even though Flash is dead), or an enriching viewing of Minecraft Let's Play: Episode 2763.
There's a fantastic TED Talk on procrastination if you want to learn more about it.
Procrastination has become especially problematic since the beginning of the COVID-19 pandemic because virtual learning done solely on a computer has become more prevalent than ever.
Stop Procrastination hopes to help combat this by allowing you to set a time limit on certain user-defined websites so you don't spend hours on end procrastination on your schoolwork.
If you find Stop Procrastinating useful, please tell your friends about it (even your imaginary ones).
What the h*ck?
This project was made for the NotUniversity Hacks hackathon.
Why no Chrome extension?
If you're still using Chrome, you deserve to fail on that paper.
Is it free?
Yep.
Can I have the source code?
Who are you?
Three professional procrastinators who code sometimes.


§44. Enacting clause-English language. That the enacting clause of all laws be, "Be it enacted by the legislature of the Territory of Hawaii."
All legislative proceedings shall be conducted in the English language.
Whether joint resolution without this enacting clause may have force of law, see message of governor to legislature relating to House J.R. No. 8, session of 1911. Referred to in 16 H. 245.
Law Journals and Reviews
"Language Is Never About Language": Eliminating Language Bias in Federal Education Law to Further Indigenous Rights. 37 UH L. Rev. 381 (2015).


JavaScript is disabled on your browser.
Skip navigation links
Overview
Package
Class
Tree
Deprecated
Index
Help
Prev Letter
Next Letter
Frames
No Frames
All Classes
A
C
D
E
F
G
I
L
M
N
P
R
S
T
V
C
com.myself
- package com.myself
com.myself.Entity
- package com.myself.Entity
com.myself.Exception
- package com.myself.Exception
com.myself.factory
- package com.myself.factory
com.myself.service
- package com.myself.service
com.myself.util
- package com.myself.util
CONFERENCE_DAYS
- Static variable in class com.myself.util.
ConstantsUtil
ConstantsUtil
- Class in
com.myself.util
Constants
ConstantsUtil()
- Constructor for class com.myself.util.
ConstantsUtil
cutTime(String)
- Method in class com.myself.service.
ScheduleTalks
extract string time to end of line
A
C
D
E
F
G
I
L
M
N
P
R
S
T
V
Skip navigation links
Overview
Package
Class
Tree
Deprecated
Index
Help
Prev Letter
Next Letter
Frames
No Frames
All Classes


public class FinanceTypesKt
| Modifier and Type | Method and Description |
|---|---|
static int |
calculateDaysBetween(java.time.LocalDate startDate,
java.time.LocalDate endDate,
DayCountBasisYear dcbYear,
DayCountBasisDay dcbDay) |
static boolean |
isWorkingDay(java.time.LocalDate $receiver,
BusinessCalendar accordingToCalendar) |
static <T> Amount<T> |
sumOrNull(java.lang.Iterable<net.corda.core.contracts.Amount> $receiver) |
static <T> Amount<T> |
sumOrThrow(java.lang.Iterable<net.corda.core.contracts.Amount> $receiver) |
static <T> Amount<T> |
sumOrZero(java.lang.Iterable<net.corda.core.contracts.Amount> $receiver,
T currency) |
static java.math.BigDecimal |
toDecimal(Amount<java.util.Currency> $receiver)
Convert a currency
class Amount to a decimal representation. For example, with an amount with a quantity
of "1234" GBP, returns "12.34". |
public static java.math.BigDecimal toDecimal(Amount<java.util.Currency> $receiver)
Convert a currency class Amount
to a decimal representation. For example, with an amount with a quantity
of "1234" GBP, returns "12.34".
class Amount
public static <T> Amount<T> sumOrNull(java.lang.Iterable<net.corda.core.contracts.Amount> $receiver)
public static <T> Amount<T> sumOrThrow(java.lang.Iterable<net.corda.core.contracts.Amount> $receiver)
public static <T> Amount<T> sumOrZero(java.lang.Iterable<net.corda.core.contracts.Amount> $receiver, T currency)
public static boolean isWorkingDay(java.time.LocalDate $receiver, BusinessCalendar accordingToCalendar)
public static int calculateDaysBetween(java.time.LocalDate startDate, java.time.LocalDate endDate, DayCountBasisYear dcbYear, DayCountBasisDay dcbDay)


Saturday, after waking up and eating a delicious breakfast made by Z's mom, R and I drove back to my house.  We were chilling, talking about things, and then I remembered I had 2c-e, 2c-i, and 2c-t-2 that my friend C had sent me a month or so ago. I had been reading up on them, especially 2c-e, but was too scared to try it by myself. To this, R readily said, 'Let's take it, we don't have anything else to do today'. I was more than happy to oblige. Though a little nervous, I got 2 glasses of water, into which we mixed the 2c-e and cool aid, and we drank them. I can't report on times, because time moved both incredibly slow and fast at the same time, and I had no idea where it went while on 2c-e.
After taking it, we walked around the house waiting for it to kick in. It took about an hour, but the first signs that something was different for me was that I was looking at a cowboy hat on my living room table, and all of a sudden I could see every stitch on it. Not only could I SEE the stitch, though, but the patterns were moving! They were morphing. One segment would get lighter, like my eyes had sliders for brightness and contrast, and just by thinking, I could change one or both of them. It was scary; I wasn't ready for it. So I looked away, at a picture I took in Israel of a bird flying over a bench and chair.
As I was looking at it, I could see the mountains clearly in the background, I closed my eyes and could smell the way the air was. Then I noticed, when my eyes were closed, that I was able to still see things in my mind's eye. It didn't matter what my physical eyes were doing, because I could see things no matter what. Nothing I could do would make that change. I saw red, green, and blue the most vividly. They were outlining things that didn't exist except in the blackness behind my eyelids. The images were beautiful, peaceful, and dancing with my mind. Sometimes I would see faces, or shapes. All the colors that made up light were shattered into their individual constituents upon reaching my eyes.
But then I opened them again. I had to go to the bathroom from drinking all the water initially. As I was urinating, I looked at the wall I had seen hundreds of times prior to that moment. This time was different, though-- The minute patterning in the wallpaper was MORPHING. Morphing! There is no other word to explain it. Not even on mushrooms did I get such amazing shape-shifting and tonal-changing. Think of one pattern, and then having those contrast sliders in your mind changed, and then all of a sudden you can see deeper; more vividly; into what the creator of that wallpaper was trying to say. Someone created the intricate patterning on it, they probably devoted a lot of time to it, and now here I was, able to fully comprehend and appreciate the beauty of it.
We had to go outside. It was rainy, cold, what some would call miserable outside. I had to be out in nature though. The sun was setting, so it was probably around 5 or 6pm. R and I took off our shoes and socks, put on hats and coats, and walked outside. The INSTANT I walked outside, I became aware of my brain altering the levels of black and white, adjusting my perception to 'outside vision'. It was beautiful the way I was able to see my mind at work - feeling that I was a part of the system, and knowing that all I was able to do was to observe. We walked around outside, loving nature and feeling as though she (nature) was filling me up with love, allowing me to see the true beauty and infinite complexity that humans will never understand. We played in the mud, and saw amazing morphing patterns in it.
Back inside, we flew on magic carpets (shuffling our feet on my blankets) up to the bathroom. There, we got mud all in the bathtub as we rinsed our feet off. The mud made gorgeous fractals in the bathtub, which also kept morphing in front of our eyes, showing us different things with every millisecond. Contrast going up, seeing intense shades of white and brown and yellow, and then contrast going way down, and seeing everything come together as one. So we left the mud be for then.
The trip was also very location dependent. The ambience of one room, where STS9 was playing loudly with whiteish-blue light coming in the windows was far different than the next room over, which was filled with the essence of slightly quieter music and red light coming through the red blinds. The purple blinds in my living room created yet a different ambience, which my brain registered and reflected in its mood.
Often, I would find myself getting anxious. I said to R that I had an itch I just couldn't scratch - it was like the feeling of being right on the edge of yawning but never having the yawn come. When this happened, as it did several times throughout the trip, I started feeling nauseous, though I never threw up thanks to ondansatron (Zofran) I had taken at the beginning of the trip. Any time I felt nauseous, or negative vibes came over me, all I had to do was walk upstairs, change the song, or walk outside/into a differently lit room, and I would feel beautifully warm again.
In my house, there are two cats, and we just kept wondering about them and playing with them. The patterns in their fur was exquisitely mind-blowing. Indescribable. The cats just walk around all day observing things. I have no way of knowing what their consciousness is like, but we tossed around the idea that maybe they were seeing things like this all the time, and that's why they love strings, hanging things, and just staring at patterns. What a great life it is to be a loved cat.
The trip lasted about 7 hours until I fell asleep with the help of an Ambien and a lot of marijuana. Coming down from this trip was very hard. I think I had more trouble when coming off my first mushroom trip, but this was a close second as far as difficult/uncomfortable comedowns go. I had terrible anxiety, was very indecisive for a while, and had horrible bodily discomfort. I felt expansive - like my brain, with everything it learned, was trying to squeeze back into a tiny little skull, but it wasn't fitting as well as it used to. R and I smoked some herb, and I took some Valerian Root extract.
After that, things calmed down enough for me to sit down and watch the movie Baraka. About an hour into it, I had to go lay down in my bed. So R and I said good night, he slept downstairs on the couch, and I went up to my bedroom. I took an Ambien and laid in bed waiting for it to kick in. There were thoughts of 'will I ever be the same again?' and 'How will I possibly explain this to anyone?' But today, waking up to a beautiful day out, I realized that part of the amazing thing about this life is that there is SO much to experience that I can just keep living. I experienced a fantastic voyage, and gained much knowledge about myself and Life as humans can know it.
There are many parts of this trip that I have yet to process. My mind moved so fast and learned/observed so much that I could not possibly write everything here right now. That would take months at the least. I like 2C-E because it allowed me to discover more about myself and Life. I think I will always take this drug with a friend, and walk around and be in nature at least for part of it. So an empty house or a camping trip would be ideal for 2C-E, in my opinion.
Theme of this trip:
Life is infinitely weirder than it wants us to believe.
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.


Over the last couple of years an amazing transformation has happened in the federal, and even state-level, government with regards to technology. The much need arrival of United States Digital Service and 18F have brought with it modern development and management methods such as AGILE. It has been amazing to watch these folks use open sources tools, and modern methodologies to create deeply needed and truly functional web tools, in the open. It has motivated me to attempt drag myself and my organization into the same league with them, and to make ourselves more attractive to federal work.
To that end, I decided to try and get myself educated on Agile, and with much less effort than I thought, I'm able to say that I am a Certified Scrum Master. So if you need any scrums mastered, you know, let me know.
Now comes the hard part, trying to implement Agile into a 30-year-old organization, with very entrenched behaviors. Wish me luck.
I'm Jeff Coburn, I lead Web Services at the School for Global Inclusion and the Institute for Community Inclusion (located at the University of Massachusetts Boston). I do some developement, a little design, but if I'm honest with myself, I spend a lot of time planning things and writing emails about planning things. I occasionally write and speak on Web Accessiblity and technology. I try to live the "joie de vivre" up here in Southern Maine, with my family and friends.
You can follow me on twitter and Instagram, if you are into that sort of thing.


MBMLDebugFunctions Class Reference
| Inherits from | NSObject |
|---|---|
| Declared in | MBMLDebugFunctions.h |
Overview
This class implements MBML functions useful for debugging.
These functions are exposed to the Mockingbird environment via
<Function ... />
declarations in the MBDataEnvironmentModule.xml
file.
For more information on MBML functions, see the MBMLFunction
class.
Inspecting values within expressions
+ log:
Evaluates the passed-in expression in the object context, logs the result to the console, and then returns the result.
+ (id)log:(NSString *)expr
Parameters
expr |
The expression to be evaluated. Both |
|---|
Return Value
The result of evaluating expr
.
Discussion
You can use this to inspect object expressions (or portions thereof) to see what values are being returned within them. This can be handy when debugging a complex expression that isn’t returning the result you expect.
This Mockingbird function accepts one parameter, the expression to evaluate.
Expression usage
Assume the variable $cart
is an array containing five items:
You have ^log($cart).count items in your cart.
The expression “$cart
” would be logged to the console, along with the
result of calling the description
method on underlying the NSArray
.
The array would then be returned by the function.
The expression as a whole would yield the string “You have 5 items in your
cart.
”
Declared In
MBMLDebugFunctions.h
+ test:
Evaluates the passed-in expression in the boolean context, logs the result to the console, and then returns the result.
+ (id)test:(NSString *)expr
Parameters
expr |
The expression to be evaluated. Both |
|---|
Return Value
The result of evaluating expr
.
Discussion
You can use this to inspect boolean expressions (or portions thereof) to see what values are being returned within them. This can be handy when debugging a complex expression that isn’t returning the result you expect.
This Mockingbird function accepts one parameter, the expression to evaluate.
Expression usage
Assume the variable $foo
contains the string “cromulent
”:
^test($foo.length -GT 5)
The expression “$foo.length -GT 5
” would be logged to the console,
along with the boolean result, which is YES
. The result YES
would then
be returned by the function.
Declared In
MBMLDebugFunctions.h
+ dump:
Evaluates the passed-in expression in the object context, logs the result to the console, and then returns the string description of the result.
+ (id)dump:(NSString *)expr
Parameters
expr |
The expression to be evaluated. Both |
|---|
Return Value
The result of evaluating `expr.
Discussion
This Mockingbird function accepts one parameter, the expression to evaluate.
Expression usage
Assume the variable $Window
contains a reference to the application’s
UIWindow
:
^dump($Window)
The expression above might result in a value such as:
<UIWindow: 0x7f811c3036e0; frame = (0 0; 375 667); layer = <UIWindowLayer: 0x7f811c300ed0>>
Declared In
MBMLDebugFunctions.h
Triggering a debug breakpoint
+ debugBreak:
Triggers a debug breakpoint when called in a debug build. This allows the developer to trap execution at a specific point during expression evaluation.
+ (NSString *)debugBreak:(NSString *)input
Parameters
input |
An arbitrary expression to be logged to the console before the breakpoint is triggered. |
|---|
Return Value
The input
.
Discussion
Note: This function does nothing unless the DEBUG
preprocessor macro is
defined.
This Mockingbird function accepts one parameter as input, an expression that will be returned by the function when it is called, allowing the function to be used as a pass-through.
Expression usage
^debugBreak(Here is the first problem)
In a debug build, the expression above would result in the string
“Here is the first problem
”, and then a breakpoint would be triggered
in the Xcode debugger.
In non-debug builds, nothing happens.
Declared In
MBMLDebugFunctions.h
Inspecting expression tokenization
+ tokenize:
Tokenizes an object expression and logs the resulting parse tokens to the console.
+ (NSString *)tokenize:(NSString *)expr
Parameters
expr |
The expression to tokenize. |
|---|
Return Value
The expression expr
.
Discussion
When experiencing trouble with a complex expression giving unexpected results, seeing the parse tokens lets you understand how the expression evaluator is interpreting your expression.
This Mockingbird function accepts a single parameter, the expression to tokenize. The input expression is returned, allowing the function to be used as a pass-through.
Expression usage
^tokenize(This $aint.no ^party())
The expression above would result in console output similar to the following:
--> Tokens for object expression "This $aint.no ^party()":
<MBMLLiteralToken@0x7f8ac03aaea0: "This " {0, 5}>
<MBMLVariableReferenceToken@0x7f8abce042a0: "$aint" {5, 5}> containing 1 token:
0: <MBMLObjectSubreferenceToken@0x7f8ac0670a00: ".no" {10, 3}>
<MBMLLiteralToken@0x7f8ac036f4a0: " " {13, 1}>
<MBMLFunctionCallToken@0x7f8ac0645bb0: "^party()" {14, 8}>
Declared In
MBMLDebugFunctions.h
+ tokenizeBoolean:
Tokenizes a boolean expression and logs the resulting parse tokens to the console.
+ (NSString *)tokenizeBoolean:(NSString *)expr
Parameters
expr |
The expression to tokenize. |
|---|
Return Value
The expression expr
.
Discussion
When experiencing trouble with a complex expression giving unexpected results, seeing the parse tokens lets you understand how the expression evaluator is interpreting your expression.
This Mockingbird function accepts a single parameter, the expression to tokenize. The input expression is returned, allowing the function to be used as a pass-through.
Expression usage
^tokenizeBoolean(This != ^party())
The expression above would result in console output similar to the following:
--> Tokens for boolean expression "This != ^party()":
<MBMLInequalityTestToken@0x7fa93fb5fbe0: "!=" {5, 2}> containing 2 tokens:
0: <MBMLLiteralToken@0x7fa93fb45970: "This" {0, 4}>
1: <MBMLFunctionCallToken@0x7fa93fb4af80: "^party()" {8, 8}>
Declared In
MBMLDebugFunctions.h
+ tokenizeMath:
Tokenizes a math expression and logs the resulting parse tokens to the console.
+ (NSString *)tokenizeMath:(NSString *)expr
Parameters
expr |
The expression to tokenize. |
|---|
Return Value
The expression expr
.
Discussion
When experiencing trouble with a complex expression giving unexpected results, seeing the parse tokens lets you understand how the expression evaluator is interpreting your expression.
This Mockingbird function accepts a single parameter, the expression to tokenize. The input expression is returned, allowing the function to be used as a pass-through.
Expression usage
^tokenizeMath(($user.firstName.length + $user.lastName.length) + 1)
The expression above would result in console output similar to the following:
--> Tokens for math expression "($user.firstName.length + $user.lastName.length) + 1":
<MBMLAdditionOperatorToken@0x7fa940048b70: "+" {49, 1}> containing 2 tokens:
0: <MBMLMathGroupingToken@0x7fa9400a87d0: "($user.firstName.length + $user.lastName.length)" {0, 48}> containing 1 token:
0: <MBMLAdditionOperatorToken@0x7fa93ae86fd0: "+" {23, 1}> containing 2 tokens:
0: <MBMLVariableReferenceToken@0x7fa93faf9400: "$user" {0, 5}> containing 2 tokens:
0: <MBMLObjectSubreferenceToken@0x7fa940049ac0: ".firstName" {5, 10}>
1: <MBMLObjectSubreferenceToken@0x7fa93fae4340: ".length" {15, 7}>
1: <MBMLVariableReferenceToken@0x7fa93aeb8f70: "$user" {25, 5}> containing 2 tokens:
0: <MBMLObjectSubreferenceToken@0x7fa93aea8d90: ".lastName" {30, 9}>
1: <MBMLObjectSubreferenceToken@0x7fa93fa52f60: ".length" {39, 7}>
1: <MBMLNumericLiteralToken@0x7fa94007d100: "1" {51, 1}>
Declared In
MBMLDebugFunctions.h
Benchmarking
+ bench:
Benchmarks an object expression by measuring the time it takes to evaluate and logging the resulting time to the console.
+ (id)bench:(NSString *)expr
Parameters
expr |
The expression to benchmark. |
|---|
Return Value
The expression expr
.
Discussion
This Mockingbird function accepts a single parameter, the expression being benchmarked. The input expression is also returned by the function, allowing it to be used as a pass-through.
Expression usage
In this example, the MBML function ^currentTime()
is benchmarked:
^bench(^currentTime())
One run of this benchmark resulted in the console output:
--> Evaluated variable expansion expression "^currentTime()" in 1.90139e-05 seconds
Declared In
MBMLDebugFunctions.h
+ benchBool:
Benchmarks a boolean expression by measuring the time it takes to evaluate and logging the resulting time to the console.
+ (id)benchBool:(NSString *)expr
Parameters
expr |
The expression to benchmark. |
|---|
Return Value
The expression expr
.
Discussion
This Mockingbird function accepts a single parameter, the expression being benchmarked. The input expression is also returned by the function, allowing it to be used as a pass-through.
Expression usage
In this example, a boolean expression involving the MBML function
^randomPercent()
is benchmarked:
^benchBool(^randomPercent() -GTE 0.5)
One run of this benchmark resulted in the console output:
--> Evaluated boolean expression "^randomPercent() -GTE 0.5" in 4.09484e-05 seconds
Declared In
MBMLDebugFunctions.h
+ repeat:
Repeatedly evaluates an object expression a given number of times.
+ (id)repeat:(NSArray *)params
Parameters
params |
The function’s input parameters. |
|---|
Return Value
The function result.
Discussion
This Mockingbird function accepts two pipe-separated parameters:
The number of repetitions to perform, a numeric expression indicating how many times expression will be evaluated
The expression to evaluate
The function returns the result of the final evaluation of expression.
Expression usage
When combined with benchmarking, this function is useful for evaluating the performance of MBML function implementations and other types of expressions.
^bench(^repeat(1000|^currentTime()))
The expression above calls the ^currentTime()
function 1,000 times and then
logs the result to the console.
One run of this benchmark resulted in the console output:
--> Successfully repeated object expression "^currentTime()" 1000 times
--> Evaluated object expression "^repeat(1000|^currentTime())" in 0.010256 seconds
Declared In
MBMLDebugFunctions.h
+ repeatBool:
Repeatedly evaluates a boolean expression a given number of times.
+ (id)repeatBool:(NSArray *)params
Parameters
params |
The function’s input parameters. |
|---|
Return Value
The function result.
Discussion
This Mockingbird function accepts two pipe-separated parameters:
The number of repetitions to perform, a numeric expression indicating how many times expression will be evaluated
The expression to evaluate
The function returns the result of the final evaluation of expression.
Expression usage
When combined with benchmarking, this function is useful for evaluating the performance of MBML expressions.
^benchBool(^repeatBool(10000|^randomPercent() -GTE 0.5))
In the example above, the boolean expression ^randomPercent() -GTE 0.5
is
evaluated 10,000 times.
One run of this benchmark resulted in the console output:
--> Successfully repeated boolean expression "^randomPercent() -GTE 0.5" 1000 times
--> Evaluated boolean expression "^repeatBool(10000|^randomPercent() -GTE 0.5)" in 0.013923 seconds
Declared In
MBMLDebugFunctions.h
Deprecation
+ deprecateVariableInFavorOf:
Issues a deprecation warning to the console for the MBML variable with the given name.
+ (id)deprecateVariableInFavorOf:(NSArray *)params
Parameters
params |
The function’s input parameters. |
|---|
Return Value
The preferred variable name.
Discussion
This Mockingbird function accepts two or three pipe-separated parameters:
The deprecated variable name, a string expression yielding the name of the variable being deprecated.
The preferred variable name, a string expression yielding the variable name that should be used instead of deprecated variable name.
An optional module class, a string expression representing the name of a class implementing the
MBModule
protocol. If specified, theMBModuleLog
associated with module class will be used to issue the deprecation warning. If this parameter is omitted, the deprecation warning will be issued using theMBDataEnvironmentModule
’s log.
This method returns preferred variable name, allowing it to be used as a pass-through.
Expression usage
^deprecateVariableInFavorOf(place|location|MBGeolocationModule)
The expression above would result in the following message
DEPRECATION WARNING: Support will be dropped from a future version of the
MBGeolocation module for Mockingbird:
The MBML variable "place" has been deprecated; please update your code
to use "location" instead
Declared In
MBMLDebugFunctions.h


In the summer of 1989, a group of bullied kids band together to destroy a shapeshifting monster, which disguises itself as a clown and preys on the children of Derry, their small Maine town.
Click here for the photos
Push it to make all vanish


A Serial Port Terminal Web App for Chrome
To get started, choose a Serial Port from the drop-down list above and click the Play Button to connect. Click in this window to get focus (black border), which will allow you to send characters down the Serial Port.
This app is designed for Espruino JavaScript for Microcontrollers. Please see the website and Quick Start page for more documentation, tutorials and example projects.


Implements the case-base sampling approach of Hanley and Miettinen (2009) <doi:10.2202/1557-4679.1125>, Saarela and Arjas (2015) <doi:10.1111/sjos.12125>, and Saarela (2015) <doi:10.1007/s10985-015-9352-x>, for fitting flexible hazard regression models to survival data with single event type or multiple competing causes via logistic and multinomial regression. From the fitted hazard function, cumulative incidence, risk functions of time, treatment and profile can be derived. This approach accommodates any log-linear hazard function of prognostic time, treatment, and covariates, and readily allows for non-proportionality. We also provide a plot method for visualizing incidence density via population time plots.
| Version: | 0.1.0 |
| Depends: | R (≥ 3.3.1) |
| Imports: | data.table, ggplot2, methods, survival, VGAM |
| Suggests: | eha, knitr, rmarkdown, splines, testthat |
| Published: | 2017-04-28 |
| Author: | Sahir Bhatnagar [aut, cre] (http://sahirbhatnagar.com/), Maxime Turgeon [aut] (http://turgeonmaxime.github.io/), Olli Saarela [aut] (http://individual.utoronto.ca/osaarela/), James Hanley [aut] (http://www.medicine.mcgill.ca/epidemiology/hanley/) |
| Maintainer: | Sahir Bhatnagar <sahir.bhatnagar at gmail.com> |
| BugReports: | https://github.com/sahirbhatnagar/casebase/issues |
| License: | MIT + file LICENSE |
| URL: | http://sahirbhatnagar.com/casebase/ |
| NeedsCompilation: | no |
| Citation: | casebase citation info |
| Materials: | README NEWS |
| In views: | Survival |
| CRAN checks: | casebase results |
| Reference manual: | casebase.pdf |
| Vignettes: |
Competing risk analysis Population Time Plots Introduction to casebase sampling |
| Package source: | casebase_0.1.0.tar.gz |
| Windows binaries: | r-devel: casebase_0.1.0.zip, r-release: casebase_0.1.0.zip, r-oldrel: casebase_0.1.0.zip |
| OS X binaries: | r-release: casebase_0.1.0.tgz, r-oldrel: casebase_0.1.0.tgz |
Please use the canonical form https://CRAN.R-project.org/package=casebase to link to this page.


menu
My Files
Additional features
Archive Page
Trash
QnA
Frequently Asked Questions
My QnA
Themes
Home
User's All file list
Get file list
Archive Page
This is the page where all your activity history is stored.
Explore Archive Page
Trash
Go to see the poor file in the trash.
Explore your Trash


We would like to invite you to participate in a web-based online experiment. The experiment is part of a research program investigating decision making in groups.
You must be at least 18 years old to participate in these experiments.
The decision to participate in this experiment is voluntary. Even after the start of the web-based experiment, you can stop at any time by closing your browser.
There are no foreseeable risks or discomforts to you for taking part in this study.
You will be compensated for good faith participation in this experiment with at least $ and an additional bonus between $0 and $. We expect that you urn on average an additional bonus of $. The exact amount of your payoff depends both on your decisions and on chance. We anticipate that it will take about minutes to complete this task. You will be rewarded for completing the task, not for the length of time you participate. Submitted HITs will be rejected if they are completed in a manner that appears to be random, incomplete, or otherwise negligent.
Your answers in this study are anonymized for the researchers. Researchers at the University of Mannheim, Germany have access to anonymized experimental research records only. Neither the researcher nor anyone involved with this study will access or capture any available electronic record that could be used to identify you. Any reports or publications based on this research will use only group data and will not identify you or any individual as being affiliated with this project. The only individually-identifying data we receive from Mechanical Turk are your unique identifier and your country. Your data are also stored on Mechanical Turk's servers, and the data there are subject to the Amazon Mechanical Turk Privacy Notice and Participation Agreement.
If you have any questions about this study, you may contact Samuel Mueller at<EMAIL_ADDRESS>This study is funded by the Graduate School of Economic and Social Sciences of the University of Mannheim.
Please print out a copy of this consent form for your records. By clicking 'Done' you consent to participate in this study.


Sign up for Factoriole
Username may only contain letters and spaces and must be between 2 and 32 characters.
Password must be larger than 12 characters and less than 32 characters.
Passwords must match.
Welcome to Factoriole.
After you create an account, you will be able to post facts.


Make great ideas come to life
LEADict.com is an informal group of ICT professionals with over 20 years experience in the ICT industry. We continuously look for better ways to satisfy the requirements of a modern world with improved quality, durability, service, and price.
-
The name, LEADict is an acronym with more than one meaning:
- Lead ICT - an Information and Communication Technology Leadership.
- Learn, Execute And Diagnose ICT - a three-stage Information and Communication Technology development strategy.
-
Activity portfolio:
- Cloud Computing and Privacy Protection.
- Solutions and software architecture.
- Consulting, system integration, process analysis.
- Software developing, implementing, training.
-
"It's all about finding ways to get things done."


git-http-backend - Server side implementation of Git over HTTP
git http-backend
A simple CGI program to serve the contents of a Git repository to Git clients accessing the repository over http:// and https:// protocols.
It verifies that the directory has the magic file "git-daemon-export-ok", and it will refuse to export any Git directory that hasn(cqt explicitly been marked for export this way (unless the GIT_HTTP_EXPORT_ALL environmental variable is set).
By default, only the upload-pack service is enabled, which serves git fetch-pack and git ls-remote clients, which are invoked from git fetch, git pull, and git clone. If the client is authenticated, the receive-pack service is enabled, which serves git send-pack clients, which is invoked from git push.
These services can be enabled/disabled using the per-repository configuration file:
http.getanyfile
This serves Git clients older than version 1.6.6 that are unable to use the upload pack service. When enabled, clients are able to read any file within the repository, including objects that are no longer reachable from a branch but are still present. It is enabled by default, but a repository can disable it by setting this configuration item to false.
http.uploadpack
This serves git fetch-pack and git ls-remote clients. It is enabled by default, but a repository can disable it by setting this configuration item to false.
http.receivepack
This serves git send-pack clients, allowing push. It is disabled by default for anonymous users, and enabled by default for users authenticated by the web server. It can be disabled by setting this item to false, or enabled for all users, including anonymous users, by setting it to true.
To determine the location of the repository on disk, git http-backend concatenates the environment variables PATH_INFO, which is set automatically by the web server, and GIT_PROJECT_ROOT, which must be set manually in the web server configuration. If GIT_PROJECT_ROOT is not set, git http-backend reads PATH_TRANSLATED, which is also set automatically by the web server.
All of the following examples map http://$hostname/git/foo/bar.git to /var/www/git/foo/bar.git.
Apache 2.x
Ensure mod_cgi, mod_alias, and mod_env are enabled, set GIT_PROJECT_ROOT (or DocumentRoot) appropriately, and create a ScriptAlias to the CGI:
SetEnv GIT_PROJECT_ROOT /var/www/git SetEnv GIT_HTTP_EXPORT_ALL ScriptAlias /git/ /usr/libexec/git-core/git-http-backend/
To enable anonymous read access but authenticated write access, require authorization for both the initial ref advertisement (which we detect as a push via the service parameter in the query string), and the receive-pack invocation itself:
RewriteCond %{QUERY_STRING} service=git-receive-pack [OR] RewriteCond %{REQUEST_URI} /git-receive-pack$ RewriteRule ^/git/ - [E=AUTHREQUIRED:yes] <LocationMatch "^/git/"> Order Deny,Allow Deny from env=AUTHREQUIRED AuthType Basic AuthName "Git Access" Require group committers Satisfy Any ... </LocationMatch>
If you do not have mod_rewrite available to match against the query string, it is sufficient to just protect git-receive-pack itself, like:
<LocationMatch "^/git/.*/git-receive-pack$"> AuthType Basic AuthName "Git Access" Require group committers ... </LocationMatch>
In this mode, the server will not request authentication until the client actually starts the object negotiation phase of the push, rather than during the initial contact. For this reason, you must also enable the http.receivepack config option in any repositories that should accept a push. The default behavior, if http.receivepack is not set, is to reject any pushes by unauthenticated users; the initial request will therefore report 403 Forbidden to the client, without even giving an opportunity for authentication.
To require authentication for both reads and writes, use a Location directive around the repository, or one of its parent directories:
<Location /git/private> AuthType Basic AuthName "Private Git Access" Require group committers ... </Location>
To serve gitweb at the same url, use a ScriptAliasMatch to only those URLs that git http-backend can handle, and forward the rest to gitweb:
ScriptAliasMatch e "(?x)^/git/(.*/(HEAD | e info/refs | e objects/(info/[^/]+ | e [0-9a-f]{2}/[0-9a-f]{38} | e pack/pack-[0-9a-f]{40}e.(pack|idx)) | e git-(upload|receive)-pack))$" e /usr/libexec/git-core/git-http-backend/$1 ScriptAlias /git/ /var/www/cgi-bin/gitweb.cgi/
To serve multiple repositories from different gitnamespaces(7) in a single repository:
SetEnvIf Request_URI "^/git/([^/]*)" GIT_NAMESPACE=$1 ScriptAliasMatch ^/git/[^/]*(.*) /usr/libexec/git-core/git-http-backend/storage.git$1
Accelerated static Apache 2.x
Similar to the above, but Apache can be used to return static files that are stored on disk. On many systems this may be more efficient as Apache can ask the kernel to copy the file contents from the file system directly to the network:
SetEnv GIT_PROJECT_ROOT /var/www/git AliasMatch ^/git/(.*/objects/[0-9a-f]{2}/[0-9a-f]{38})$ /var/www/git/$1 AliasMatch ^/git/(.*/objects/pack/pack-[0-9a-f]{40}.(pack|idx))$ /var/www/git/$1 ScriptAlias /git/ /usr/libexec/git-core/git-http-backend/
This can be combined with the gitweb configuration:
SetEnv GIT_PROJECT_ROOT /var/www/git AliasMatch ^/git/(.*/objects/[0-9a-f]{2}/[0-9a-f]{38})$ /var/www/git/$1 AliasMatch ^/git/(.*/objects/pack/pack-[0-9a-f]{40}.(pack|idx))$ /var/www/git/$1 ScriptAliasMatch e "(?x)^/git/(.*/(HEAD | e info/refs | e objects/info/[^/]+ | e git-(upload|receive)-pack))$" e /usr/libexec/git-core/git-http-backend/$1 ScriptAlias /git/ /var/www/cgi-bin/gitweb.cgi/
Lighttpd
Ensure that mod_cgi, mod_alias, mod_auth, mod_setenv are loaded, then set GIT_PROJECT_ROOT appropriately and redirect all requests to the CGI:
alias.url += ( "/git" => "/usr/lib/git-core/git-http-backend" ) $HTTP["url"] =~ "^/git" { cgi.assign = ("" => "") setenv.add-environment = ( "GIT_PROJECT_ROOT" => "/var/www/git", "GIT_HTTP_EXPORT_ALL" => "" ) }
To enable anonymous read access but authenticated write access:
$HTTP["querystring"] =~ "service=git-receive-pack" { include "git-auth.conf" } $HTTP["url"] =~ "^/git/.*/git-receive-pack$" { include "git-auth.conf" }
where git-auth.conf looks something like:
auth.require = ( "/" => ( "method" => "basic", "realm" => "Git Access", "require" => "valid-user" ) ) # ...and set up auth.backend here
To require authentication for both reads and writes:
$HTTP["url"] =~ "^/git/private" { include "git-auth.conf" }
git http-backend relies upon the CGI environment variables set by the invoking web server, including:
h'-04'(buh'+03'c
PATH_INFO (if GIT_PROJECT_ROOT is set, otherwise PATH_TRANSLATED)
h'-04'(buh'+03'c
REMOTE_USER
h'-04'(buh'+03'c
REMOTE_ADDR
h'-04'(buh'+03'c
CONTENT_TYPE
h'-04'(buh'+03'c
QUERY_STRING
h'-04'(buh'+03'c
REQUEST_METHOD
The GIT_HTTP_EXPORT_ALL environmental variable may be passed to git-http-backend to bypass the check for the "git-daemon-export-ok" file in each repository before allowing export of that repository.
The backend process sets GIT_COMMITTER_NAME to $REMOTE_USER and GIT_COMMITTER_EMAIL to<EMAIL_ADDRESS>ensuring that any reflogs created by git-receive-pack contain some identifying information of the remote user who performed the push.
All CGI environment variables are available to each of the hooks invoked by the git-receive-pack.
Part of the git(1) suite


Amazon Web Services offers cloud computing services on which you can run Flink.
Amazon Elastic MapReduce (Amazon EMR) is a web service that makes it easy to quickly setup a Hadoop cluster. This is the recommended way to run Flink on AWS as it takes care of setting up everything.
Flink is a supported application on Amazon EMR. Amazon’s documentation describes configuring Flink, creating and monitoring a cluster, and working with jobs.
Amazon EMR services are regularly updated to new releases but a version of Flink which is not available can be manually installed in a stock EMR cluster.
Create EMR Cluster
The EMR documentation contains examples showing how to start an EMR cluster. You can follow that guide and install any EMR release. You don’t need to install the All Applications part of the EMR release, but can stick to Core Hadoop.
Note Access to S3 buckets requires configuration of IAM roles when creating an EMR cluster.
Install Flink on EMR Cluster
After creating your cluster, you can connect to the master node and install Flink:
Amazon Simple Storage Service (Amazon S3) provides cloud object storage for a variety of use cases. You can use S3 with Flink for reading and writing data as well in conjunction with the streaming state backends or even as a YARN object storage.
You can use S3 objects like regular files by specifying paths in the following format:
The endpoint can either be a single file or a directory, for example:
Note that these examples are not exhaustive and you can use S3 in other places as well, including your high availability setup or the RocksDBStateBackend; everywhere that Flink expects a FileSystem URI.
For most use cases, you may use one of our shaded flink-s3-fs-hadoop
and flink-s3-fs-presto
S3
filesystem wrappers which are fairly easy to set up. For some cases, however, e.g. for using S3 as
YARN’s resource storage dir, it may be necessary to set up a specific Hadoop S3 FileSystem
implementation. Both ways are described below.
To use either flink-s3-fs-hadoop
or flink-s3-fs-presto
, copy the respective JAR file from the
opt
directory to the lib
directory of your Flink distribution before starting Flink, e.g.
Both flink-s3-fs-hadoop
and flink-s3-fs-presto
register default FileSystem
wrappers for URIs with the s3://
scheme, flink-s3-fs-hadoop
also registers
for s3a://
and flink-s3-fs-presto
also registers for s3p://
, so you can
use this to use both at the same time.
After setting up the S3 FileSystem wrapper, you need to make sure that Flink is allowed to access your S3 buckets.
The recommended way of setting up credentials on AWS is via Identity and Access Management (IAM). You can use IAM features to securely give Flink instances the credentials that they need in order to access S3 buckets. Details about how to do this are beyond the scope of this documentation. Please refer to the AWS user guide. What you are looking for are IAM Roles.
If you set this up correctly, you can manage access to S3 within AWS and don’t need to distribute any access keys to Flink.
Access to S3 can be granted via your access and secret key pair. Please note that this is discouraged since the introduction of IAM roles.
You need to configure both s3.access-key
and s3.secret-key
in Flink’s flink-conf.yaml
:
This setup is a bit more complex and we recommend using our shaded Hadoop/Presto file systems
instead (see above) unless required otherwise, e.g. for using S3 as YARN’s resource storage dir
via the fs.defaultFS
configuration property in Hadoop’s core-site.xml
.
Interaction with S3 happens via one of Hadoop’s S3 FileSystem clients:
S3AFileSystem
(recommended for Hadoop 2.7 and later): file system for reading and writing regular files using Amazon’s SDK internally. No maximum file size and works with IAM roles.NativeS3FileSystem
(for Hadoop 2.6 and earlier): file system for reading and writing regular files. Maximum object size is 5GB and does not work with IAM roles.S3AFileSystem
(Recommended)This is the recommended S3 FileSystem implementation to use. It uses Amazon’s SDK internally and works with IAM roles (see Configure Access Credentials).
You need to point Flink to a valid Hadoop configuration, which contains the following properties in core-site.xml
:
This registers S3AFileSystem
as the default FileSystem for URIs with the s3a://
scheme.
NativeS3FileSystem
This file system is limited to files up to 5GB in size and it does not work with IAM roles (see Configure Access Credentials), meaning that you have to manually configure your AWS credentials in the Hadoop config file.
You need to point Flink to a valid Hadoop configuration, which contains the following property in core-site.xml
:
This registers NativeS3FileSystem
as the default FileSystem for URIs with the s3://
scheme.
You can specify the Hadoop configuration in various ways pointing Flink to the path of the Hadoop configuration directory, for example
HADOOP_CONF_DIR
, orfs.hdfs.hadoopconf
configuration option in flink-conf.yaml
:This registers /path/to/etc/hadoop
as Hadoop’s configuration directory with Flink. Flink will look for the core-site.xml
and hdfs-site.xml
files in the specified directory.
After setting up the S3 FileSystem, you need to make sure that Flink is allowed to access your S3 buckets.
When using S3AFileSystem
, the recommended way of setting up credentials on AWS is via Identity and Access Management (IAM). You can use IAM features to securely give Flink instances the credentials that they need in order to access S3 buckets. Details about how to do this are beyond the scope of this documentation. Please refer to the AWS user guide. What you are looking for are IAM Roles.
If you set this up correctly, you can manage access to S3 within AWS and don’t need to distribute any access keys to Flink.
Note that this only works with S3AFileSystem
and not NativeS3FileSystem
.
S3AFileSystem
(Discouraged)Access to S3 can be granted via your access and secret key pair. Please note that this is discouraged since the introduction of IAM roles.
For S3AFileSystem
you need to configure both fs.s3a.access.key
and fs.s3a.secret.key
in Hadoop’s core-site.xml
:
NativeS3FileSystem
(Discouraged)Access to S3 can be granted via your access and secret key pair. But this is discouraged and you should use S3AFileSystem
with the required IAM roles.
For NativeS3FileSystem
you need to configure both fs.s3.awsAccessKeyId
and fs.s3.awsSecretAccessKey
in Hadoop’s core-site.xml
:
Hadoop’s S3 FileSystem clients are packaged in the hadoop-aws
artifact (Hadoop version 2.6 and later). This JAR and all its dependencies need to be added to Flink’s classpath, i.e. the class path of both Job and TaskManagers. Depending on which FileSystem implementation and which Flink and Hadoop version you use, you need to provide different dependencies (see below).
There are multiple ways of adding JARs to Flink’s class path, the easiest being simply to drop the JARs in Flink’s lib
folder. You need to copy the hadoop-aws
JAR with all its dependencies. You can also export the directory containing these JARs as part of the HADOOP_CLASSPATH
environment variable on all machines.
Depending on which file system you use, please add the following dependencies. You can find these as part of the Hadoop binaries in hadoop-2.7/share/hadoop/tools/lib
:
S3AFileSystem
:
hadoop-aws-2.7.3.jar
aws-java-sdk-s3-1.11.183.jar
and its dependencies:
aws-java-sdk-core-1.11.183.jar
aws-java-sdk-kms-1.11.183.jar
jackson-annotations-2.6.7.jar
jackson-core-2.6.7.jar
jackson-databind-2.6.7.jar
joda-time-2.8.1.jar
httpcore-4.4.4.jar
httpclient-4.5.3.jar
NativeS3FileSystem
:
hadoop-aws-2.7.3.jar
guava-11.0.2.jar
Note that hadoop-common
is available as part of Flink, but Guava is shaded by Flink.
Depending on which file system you use, please add the following dependencies. You can find these as part of the Hadoop binaries in hadoop-2.6/share/hadoop/tools/lib
:
S3AFileSystem
:
hadoop-aws-2.6.4.jar
aws-java-sdk-1.7.4.jar
and its dependencies:
jackson-annotations-2.1.1.jar
jackson-core-2.1.1.jar
jackson-databind-2.1.1.jar
joda-time-2.2.jar
httpcore-4.2.5.jar
httpclient-4.2.5.jar
NativeS3FileSystem
:
hadoop-aws-2.6.4.jar
guava-11.0.2.jar
Note that hadoop-common
is available as part of Flink, but Guava is shaded by Flink.
These Hadoop versions only have support for NativeS3FileSystem
. This comes pre-packaged with Flink for Hadoop 2 as part of hadoop-common
. You don’t need to add anything to the classpath.
The following sections lists common issues when working with Flink on AWS.
If your job submission fails with an Exception message noting that No file system found with scheme s3
this means that no FileSystem has been configured for S3. Please check out the configuration sections for our shaded Hadoop/Presto or generic Hadoop file systems for details on how to configure this properly.
If you see your job failing with an Exception noting that the AWS Access Key ID and Secret Access Key must be specified as the username or password
, your access credentials have not been set up properly. Please refer to the access credential section for our shaded Hadoop/Presto or generic Hadoop file systems for details on how to configure this.
If you see this Exception, the S3 FileSystem is not part of the class path of Flink. Please refer to S3 FileSystem dependency section for details on how to configure this properly.
400: Bad Request
If you have configured everything properly, but get a Bad Request
Exception and your S3 bucket is located in region eu-central-1
, you might be running an S3 client, which does not support Amazon’s signature version 4.
or
This should not apply to our shaded Hadoop/Presto S3 file systems but can occur for Hadoop-provided
S3 file systems. In particular, all Hadoop versions up to 2.7.2 running NativeS3FileSystem
(which
depend on JetS3t 0.9.0
instead of a version >= 0.9.4)
are affected but users also reported this happening with the S3AFileSystem
.
Except for changing the bucket region, you may also be able to solve this by
requesting signature version 4 for request authentication,
e.g. by adding this to Flink’s JVM options in flink-conf.yaml
(see
configuration):
This Exception is usually caused by skipping the local buffer directory configuration fs.s3a.buffer.dir
for the S3AFileSystem
. Please refer to the S3AFileSystem configuration section to see how to configure the S3AFileSystem
properly.


ngModel
the model to be bound to the control
ngDisabled
indicates whether this control is disabled or not
ngRequired
indicates whether the value of this control is required or not
ngValidating
indicated whether the value of this control is validated or not
ngLabel
the label for this control, viewed as header
ngTip
the sublabel for this control, viewed as subheader
ngToolbar
the toolbar buttons
ngHeight
the editor height. if undefined, auth height is applied
ngMaxHeight
the editor max height
<ctrl-html
ng-model="sample.value"
ng-disabled="false"
ng-required="true"
ng-label="sample label text"
ng-tip="sample tip text"
ng-toolbar=['formatting', 'bold', 'italic', 'deleted', 'unorderedlist', 'orderedlist', 'outdent', 'indent', 'image', 'file', 'link', 'alignment', 'horizontalrule']
ng-height=200></ctrl-html>


{% extends "docs/base.html" %} {% load static %} {% block title %}Quickstart | Siphon Docs{% endblock %} {% block docs_toc %} Install the command-line client Download and run the Siphon Sandbox app Create your first app Push some changes to your app Running your app in the simulator Sharing your app with beta testers Publishing your app Next up {% endblock %} {% block docs_content %}
Siphon is primarily a command-line tool. This quickstart tutorial will walk you through the installation process and then describe all of the ways that you can interact with the service.
To get started with Siphon you will need to download our lightweight command-line tool. Paste the following command into a terminal window:
The installer script will take a few seconds to complete. Once that's done, check that the tool is working:
One way to run apps is by installing the Siphon Sandbox app onto your device. Open up your phone's browser and type in the following address if it's an iPhone:
Or, if it's an Android device:
Once that's done, login with your Siphon account. No account yet?
You can also use the siphon play command to run your apps in the simulator. More on that below.
Navigate to a suitable directory (anywhere is fine) and type the following command to create a new app:
You can name the app anything you like. The tool creates a new directory with same name.
The new directory contains a simple React Native template app. Once the command finishes running, the new app is going to appear in the Siphon Sandbox.
Next, tap on the icon to start the app; it's going to load over-the-air.
Now let's try making some changes. Navigate into the newly created directory and open up index.js in your favourite editor.
Change some of the template text within the <Text> tag and save the file.
Next, push your changes with the command-line tool:
The app should now automatically reload on the phone and display your changes. Instead of typing in this command for every change, you can also use the tool to watch your app for changes:
Every time you save a change to one of your app's files, the tool will push those changes automatically. This makes the process of developing your app much more pleasant.
To stream logs and errors from your app as it runs in the sandbox, you can use the siphon logs command.
If you're using a Mac, there's a way to run your app in the iOS simulator. Navigate to your app directory and type in:
The tool will prompt you to install Xcode and any other necessary components that you haven't already installed on your local machine.
It will then build and run your project as a standalone app in the simulator while running the React Native packager in the background (so you get the benefits of Hot Reloading).
You can specify other simulator types like this:
Soon you will also be able to run your app in the Android emulator, but for now you should use the sandbox.
Before publishing an app it can be useful to send it to beta testers so that they can give you feedback. Simply specify an email address and we will send them an invitation to beta test your app:
No approval is required and the recipient will be prompted to create a Siphon account if they do not already have one. The user will see a special read-only copy of your app and you can instantly send them changes as often as you like.
When you're finished working on an app, you can publish it by typing in one command:
You will be prompted to enter some basic information about your app, like a description and some keywords.
Behind-the-scenes we will build, sign, package and submit an app binary on your behalf.
Read more about how publishing works


"The Circle"
In a nation where a woman cannot even buy a bus ticket without her husband's permission or smoke a cigarette in public, much less obtain an abortion, director Jafar Panahi delves into the lives of women on the wrong side of the law in Iran in "The Circle."
>From the very start of "The Circle" we are thrust into the alien, male-dominated society of Iran that treats its women as possessions, not people. An old woman stands outside the small door to a hospital maternity ward. The door slides opens and a nurse tells her that her daughter has had a beautiful baby girl. The door slides shut. Obviously agitated, the woman knocks at the door and asks another nurse about the baby's sex. Again, "it's an adorable girl," she is told. "They'll want a divorce!" she moans about her in-laws as she dejectedly leaves the hospital.
This extended scene of despair summarizes the film's theme of the harsh life for women, especially an ex-convict, in Iran. The old woman's misery is just the lead into one of the most powerful, thought-provoking and eye-opening films to come to the screen this year. Iran's Islamic society stridently keeps women in a second-class, subservient role where the men running the country define a woman's "rights". Conditions, from a western viewpoint, are severe, at best, for the average Iranian woman. Panahi's "circle" of women is an even more harshly treated subgroup - the sisterhood of women who served time in Iranian prison.
As the old woman leaves the hospital, she crosses paths with three younger women, dressed head to toe in the black robes and the ever-ready chadir required by Islamic law. There is something wrong as they try to make a phone call to a friend who can help get tickets for the three to flee the city, hopefully to a place where the air is not so oppressive. But, no one answers the phone. Desperate for money, one of them takes their one valuable possession, a slender gold necklace, and tries to sell it on the street. A scuffle ensues and she (though not the men she tries to sell the trinket to) is arrested, as her friends look on helpless to intervene.
Arezou (Maryiam Parvin Almani) and Nargess (Nargess Mamizadeh) now must fend for themselves. The older Arezou takes the little money they have and gets Nargess onto a bus that she hopes will bring her young friend back to the wonderful world of her childhood. It doesn't and Nargess must seek out another convict, Pari (Fereshteh Sadr Orafai), for help. The story shifts to Pari, who has her own set of problems. She's a prison escapee, single and pregnant, not a safe combination for a woman and Pari goes to another prison sister for assistance. The story then weaves in a heart rendering tale about a pretty little girl, dressed in her best clothes, abandoned by her unwed mother (Fatemah Naghavi) in hopes that she'll be taken by good and kind people.
The end of the film bookends the beginning with another small door sliding shut. The finality of this action closes out a story that leaves you pondering just how it would feel to live under such repression, always fearful and always vulnerable. It's a story about a man's world shown from the woman's view and it's not an appealing picture of life in Iran. But, it is a beautifully made film by the maker of the wonderful childhood story, "The White Balloon," showing Panahi's deft versatility as a world-class filmmaker.
The cinema verite-style camerawork helps carry forward the tension these women live with, day to day, as they strive to survive and stay out of prison - and it doesn't take much to get sent to prison. The look of the film, coupled with the natural efforts by the actresses, makes it feel real, almost documentary-like, and brings us to see a very different social order. "The Circle" is a powerhouse of a film and I give it an A.
For more Reeling reviews visit www.reelingreviews.com
<EMAIL_ADDRESS><EMAIL_ADDRESS>The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Scott Doyle /<EMAIL_ADDRESS>If you are looking for people to group up with, you can use the following sheet:
Probabilistic Classification
$ P(x|y) = \frac{P(y|x)P(x)}{\sum_{x\in\mathcal{X}}P(y|x)P(x)} $
Each object has a class associated with it, which we will call $\omega$
Binary class: Only have two possible values.
$\omega$ is a discrete random variable representing those values.
Probabilies can be written as both $P(\cdot)$ and $p(\cdot)$.
The math behind $P(\cdot)$ and $p(\cdot)$ is different:
Continuous variables have infinite possible values, so you cannot sum them all across the domain.
Discrete values have discontinuities in the domain, so the integral is not fully differentiable in the domain.
$P(x)$ is the Prior, or a priori, probability of observing a certain $x$, in the absence of any other information.
Recall that any set of probabilities must:
How do we find $P(\omega_{1})$ and $P(\omega_{2})$?
Domain Knowledge
If we know that there are twice as many benign patients as there are malignant patients in the world, then we might say that:
$P(\omega_{2}) = 2P(\omega_{1})$
$P(\omega_{2})\approx 66\%\qquad P(\omega_{1})\approx 33\%$
How do we decide whether a random patient is benign or malignant?
Guessing Game
Here we find our first Decision Rule:
If $P(\omega_{1}) > P(\omega_{2})$, decide $\omega_{1}$; otherwise, decide $\omega_{2}.$
Since the priors are fixed, we always decide the same class for each patient randomly drawn from our collection.
Of course, this doesn’t work very well.
Both types of patients do exist, so we will clearly be making mistakes.
How do we calculate our error rate?
The error depends on the difference between $P(\omega_{1})$ and $P(\omega_{2})$:
Keep in mind, this assumes your estimates of $P(\omega_{1})$ and $P(\omega_{2})$ are accurate!
Using Evidence to Make Decisions
This is a bit boring: our “classifier” just gives us the same answer, forever!
We improve this rule through the use of evidence, or features.
Let’s say that:
Each feature is considered a dimension of the feature vector, so $\mathbf{x}\in\mathbb{R}^{d}$.
We want the probability of observing a particular feature value given $\omega$:
$p(x|\omega)$
This is the class-conditional probability density function (PDF).
$p(x|\omega_{i})$ says that if we know the class label $\omega_{i}$, what is the probability of observing $x$?
The difference between $p(x|\omega_{1})$ and $p(x|\omega_{2})$ is the difference in likelihood of observing feature value $x$ between the two populations.
How do we use our PDFs to improve our decision rule?
We know $P(\omega_{i})$ (our prior) and $p(x|\omega_{i})$ (our PDF), for both classes $i\in\{1,2\}$.
If we have a new image and measure this feature, it gives us a location on the horizontal axis of our PDF.
Recall joint probability, $P(y,x)$: The probability that you observe a specific value of $y$ and a specific value of $x$.
So the joint probability for our example problem is $p(\omega_{i},x)$.
We can rewrite the joint probability in terms of conditionals and priors:
Which you can rearrange into Bayes formula:
This is the posterior, or the a posteriori: It is the probability of observing class $\omega_{i}$ AFTER observing a specific feature value.
$ P(\omega_{i}|x) = \frac{p(x|\omega_{i})P(\omega_{i})}{p(x)} $
The denominator, $p(x)$, is the “prior” for a particular feature value.
Remember from last lecture:
If an event can occur in many different ways, the probability of the event is the sum over the probabilities of each of the different ways it can happen.
In this case, the “event” is “observing a specific value of $x$”.
The different ways it can happen are:
So the probability of observing a sample with feature value $x$ is the sum of the likelihood of both of those scenarios:
$ p(x) = \sum_{i=1}^{c}p(x|\omega_{i})P(\omega_{i}) $
This makes the posterior likelihood $P(\omega_{i}|x)$ sum to 1 over all feature values.
In other words, we will definitely observe some class after measuring $x$.
Now we can define our new Decision Rule in terms of our A Posteriori knowledge:
If $P(\omega_{1}|x)>P(\omega_{2}|x)$, decide $\omega_{1}$; otherwise, decide $\omega_{2}.$
Another way of writing this is:
$\omega^{\star} = \textrm{arg max}_{i}\left[P(\omega_{i}|x)\right]$
How Wrong Are We?
What is the probability of this decision rule being wrong?
$P(\textrm{error}|x)= \begin{cases} P(\omega_{1}|x)&\textrm{if we decide } \omega_{2} \\ P(\omega_{2}|x)&\textrm{if we decide } \omega_{1} \end{cases} $
This gives us the probability of error for a single value of $x$.
To get the total error, we have to integrate over all possible values of $x$:
$ P(\textrm{error}) = \int_{-\infty}^{\infty}P(\textrm{error}|x)p(x)dx $
We integrate over $\infty$ because this accounts for literally any feature value.
Our decision rule is now:
$ \textrm{If } P(\omega_{1}|x) > P(\omega_{2}|x), \textrm{decide } \omega_{1}; \textrm{otherwise, decide } \omega_{2}.$
Equivalently:
$ \textrm{If } p(x|\omega_{1})P(\omega_{1}) > p(x|\omega_{2})P(\omega_{2}), \textrm{decide } \omega_{1}; \textrm{otherwise, decide } \omega_{2}.$
Under this rule, we can express the error as:
$P(\textrm{error}|x) = \min{\left[P(\omega_{1}|x), P(\omega_{2}|x)\right]}$
If $p(x|\omega_{1})P(\omega_{1}) > p(x|\omega_{2})P(\omega_{2})$ decide $\omega_{1}$ otherwise, decide $\omega_{2}$.
Two conditions to consider:
Bayes Rule combines these factors to minimize error.
The error is the likelihood of making the wrong classification.
We can extend this to risk or loss, which is the “cost” of a wrong classification.
Recall the Kronecker delta or impulse function:
$\delta_{ij} = \begin{cases} 1 & \quad \textrm{if } i=j\\ 0 & \quad \textrm{otherwise} \end{cases}$
We can use this to define our loss function.
If we express our loss as a simple “Right” or “Wrong”, then we have the zero-one loss function:
$ \lambda(\alpha_{i}|\omega_{j}) = \begin{cases} 0 & \textrm{if } i=j\\ 1 & \textrm{if } i\neq j \end{cases} \quad\textrm{for } i,j = 1,\dots,c $
Translation:
In this case, the zero-one loss is the inverse of the delta function, i.e. $|1-d_{ij}|$.
Expected Loss is the average loss for an action for all possible classes: $ \begin{aligned} R(\alpha_{i}|\mathbf{x}) & = \sum_{j=1}^{c}\lambda(\alpha_{i}|\omega_{j})P(\omega_{j}|\mathbf{x}) \\ R(\alpha_{i}|\mathbf{x}) & = \sum_{j\neq i} P(\omega_{j}|\mathbf{x}) \\ R(\alpha_{i}|\mathbf{x}) & = 1 - P(\omega_{i}|\mathbf{x}) \end{aligned}$
This is also the conditional risk, because the risk “depends on” the feature vector $\mathbf{x}$.
$ R(\alpha_{i}|\mathbf{x}) = 1 - P(\omega_{i}|\mathbf{x}) $
We can take the action that minimizes risk by choosing the class that maximizes $P(\omega_{i}|\mathbf{x})$.
This is the same as Bayes Rule: You are taking the action associated with the most “likely” class.
More generally, let’s assume there are $a$ different actions that we can take, denoted $\alpha_{1}, \alpha_{2}, \dots, \alpha_{a}$.
Note that $a$ doesn’t have to equal $c$, the number of classes!
Define a decision rule $\alpha(\mathbf{x})$ to be a decision rule that maps a $d$-dimensional feature vector $\mathbf{x}$ to an action: $\mathbb{R}^{d}\mapsto{\alpha_{1},\alpha_{2},\dots,\alpha_{a}}$.
The overall risk for this rule over all $\mathbf{x}$ is calculated as the integral: $ R = \int R(\alpha(\mathbf{x}) | \mathbf{x}) p(\mathbf{x}) d\mathbf{x} $
The Bayes Decision Rule: we should take the action that minimizes the conditional risk:
$\alpha^{\star}=\textrm{arg min}_{\alpha_{i}} R(\alpha_{i}|\mathbf{x}) = \textrm{arg min}_{\alpha_{i}} \sum_{j=1}^{c}\lambda(\alpha_{i}|\omega_{j})P(\omega_{j}|\mathbf{x})$
Let’s simplify the problem problem to two classes, and assume only two possible actions:
$\lambda_{ij} = \lambda(\alpha_{i}|\omega_{j})$ is the loss incurred when $\alpha_{i}$ is taken and the class is $\omega_{j}$.
The conditional risk, $R(\alpha_{i}|\mathbf{x})$, becomes:
$ \begin{aligned} R(\alpha_{1}|\mathbf{x}) &= \lambda_{11}P(\omega_{1}|\mathbf{x}) + \lambda_{12}P(\omega_{2}|\mathbf{x}) \\ R(\alpha_{2}|\mathbf{x}) &= \lambda_{21}P(\omega_{1}|\mathbf{x}) + \lambda_{22}P(\omega_{2}|\mathbf{x}) \end{aligned} $
The Fundamental Rule is that we can choose the class that has the smallest risk:
Decide $\omega_{1}$ if $R(\alpha_{1}|\mathbf{x}) < R(\alpha_{2}|\mathbf{x})$ and decide $\omega_{2}$ otherwise.
We can rewrite this in terms of the posteriors:
Decide $\omega_{1}$ if $(\lambda_{21} - \lambda_{11})P(\omega_{1}|\mathbf{x}) > (\lambda_{12} - \lambda_{22})P(\omega_{2}|\mathbf{x})$
And finally, we can rewrite in terms of Bayes Rule:
Decide $\omega_{1}$ if $(\lambda_{21} - \lambda_{11})p(\mathbf{x}|\omega_{1})P(\omega_{1}) > (\lambda_{12} - \lambda_{22})p(\mathbf{x}|\omega_{2})P(\omega_{2})$
It makes sense that the loss for making a mistake is greater than the loss for getting something correct.
In other words, if the true class is $\omega_{1}$, then the loss for guessing class $\omega_{2}$, which is $\lambda_{21}$, is greater than the loss for guessing $\omega_{1}$, or $\lambda_{11}$.
This means that $(\lambda_{21} - \lambda_{11})$ and $(\lambda_{12} - \lambda_{22})$ are positive.
If we make that assumption, we can write the relationship between the PDFs as:
$\frac{p(\mathbf{x}|\omega_{1})}{p(\mathbf{x}|\omega_{2})} > \frac{\lambda_{12}-\lambda_{22}}{\lambda_{21}-\lambda_{11}}\frac{P(\omega_{2})}{P(\omega_{1})}$
$\frac{p(\mathbf{x}|\omega_{1})}{p(\mathbf{x}|\omega_{2})} > \frac{\lambda_{12}-\lambda_{22}}{\lambda_{21}-\lambda_{11}}\frac{P(\omega_{2})}{P(\omega_{1})}$
Why do we want to do this?
We can set a threshold, $\theta_{a}$, corresponding to a zero-one (symmetrical) loss function. In this case, our errors are equally weighted.
If $\lambda_{21} > \lambda_{12}$, then when we guess $\omega_{2}$ and are wrong, the loss is greater than when we guess $\omega_{1}$ and are wrong.
We might want to adjust our threshold to decrease the number of samples we call $\omega_{2}$.
In other words, we “prefer” to make the other mistake (taking action $\alpha_{1}$ when the class is $\omega_{2}$).
In medicine, this is like preferring to over treat rather than under treat a patient.
By adjusting our threshold from $\theta_{a}$ to $\theta_{b}$, we shrink region $\mathcal{R}_{2}$ and enlarge region $\mathcal{R}_{1}$. In other words, we classify more of $x$ as $\omega_{1}$.
Discriminant Functions are a set of $c$ functions, one for each class, that map a $d$-dimensional feature vector $\mathbf{x}$ to a value.
For $g_{i}(\mathbf{x})$, where $i=1,\dots,c$, the classifier assigns $\mathbf{x}$ to class $\omega_{i}$ if:
$ g_{i}(\mathbf{x}) > g_{j}(\mathbf{x}) \textrm{ for all } i\neq j $
How do we get $g_{i}(\mathbf{x})$?
We can use any function, as long as the value is highest for the correct class.
For example, we can tie $g_{i}(\mathbf{x})$ to the risk associated with action $\alpha_{i}$:
$ g_{i}(\mathbf{x}) = -R(\alpha_{i}|\mathbf{x}) $
The action with the lowest risk has the highest value for $g(\cdot)$, and vice-versa.
The classifier will then assign the label corresponding to the action that carries the lowest risk.
If we assume a zero-one loss function, this generalizes to:
$ g_{i}(\mathbf{x}) = P(\omega_{i}|\mathbf{x}) $
So in this case, the highest posterior probability yields the highest discriminant function.
Thus, the classifier will always choose the class with the highest likelihood.
We can build different discriminant functions, which yield identical classifier results:
$ \begin{aligned} g_{i}(\mathbf{x}) &= P(\omega_{i}|\mathbf{x}) \\ g_{i}(\mathbf{x}) &= p(\mathbf{x}|\omega_{i})P(\omega_{i}) \\ g_{i}(\mathbf{x}) &= \ln{p(\mathbf{x}|\omega_{i})} + \ln{P(\omega_{i})} \end{aligned} $
The output of $g_{i}(\mathbf{x})$ doesn’t have any restrictions on it; they don’t all have to sum to 1, they don’t have to all be positive, etc.
If we replace $g_{i}(\mathbf{x})$ with $f(g_{i}(\mathbf{x}))$, where $f(\cdot)$ is monotonically increasing, then the classification results are the same.
The goal of a decision rule is to divide the feature space into decision regions, $\mathcal{R}_{1},\mathcal{R}_{2},\dots,\mathcal{R}_{c}$.
If $g_{i}(\mathbf{x}) > g_{j}(\mathbf{x})$ for all $j\neq i$, then $\mathbf{x}$ falls in region $\mathcal{R}_{i}$ and is assigned to $\omega_{i}$.
The size of the region, and samples assigned to that class, is driven by the loss functions.
If, for any $j\neq i$, $g_{i}(\mathbf{x}) = g_{j}(\mathbf{x})$, then $\mathbf{x}$ is on the decision boundary of $\mathcal{R}_{i}$ and $\mathcal{R}_{j}$.
This is all well and good for one feature, but how does it look with two?
When $c=2$ (two-class case), then we have just two functions, $g_{1}$ and $g_{2}$.
Instead of finding which is greater, we can define a combined discriminant function:
$ g(\mathbf{x}) \equiv g_{1}(\mathbf{x}) - g_{2}(\mathbf{x}) $
and now our decision is simply:
If $g(\mathbf{x})>0$, decide $\omega_{1}$; otherwise, decide $\omega_{2}$.
We can also create our alternative discriminant functions in this way:
$ g(\mathbf{x}) = P(\omega_{1}|\mathbf{x}) - P(\omega_{2}|\mathbf{x}) $
$ g(\mathbf{x}) = \ln{\frac{p(\mathbf{x}|\omega_{1})}{p(\mathbf{x}|\omega_{2})}} + \ln{\frac{P(\omega_{1})}{P(\omega_{2})}} $
These are equivalent to the previous examples with $c$ classes.
Since two-class problems are so common, you’ll often see the decision rule based on a positive or negative value for the discriminant function.
Why is Bayes so useful?
We haven’t gone into parameters yet, but assuming a Gaussian distribution makes a lot of things easier.
We have so far assumed that we have some way of modeling our feature data, going from a histogram to a function $p(x | \omega_{i})$.
In the next class, we will see how this modeling takes place by covering normal density in univariate and multivariate cases.
We will also cover how to compute decision surfaces, or how to set thresholds for your feature values to define your decision space.
Finally we’ll talk a little about entropy and information content of a signal – how much one signal (like a feature) tells you about another signal (like a class label).


DEFAULT
FIX SRC
REFRESH
SRC BINDING
COVER IMAGE
REFRESH INTERVAL
BASE URL
ROUND
CIRCLE
CREDENTIALS
RELATIVE


{% for picture in pictures %}
about: {{ picture.about }}
creador: {{ picture.owner }}
{{ comment.comments }}


This background will change because of the directive...
This will change some attributes depending of the mouse action.
This will change when the pointer is enter or leave the element.