Students and instructors need to have an intuitive way of centralizing course information and discussion to effectively communicate with each other and progress through the class.
During my time at college, I noticed that a lot of classes frequently use platforms such as Piazza to communicate important course information as well as serve as a hub for student questions and answers. These platforms greatly shorten the amount of time it takes for students to receive help on assignments and provide a means of deepening their understanding of course material through engaging discussions.
However, several of my fellow classmates and I came to agreement that the interface for the Piazza platform was inflexible, unaesthetic, and fairly unintuitive. This could be a major issue for many students as well as instructors, especially those who teach large class sizes, since a poorly-designed interface could impede the communication between them.
There was a lot that could be improved upon in terms of the site's design, and thus, during my second year of college, I was the front-end software development lead for a class project aimed at redesigning the Piazza interface to be more intuitive and sleeker.
Before we came up with our application and started development, we wanted to explore whether or not other students felt the same lack of intuitiveness from Piazza that our team did. We also wanted to hone in on specific aspects of the interface that could be improved or revised, so we spent some time researching those as well.
From sending out a survey to a large number of students and a few professors, we discovered several main pain points with Piazza:
Filtering and searching for posts can be buggy and inflexible — it can be difficult to find specific posts even with exact keywords, and filtering does not allow multiple parameters.
The interface lacks a cohesive aesthetic — many of the fonts are too small, and the current color options are limited and sometimes result in glitches.
Many interface components are unintuitive or unbeknownst to users — some features are somewhat awkward to users who haven't used them before, and other features go entirely unused.
After consolidating our research, we finally decided to settle on creating a full-stack web application aimed to showcase a potential redesign of Piazza. Our goal was to make sure that the application was slimmer both in terms of aesthetic and functionality to ensure that users would have a pleasant and uncluttered experience.
In order to differentiate our application from Piazza, we chose to focus on improving the searching and filtering functionalities. To do so, we framed the design of our app around a tagging system which would allow users to label their posts with tags and find posts based on those tags. This tagging system became our key feature, inspiring the name of our app, Tag.it.
In creating our solution, however, we also needed to keep in mind several ideas that came up during initial planning.
We didn't want to create an entirely different interface because we felt that Piazza's Q&A forum style was already pretty useful.
We needed to make sure that text and interface components were easy to see and uncluttered throughout the whole development process.
Before we started developing, we created several design documents, such as a list of use cases and user stories, to help guide our thoughts and ensure that our application was meeting the goals we set for ourselves.
As a project for a software engineering class, Tag.it was developed with a very programming-centric mindset, employing the use of many different technologies and practices commonly found in the software engineering industry. We split up work into two main areas of focus, front-end and back-end development.
For front-end development, we chose to develop the interface using React, HTML, CSS, and JavaScript. Although our front-end developers, including myself, initially didn't have too much experience with React, we quickly ramped up and started writing barebones components.
With the back end, our developers mainly used Node.js and Express to set up the necessary REST API endpoints, as well as Firebase for our primary database to store application information such as posts and users.
Besides front-end and back-end technologies, we also utilized the Mocha and Chai testing libraries to ensure proper feature functionalities. Additionally, we used Git and Github for version control and Netlify and Heroku for deployment of our code to production.
Week by week, we slowly built up our site, first wireframing all of our application's screens, then adding onto them with smaller interface components to handle required user interactions. As we were building front-end components, we also connected them to the back-end API endpoints we developed to finalize functionalities. Lastly, we fine-tuned our initial database schemas to streamline the loading of data, especially in regards to posts.
Throughout our development process, we frequently tested features to ensure that they worked as the project continued to be built and components were added. Once we were almost ready to deploy to production, we spent a week on user testing to squash any remaining bugs. Additionally, we allowed some external user testers play around with the app to see if they had any feedback on features that needed to be tweaked or improved upon.
After 10 weeks of hard work, we created a fully functional web application that worked similarly to Piazza, albeit with a cleaner aesthetic and more flexibility in terms of post interactions, especially searching and filtering by tags. Some of the features we included were:
Ability to find posts by search bar or by selecting tags
Fully functioning post editor with Markdown support
Interactive comment-reply system with upvoting similar to Reddit
Ability for instructors to manage course tags and staff
Ability to add multiple courses and invite students to a course using an invitation link
In the end, we created a successfully deployed app that we were all proud of. Although we didn't quite meet all of the specifications we set for ourselves at the beginning of the project, we learned a great deal about agile software development and what it means to put into practice proper software engineering principles. I, myself, improved my own knowledge of full-stack development and technologies such as React and Node.js.
Moreover, we learned how to improve and redesign an already existing site while also taking into account "good" features that don't need to be revamped. And overall, we learned the immense work that goes into building platforms like Piazza, as well as keeping in mind the needs of students and instructional staff alike.
You can check out the project's source code on Github.


Derek Eder
@derekeder
48 hack nights
4 community events
2 honorific resolutions
72 breakout groups
15 new co-hosts
35 presentations from:
3 candidates for governor
5 elected officials
15 gov agencies
25 local orgs
This is the @chihacknight 2017 year in review!
https://chihacknight.org/blog/2018/01/04/2017-year-in-review.html
1/4/2018, 3:53:32 PM
Favs: 31
Retweets: 5
link


Concepts definition
Lowering this value will lower latency but may decrease the player's ability to build a stable buffer.

Maximum catch-up rate, as a percentage, for low latency live streams.
Use this parameter to set the maximum threshold for which live catch up is applied. For instance, if this value is set to 8 seconds, then live catchup is only applied if the current live latency is equal or below 8 seconds. The reason behind this parameter is to avoid an increase of the playback rate if the user seeks within the DVR window.


*Maximum: 25.2 L x 19.9 W x 15.0 H centimeters
*Save .stl file as .makerbot file
*Position the object flat on the building plotform
I decided to create a ball with a hollow interior. I designed a box, using Fusion 360.
This is what the ball looks like after printing.
I'm so happy that it came out exactly as I wanted to be.
Using Knockout Concepts Mobile scanner, I scanned myself and made a 3D model of myself.
I brought it down to a miniature size (1:55) and saved as a .makerbot file
This is my final product!


18 December 1998
Disease Outbreak Reported
A significant increase in the number of cases of acute diarrhoea has been reported to WHO by Médecins sans frontières (Spain), who have opened their cholera treatment centre in North Mogadishu as a result. An average of 14 cases are being admitted daily to this facility. There have also been reports of a considerable increase in the number of cases of acute diarrhoea admitted to Benadir hospital in South Mogadishu since mid-November. Of 22 stool samples tested, 20 were positive for cholera. In areas surrounding Mogadishu, there has been no significant increase in acute diarrhoea cases.


{% extends "_template.html" %} {% block container %} {{ super() }}
Sign in to your Nextzen account to manage API keys
Continue with Facebook
Continue with Google
Continue with GitHub


CPU Traffic
10
%
Likes
41,410
Sales
760
New Members
2,000
CPU Traffic
10
%
Likes
41,410
Sales
760
New Members
2,000
CPU Traffic
10
%
Likes
41,410
Sales
760
New Members
2,000
CPU Traffic
10
%
Likes
41,410
Sales
760
New Members
2,000


Manage Categories
Manage Products
Go to Store
Welcome to Store Admin
Categories Manager
Products Manager
Please add at least one category before adding a new product
Choose Category:
Product Title:
Product desc:
Favorite:
Price:
Image URL:
Delete Product


Classes | |
| struct | Winnie::Statistic |
Functions | |
| void | GetAllocInfo (Statistic &statistic) |
| void * | Alloc (size_t size) |
| void | Free (void *p) throw () |
| void * | Realloc (void *p, size_t size) |
| size_t | MSize (void *p) |
| void | DesroyHeap () |
Variables | |
| const unsigned | max_lists_num = 31 |
|
|
|
|
|
free all consumed from OS memory and return to zero-initialized state. |
|
|
frees a memory block, which was allocated whith Winnie::Alloc |
|
|
return statistic info, if WINNIE_ALLOC_STATISTIC_ENABLED is true.
|
|
|
Returns actual number of bytes in allocated block, which can be more than requested by user. |
|
|
Reallocate memory blocks
|
|
|
number of free block lists, which holds blocks of size 1, 2, 4, 8, ..., 2GB |


Perks Coffee Shop is a unique café located in the UCSD Bookstore next to Imprints. Upon entering you will be welcomed by the warmth of our talented Baristas and Perky the Squirrel. The Perks environment is also a perfect study spot where we offer a range of seats from individual study tables, group tables, and a cozy corner equipped with a fireplace for de-stress.
Perks brews and serves only Barefoot Coffee Roasters coffee. All of Barefoot coffees are direct trade. Our pastries, salads, and sandwiches are prepared fresh locally. We guarantee the finest flavors, quality ingredients, and an unparalleled customer service experience.
Whether it’s breakfast, lunch or a mid-day gathering, include a scrumptious selection of muffins, cakes, tarts, cookies and bars. Perks is your ideal partner for every size meeting and department get together.


The package implements a general algorithm to obtain iterated bootstrap tests and confidence sets for a p-dimensional parameter based on the unstudentized version of the Rao statistic.
| Version: | 0.1-1 |
| Published: | 2013-02-15 |
| Author: | Nicola Lunardon |
| Maintainer: | Nicola Lunardon <nicola.lunardon at econ.units.it> |
| License: | GPL-2 |
| NeedsCompilation: | yes |
| Citation: | Iboot citation info |
| CRAN checks: | Iboot results |
| Reference manual: | Iboot.pdf |
| Package source: | Iboot_0.1-1.tar.gz |
| Windows binaries: | r-devel: Iboot_0.1-1.zip, r-release: Iboot_0.1-1.zip, r-oldrel: Iboot_0.1-1.zip |
| OS X binaries: | r-release: Iboot_0.1-1.tgz, r-oldrel: Iboot_0.1-1.tgz |
Please use the canonical form https://CRAN.R-project.org/package=Iboot to link to this page.


WITNESS LIST Transportation (Interim) Committee November 5, 1997-2:00P Transportation On: Mr. David Laney (TTC, TXdot), Dallas Ms. Cassie Carlson Reed (TxDot), Austin


Bombardier says to deliver all Swiss Railways trains by mid-2021
ZURICH: Bombardier said on Wednesday (Nov 6) it had alleviated technical problems that have held up deliveries of trains to Swiss Federal Railways (SBB) as the Canadian plane-and-train-maker aims to complete the long-delayed contract by mid-2021.
The company said the reliability of the 23 trains in operation had increased by a factor of seven in recent weeks and ride comfort had substantially improved thanks to new software.
Bombardier said last week it was on track to complete a handful of large rail contracts, including the Swiss order, that have weighed on margins as it restructures.
Bombardier and SBB had said in May they were making progress in resolving technical problems with the trains, with Bombardier's chief executive telling analysts last week that the Swiss railways had 23 in service.
"Bombardier has now delivered a total of 25 of the FV-Dosto trains, which is in line with the defined delivery schedule. By summer 2021, the entire fleet of (62) trains will have been delivered," the company said in a statement on Wednesday.
SBB awarded Bombardier the 1.9 billion Swiss franc (US$1.91 billion), 59-train contract in 2010, but the first deliveries were made only in 2018. Amid problems, Bombardier agreed to add three more trains free of charge as compensation.
The Swiss contract for the trains calls for undisclosed penalty payments in the event of delays, but the SBB has not given any details so far.


On 8 May 2018, WHO was notified by the Ministry of Health of the Democratic Republic of the Congo of two confirmed cases of Ebola virus disease occurring in Bikoro health zone, Equateur province.
From 4 April through 9 May 2018, a total of 32 Ebola virus disease cases (among which two are confirmed, 18 probable and 12 suspected cases) were reported from Bikoro health zone, Equateur province, including 18 deaths. Three of the 32 cases were among healthcare workers. The patients presented with fever, diarrhoea, abdominal pain, myalgia and arthralgia, and some also showed haemorrhagic signs and symptoms. All cases were reported from the catchment area of the Ikoko-Impenge health facility, located 30 km from the central health zone office of Bikoro, which is 280 km by road from Mbandaka, the capital of Equateur province. Of the 21 initially reported cases on 8 May 2018, 17 had epidemiological links (potential contacts with another suspect case).
Five samples were collected from hospitalized patients, three from Ikoko-Impenge and two from Bikoro. These were sent to Institute National de Recherche Biomédicale in Kinshasa on 7 May 2018, where the two samples from Ikoko-Impenge were found positive by reverse transcriptase polymerase chain reaction (RT-PCR) assay for Ebola virus on the same day.
Over the last four decades, the Democratic Republic of Congo has experienced eight Ebola outbreaks. The most recent epidemic took place in May 2017 in the health zone of Likati, province of Bas-Uele. The ongoing epidemic is located in the Bikoro health zone, located in Equateur province, in western Democratic Republic of the Congo and on the border with the Republic of Congo. This is the fourth time that an Ebola outbreak has been reported in the former province of Equateur, following those of 1976, 1977 and 2014. However, this is the first time that the Bikoro health zone is facing an Ebola outbreak.
The province of Equateur has an estimated population of 2.5 million people with 284 registered health facilities. Bikoro health zone has a population of around 163 000 people with three hospitals and 19 health centres covering the population, most with limited functionality. Medical supplies are provided by international bodies, but stock outs are frequent.
To date, the outbreak is reported in a remote area and appears to be geographically limited. However, in view of the available data, the overall risk is considered high at the national level due to the nature of the disease and the lack of epidemiological and demographic information to estimate the magnitude of the epidemic.
The overall risk at the regional level is considered moderate because of the proximity to the Congo river, which links with both the capitals of the Republic of the Congo and the Central African Republic.
Information is currently limited and investigations are ongoing to assess the full extent of the outbreak. Based on the information currently available and the rapid response measures implemented by the Ministry of Health in collaboration with WHO and partners, the event does not meet the criteria of a public heath emergency of international concern as defined in the IHR (2005)1, and does not warrant the convening of an Emergency Committee under the IHR (2005).
WHO advises against any restriction of travel and trade to Democratic Republic of the Congo based on the currently available information. WHO continues to monitor travel and trade measures in relation to this event, and currently there are no restrictions of the international traffic in place.
For more information on Ebola virus disease, please see the link below:
1 “Public health emergency of international concern” means an extraordinary event which is determined, as provided in these Regulations: (i) to constitute a public health risk to other States through the international spread of disease and (ii) to potentially require a coordinated international response”. International Health Regulations (2005).


Configure > Mruby Directives
The following are the configuration directives of the mruby handler. Please refer to Using mruby to find out how to write handlers using mruby.
- Description:
-
Upon start-up evaluates given mruby expression, and uses the returned mruby object to handle the incoming requests.
mruby.handler: | Proc.new do |env| [200, {'content-type' => 'text/plain'}, ["Hello world\n"]] end
Note that the provided expression is evaluated more than once (typically for every thread that accepts incoming connections).
- Level:
- path
- See also:
mruby.handler-file
- Description:
-
Upon start-up evaluates given mruby file, and uses the returned mruby object to handle the incoming requests.
mruby.handler-file: /path/to/my-mruby-handler.rb
Note that the provided expression is evaluated more than once (typically for every thread that accepts incoming connections).
- Level:
- path
- See also:
mruby.handler


'GET ON WITH IT'
Celtic WAG Helen Flanagan hits back after being mum-shamed for ‘moaning’ about stress of having kids
by Jamie DownhamHELEN Flanagan has hit back at a follower who mum-shamed her for what they called "moaning" about the stress of parenting.
The 29-year-old Coronation Street star shared a message she had received telling her: "Stop ranting about ur kids!"
It went on: "Buckle up and get on with it!!! There are some people who are unable to conceive then u have people like urself moaning!
“It’s part of the process get on with it and stop RANTING! Which is what your doing."
Helen shared the tirade with her Instagram followers replying: "I have friends very close to me who have struggled to conceive."
Addressing her critic directly, she said: "Actually. I am honest on my instagram so other mums can identity with me and feel less on their own."
The exchange appears to have been sparked after Helen said she was hiding in her bathroom for a moment of quiet away from her children.
She had written: "To get an peace at the moment I have to lock myself in the toilet… any other mums do the same?"
In a second post of a muffin she'd bought, the star said: “Delilah screamed so much in the car today I was so stressed I had to stop at Costa drive thru and inhale this.”
Helen has two daughters - Matilda, four, and Delilah, one - with 30-year-old footballer Scott Sinclair.


Hey there!
Unfortuantely I don't have anything available to show you at the moment... but when I share my projects in the future, they shall be listed here!


{% extends "base.html" %} {% block css %} {% endblock %} {% block precontent %}
{% endblock %} {% block content %}I am a dedicated developer who likes to constantly learn new skills. I regularly review my code and as such rewrites and huge refactors are common. Starting off with web development and moving into Minecraft modding I have a wide knowledge of programming. Most of my skills are in Web (HTML, CSS, Golang) and Java.


Trial of a man accused of forcing a girl into sex work starts before High Court Judge Justice Daniel Goundar
by Semi TuragaThe trial of a man accused of forcing a girl into sex work has started before High Court Judge Justice Daniel Goundar.
This morning, Josevata Werelagi pleaded not guilty to the charges laid against him.
He pleaded not guilty to 3 counts of Domestic Trafficking in Children and 1 count of Aggravated Sexual Servitude.
The man also denied an alternative count of Selling Minors Under the Age of 18 years for the Purposes of Prostitution.
According to charges filed by the Director of Public Prosecutions, Werelagi allegedly threatened or forced a 15-year-old to enter into or remain on sexual servitude between 18th to 22nd July 2015.
He also allegedly facilitated the transportation of the 15 year old girl from Nausori to Rewa Street in Suva, with the intent that the girl will be used to provide sexual services.
The girl who is now 18 years old is currently giving evidence in closed court.


| SI |
Institute |
Address |
Verified |
Contact
Number |
Website |
Email |
| 1 |
Samyuktha
Gowda Saraswatha Sabha |
16,
Habibulla Road, T.Nagar, Chennai - 600017 |
No |
|
|
|
| 2 |
GSB Sabha |
President, GSB Sabha, Kurla Chembur, Ghatkopar,
Near Railway Station, Balaji Mandir, Kurla, Mumbai - 400070 |
No |
|
|
|
| 3 |
Sri
Kashimutt Samsthan |
Welfare
Fund, Regd. Office, Sukratindra Sabha Sadan, SLV Temple, Udupi - 576101 |
No |
|
|
|
| 4 |
M/s.Srinivasa Kalyana Mantap Trust |
Off: No 9, Sri Ganesh Building, 4th cross Link Road,
P O Box no 386 , Malleswaram 8th cross post office, Malleshwaram,
Bengaluru -560003 |
Yes |
|
|
<EMAIL_ADDRESS>|
| 5 |
Sri
Venkatesh Seva Dal |
Secretary,
Sri Venkatesh Seva Dal, Sri Narasimha Kripa, V.T 1st Cross, Udupi - 576101 |
No |
|
|
|
| 6 |
S.J Jindal Education Trust |
Jindal Nagar, Tumkur Road, Bengaluru - 560073 |
No |
|
|
|
| 7 |
Sri
Rama Seva Sangh |
Sri
Pattabhi Ramachandra Temple, Koteshwar, Karnataka - 576222 |
No |
|
|
|
| 8 |
Sri P.Dayananda Pai and Sri P.Satish Pai Trust |
10/1, Sri Laxmi Narayana Complex, Palace Road,
Bengaluru - 560052 |
No |
|
|
|
| 9 |
A.S.R.P
Memorial Fund |
Canara
High School, Dongerkery, Mangalore - 575003 |
No |
|
|
|
| 10 |
The GSB Scholarship League |
Dwarakanath Bhawan, Katrak Road, Wadala, P.B No
- 7115, Mumbai - 400031 |
No |
(022)24100048 |
https://www.gsbscholarshipleague.org/ |
<EMAIL_ADDRESS>|
| 11 |
Premdas
Charitable Trust |
Sri
Ram Nayak, Mahamaya Temple, Bantwal - 574211, Karnataka |
No |
|
|
|
| 12 |
Sri Laxmi Venkataramana Seva Trust |
S.V. Temple, Padubidri - 574111, Karnataka. |
No |
|
|
|
| 13 |
Kamala
Bai Kundapur Memorial Trust |
Nalanda
House, 101-VI, Main Road, Kundapur - 576201 |
No |
|
|
|
| 14 |
Vishwa Konkani Vidhyarthi Vetan Nidhi |
President, Vishwa Konkani Vidhyarthi Vetan
Nidhi, Vishwa Konkani Kendra, Shaktinagar, Mangaluru - 575016 |
No |
|
https://vishwakonkani.org/scholarships/ |
|
| 15 |
Sri
Sathyadevatha Dharmadevatha Trust |
Main
Road, Gurpur - 574145, Karnataka |
No |
|
|
|
| 16 |
Gowda Saraswath Samaj |
Saraswath Samskriti Bhavan, Geetha Mandir, New
Rajendra Nagar, New Delhi - 110060 |
No |
|
|
|
| 17 |
K.G.K.
Shenoy Memorial Fund |
New
Tajmahal Cafe Pvt. Ltd. Carstreet, Mangaluru - 575001 |
No |
|
|
|
| 18 |
Ideal Charitable Fund |
Ideal's, Market Road, Mangaluru - 575001 |
No |
|
|
|
| 19 |
Kumbla
Ramdas Rangappa Nayak Memorial Trust |
Shanthi,
Old Kent Road, Pandeshwar, Mangalore - 575010 |
No |
|
|
|
| 20 |
Shree Sudheendra Foundation |
Ganesh Tower, T.B.Road Junction, Kanhangad -
671315 |
No |
|
|
|
| 21 |
Sri
Navadurga Seva Charitable Trust |
C/O
S.B. Kamath, Bajpe, Dakshina Kannada - 574142 |
No |
|
|
|
| 22 |
Shri Veera Venkatesha Charitable Trust |
Shri Venkataramana Temple, Carstreet, Mangaluru
- 575001 |
No |
|
|
|
| 23 |
Srimad
Keshavendra Tirtha Swami Charitable Trust |
Sri
Lakshmi Venkatesha Temple, V.T. Road, Udupi - 576101 |
No |
|
|
|
| 24 |
Gopalakrishna Kamath and Radhabai Memorial
Trust |
The Secretary, Gopalakrishna Kamath and
Radhabai Memorial Trust, Manipal - 576104 |
No |
|
|
|
| 25 |
Sri
K. Krishna Raya Kini |
Sri
K. Krishna Raya Kini, F-2, Prashanth Apartments, No-63, 2nd Main, Prashanth
Nagar, Bengaluru - 560079 |
No |
|
|
|
|
|
|
|
|
|
|


XCWebPlan is an open source program written almost entirely in Javascript (with a bit of php to interrogate the airspace database). It is based on Google Maps and makes use of their javascript apl.
Credits
Program code
The Javascript code for the application itself was mostly written by Richard Brisbourne, with help and support from Alistair Green. Copyright is held Richard Brisbourne; for further information for how to access the source code see below, for information on how you are entitled to make use of it see the licence.
Apart interacting Google Maps api, it also uses some other libraries and plugins:
- JQuery- a javascript library well-known to web developers
- Infobox- from the Google Maps utility library
- DCalendar- JQuery plug-in used for picking dates
Data
Maps and satellite images are from Google Maps.
Airspace data is drawn from a number of places, the largest being soaringweb.org. Unfortunately very little is available in computer-readable format from official sources so we are dependant on people who work voluntarily to create the files we all use in our software, both on the ground and in our gliders, and who deserve more credit than they often get. The data is held in tables on the server, so has been arrived at by conversion of some of these files. In some cases copyright has been asserted on the files, in those cases there are links below to the originals containing copyright statements. In no case have we used anything that is not licensed for non-commercial use:
- Brazil- Durval Henke and Thomas Milko.
- Canada- Peter Spier
- Croatia- Henrik Knoblauch
- Denmark- Felipe Cvitanich
- Estonia- Christoph Gauss
- Finland- Tero Tikkanen
- France- Marc Seretti
- Germany- Peter Kemme
- Great Britain- Geoff Brown
- Hungary- Tamas Gal
- Ireland- Kevin Houlihan
- Latvia, Lithuania- Andrejs Kivackis
- Macedonia- Remko Bolt
- Netherlands- Maurits Dortu
- Norway- Hans Cato Grytnes, Nils Barkald, Ole Bårdtvedt, Lars Rune Bjørnevik, Arne Martin Güettler and Agnar Renolen.
- Poland- Artur Jan Tenenberg
- Slovakia- Ján Hrncírik via Klaus Ertl
- Slovenia- Georg Falkensammer
- Spain- Durval Henke
- Switzerland- Reinhold Mueller
Developers
Source code is on GitHub.If you are interested please free to fork - we look forward to the pull requests. For general correspondence and thoughts (technical or otherwise) please use the issue tracker or send an e-mail to igcwebview@glidingweb.org.


Calling all EOS Token Holders - Get Ready for the eosDAC Snapshot
eosDAC is a leading EOS Block Producer candidate. Currently run by a twelve person ‘launch team’ spanning three continents. eosDAC is preparing to launch as a Decentralised Autonomous Community (DAC) on the EOS blockchain in early June.
A DAC is owned and controlled by it’s token holders, so eosDAC will be airdropping 75% of it’s tokens directly to the EOS token-holders worldwide. In this way eosDAC will be the Community-Owned EOS Block Producer.
The snap-shot of all EOS token holders will be taken on the 15th April at 01:00:00 UTC and the airdrop of eosDAC tokens at a rate of 1:1 will be made according to EOS token ownership at the point of this snapshot. The airdrop itself will follow in late April / early May.
How do you make sure you get your eosDAC Tokens?
If you have over 100 EOS tokens and you hold your EOS tokens in a wallet for which you control the private key (for example a hardware wallet, my etherwallet, metamask etc) then the GOOD NEWS is that you will automatically receive your EOS tokens, there is nothing further you need to do.
If you have less than 100 EOS tokens and you hold your EOS tokens in a wallet for which you control the private key, then sign-up to our newsletter and after the snap-shot we will inform you how you can collect your tokens.
What about if your EOS if on an exchange?
If you hold your EOS tokens on a crypto exchange then you will not automatically receive your free eosDAC tokens. Either you need to move your tokens out to a wallet for which you control the private key or you will need to write to your exchange to ask them to confirm that they will be distributing the eosDAC airdropped tokens.
At time of writing only Upbit (the second largest exchange in trading of EOS) has confirmed that they will be taking their own snapshot on the 15th April and distributing eosDAC tokens to their customers - https://steemit.com/eos/@eosdac/eosdac-april-airdrop-eos-holders-relieved-as-exchange-aligns-for-snapshot
It is most unlikely that your exchange will distribute eosDAC tokens to you unless they confirm this publicly BEFORE the April 15th snapshot! Therefore if you are holding your EOS tokens on an exchange please contact them immediately (via a support ticket) to demand they distribute your eosDAC tokens, a suggestion of what you might write follows below:
To whom it may concern,
I currently have EOS tokens on your exchange. On the 15th April at 01:00 UTC, a leading EOS Block Producer candidate, eosDAC (https://eosdac.io), will be airdropping 75% of it’s tokens to EOS token holders worldwide at a rate of 1:1.
Please confirm to me as soon as possible that you will also be taking this snapshot and then distributing the eosDAC tokens to your customers once you receive them from eosDAC in late April / early May.
If you are unable to support this airdrop, whose tokens I believe will be of significant value, then I will have to move my EOS tokens off your exchange to another exchange that will be distributing these tokens, or to a wallet for which I control the private key,
With much appreciation
Please make sure you are signed up to our newsletter and we will announce any exchanges that confirm that they will be distributing the eosDAC airdropped tokens. We will also list this on our Tokens page http://eosdac.io/tokens
More about eosDAC
It is the vision of eosDAC that EOS.IO block production should be open for everyone to contribute and benefit. To realise this vision, eosDAC will be an evolving Decentralised Autonomous Community (DAC) focused on becoming a leading EOS.IO Block Producer serving the EOS communities worldwide. In doing this, eosDAC will create the tools and smart contracts it needs to function. It will share these with the EOS communities to help other DACs thrive on the EOS.IO blockchains.
eosDAC is currently expanding operational facilities, all of which will be fully implemented before the end of May. The key strategy is to achieve a wide geographic and jurisdictional coverage with block-production infrastructure to be located in the United Kingdom, Romania, Gibraltar and South Korea. The Launch Team will use its considerable experience of high-level data centre operation and Tier 1 internet working design & implementation to ensure shortest latency, maximum efficiency and solid redundancy within our network architecture.
Leading up to the launch of the EOS blockchain, the governance of eosDAC will be handled via the launch team, appointed by BlockMaker Ltd. Following the successful launch of eosDAC as a Block Producer on an EOS.IO blockchain, the token holders will able to vote for a roadmap towards direct or delegated governance.
For more information on eosDAC, please see https://eosdac.io/


Class: Concurrent::Delay
- Inherits:
-
Synchronization::LockableObject
- Object
- Synchronization::LockableObject
- Concurrent::Delay
- Includes:
- Concern::Obligation
- Defined in:
- lib/concurrent/delay.rb
Overview
The default behavior of Delay
is to block indefinitely when
calling either value
or wait
, executing the delayed operation on
the current thread. This makes the timeout
value completely
irrelevant. To enable non-blocking behavior, use the executor
constructor option. This will cause the delayed operation to be
execute on the given executor, allowing the call to timeout.
Lazy evaluation of a block yielding an immutable result. Useful for
expensive operations that may never be needed. It may be non-blocking,
supports the Concern::Obligation
interface, and accepts the injection of
custom executor upon which to execute the block. Processing of
block will be deferred until the first time #value
is called.
At that time the caller can choose to return immediately and let
the block execute asynchronously, block indefinitely, or block
with a timeout.
When a Delay
is created its state is set to pending
. The value and
reason are both nil
. The first time the #value
method is called the
enclosed opration will be run and the calling thread will block. Other
threads attempting to call #value
will block as well. Once the operation
is complete the value will be set to the result of the operation or the
reason will be set to the raised exception, as appropriate. All threads
blocked on #value
will return. Subsequent calls to #value
will immediately
return the cached value. The operation will only be run once. This means that
any side effects created by the operation will only happen once as well.
Delay
includes the Concurrent::Concern::Dereferenceable
mixin to support thread
safety of the reference returned by #value
.
Copy Options
Object references in Ruby are mutable. This can lead to serious
problems when the #value of an object is a mutable reference. Which
is always the case unless the value is a Fixnum
, Symbol
, or similar
"primitive" data type. Each instance can be configured with a few
options that can help protect the program from potentially dangerous
operations. Each of these options can be optionally set when the object
instance is created:
:dup_on_deref
When true the object will call the#dup
method on thevalue
object every time the#value
method is called (default: false):freeze_on_deref
When true the object will call the#freeze
method on thevalue
object every time the#value
method is called (default: false):copy_on_deref
When given aProc
object theProc
will be run every time the#value
method is called. TheProc
will be given the currentvalue
as its only argument and the result returned by the block will be the return value of the#value
call. Whennil
this option will be ignored (default: nil)
When multiple deref options are set the order of operations is strictly defined. The order of deref operations is:
:copy_on_deref
:dup_on_deref
:freeze_on_deref
Because of this ordering there is no need to #freeze
an object created by a
provided :copy_on_deref
block. Simply set :freeze_on_deref
to true
.
Setting both :dup_on_deref
to true
and :freeze_on_deref
to true
is
as close to the behavior of a "pure" functional language (like Erlang, Clojure,
or Haskell) as we are likely to get in Ruby.
Instance Method Summary collapse
-
#complete? ⇒ Boolean
included
from Concern::Obligation
Has the obligation completed processing?.
- #exception(*args) ⇒ undocumented included from Concern::Obligation
-
#fulfilled? ⇒ Boolean
(also: #realized?)
included
from Concern::Obligation
Has the obligation been fulfilled?.
-
#incomplete? ⇒ Boolean
included
from Concern::Obligation
Is the obligation still awaiting completion of processing?.
-
#initialize(opts = {}) { ... } ⇒ Delay
constructor
Create a new
Delay
in the:pending
state. -
#pending? ⇒ Boolean
included
from Concern::Obligation
Is obligation completion still pending?.
-
#reason ⇒ Exception
included
from Concern::Obligation
If an exception was raised during processing this will return the exception object.
-
#reconfigure { ... } ⇒ true, false
Reconfigures the block returning the value if still
#incomplete?
. -
#rejected? ⇒ Boolean
included
from Concern::Obligation
Has the obligation been rejected?.
-
#state ⇒ Symbol
included
from Concern::Obligation
The current state of the obligation.
-
#unscheduled? ⇒ Boolean
included
from Concern::Obligation
Is the obligation still unscheduled?.
-
#value(timeout = nil) ⇒ Object
Return the value this object represents after applying the options specified by the
#set_deref_options
method. -
#value!(timeout = nil) ⇒ Object
Return the value this object represents after applying the options specified by the
#set_deref_options
method. -
#wait(timeout = nil) ⇒ Object
Return the value this object represents after applying the options specified by the
#set_deref_options
method. -
#wait!(timeout = nil) ⇒ Obligation
(also: #no_error!)
included
from Concern::Obligation
Wait until obligation is complete or the timeout is reached.
Constructor Details
#initialize(opts = {}) { ... } ⇒ Delay
Create a new Delay
in the :pending
state.
62 63 64 65 66 |
# File 'lib/concurrent/delay.rb', line 62 def initialize(opts = {}, &block) raise ArgumentError.new('no block given') unless block_given? super(&nil) synchronize { ns_initialize(opts, &block) } end |
Instance Method Details
#complete? ⇒ Boolean Originally defined in module Concern::Obligation
Has the obligation completed processing?
#exception(*args) ⇒ undocumented Originally defined in module Concern::Obligation
#fulfilled? ⇒ Boolean Also known as: realized? Originally defined in module Concern::Obligation
Has the obligation been fulfilled?
#incomplete? ⇒ Boolean Originally defined in module Concern::Obligation
Is the obligation still awaiting completion of processing?
#pending? ⇒ Boolean Originally defined in module Concern::Obligation
Is obligation completion still pending?
#reason ⇒ Exception Originally defined in module Concern::Obligation
If an exception was raised during processing this will return the
exception object. Will return nil
when the state is pending or if
the obligation has been successfully fulfilled.
#reconfigure { ... } ⇒ true, false
Reconfigures the block returning the value if still #incomplete?
146 147 148 149 150 151 152 153 154 155 156 |
# File 'lib/concurrent/delay.rb', line 146 def reconfigure(&block) synchronize do raise ArgumentError.new('no block given') unless block_given? unless @evaluation_started @task = block true else false end end end |
#rejected? ⇒ Boolean Originally defined in module Concern::Obligation
Has the obligation been rejected?
#state ⇒ Symbol Originally defined in module Concern::Obligation
The current state of the obligation.
#unscheduled? ⇒ Boolean Originally defined in module Concern::Obligation
Is the obligation still unscheduled?
#value(timeout = nil) ⇒ Object
The default behavior of Delay
is to block indefinitely when
calling either value
or wait
, executing the delayed operation on
the current thread. This makes the timeout
value completely
irrelevant. To enable non-blocking behavior, use the executor
constructor option. This will cause the delayed operation to be
execute on the given executor, allowing the call to timeout.
Return the value this object represents after applying the options
specified by the #set_deref_options
method. If the delayed operation
raised an exception this method will return nil. The execption object
can be accessed via the #reason
method.
77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 |
# File 'lib/concurrent/delay.rb', line 77 def value(timeout = nil) if @executor # TODO (pitr 12-Sep-2015): broken unsafe read? super else # this function has been optimized for performance and # should not be modified without running new benchmarks synchronize do execute = @evaluation_started = true unless @evaluation_started if execute begin set_state(true, @task.call, nil) rescue => ex set_state(false, nil, ex) end elsif incomplete? raise IllegalOperationError, 'Recursive call to #value during evaluation of the Delay' end end if @do_nothing_on_deref @value else (@value) end end end |
#value!(timeout = nil) ⇒ Object
The default behavior of Delay
is to block indefinitely when
calling either value
or wait
, executing the delayed operation on
the current thread. This makes the timeout
value completely
irrelevant. To enable non-blocking behavior, use the executor
constructor option. This will cause the delayed operation to be
execute on the given executor, allowing the call to timeout.
Return the value this object represents after applying the options
specified by the #set_deref_options
method. If the delayed operation
raised an exception, this method will raise that exception (even when)
the operation has already been executed).
113 114 115 116 117 118 119 120 121 |
# File 'lib/concurrent/delay.rb', line 113 def value!(timeout = nil) if @executor super else result = value raise @reason if @reason result end end |
#wait(timeout = nil) ⇒ Object
The default behavior of Delay
is to block indefinitely when
calling either value
or wait
, executing the delayed operation on
the current thread. This makes the timeout
value completely
irrelevant. To enable non-blocking behavior, use the executor
constructor option. This will cause the delayed operation to be
execute on the given executor, allowing the call to timeout.
Return the value this object represents after applying the options
specified by the #set_deref_options
method.
132 133 134 135 136 137 138 139 140 |
# File 'lib/concurrent/delay.rb', line 132 def wait(timeout = nil) if @executor execute_task_once super(timeout) else value end self end |
#wait!(timeout = nil) ⇒ Obligation Also known as: no_error! Originally defined in module Concern::Obligation
Wait until obligation is complete or the timeout is reached. Will re-raise any exceptions raised during processing (but will not raise an exception on timeout).


Troy University to study plastic recycling
TROY, Ala. (AP) - Alabama researchers are studying new ways to recycle plastics.
Troy University says its recently established Center for Material and Manufacturing Sciences has received a $2.7 million grant to look at new methods of recycling plastic waste.
A statement from the school says the money will pay for scientists and students to work on the project, plus equipment to do the work.
The grant is from the National Institute of Standards and Technology, which is part of the U.S. Commerce Department. It provided another grant of $3.2 million last year.
The research looks at ways to recycle polymers into new materials. Researchers will also study using hemp fiber to reinforce plastics and ways to test recycled material.
Sign up for Daily Newsletters
Copyright © 2019 The Washington Times, LLC.
Please read our comment policy before commenting.


Hello Memeness my old friend! yes, today we have some more memes fresh off the facebook mining campaign. These are tough to find with the levels of meme censorship. Some treasures in here. Pretty sure there’s going to be a few snowflakes Blooming today.
Military Industrial Complex dies if there is peace
Everything about her is a fraud
If you have a spare minute
Wonder what happened…
It’s probably nothing
Muh Music
Celebrate good times come on!
You get the jist?
I’d add closing backpage to the list
U1
Would be amazing!!!
Not cool popey mc pope face
Obummer
Black conservatives are dangerous
Hold Muh* beer
Millennials… you must choose
Not creepy at all
For fun… to whom it may concern
TV
Stay frosty
Same difference?
if you wonder where the money comes from
If you wonder where the votes come from
He forgot peace, but it’s a good start
That’s hot
Those bastards!!!
Yep… they traffick kids
Nope
VZ
Doing something right…

So metal
This page is synchronized from the post: ‘Meme the News 5/1/18’


{% extends "dashboard.html" %} {# Copyright (c) 2015-present, Philippine-California Advanced Research Institutes- The Village Base Station Project (PCARI-VBTS). All rights reserved. This source code is licensed under the BSD-style license found in the LICENSE file in the root directory of this source tree. #} {% load crispy_forms_tags %} {% load staticfiles i18n %} {% load mathfilters %} {% block dashboard-header %}
| Contact | Service | Type | Subscription Date | |
|---|---|---|---|---|
| {{ subscription.subscriber }} | {{ subscription.service}} | {{ subscription.service.get_type_display}} | {{ subscription.date_subscribed }} |


This is the very first post of the Cyber Security Club site! In the coming future this is where our newletters and blog posts will be
For now enjoy this quote from William Gibson’s Johnny Mnemonic
“We’re an information economy. They teach you that in school. What they don’t tell you is that it’s impossible to move, to live, to operate at any level without leaving traces, bits, seemingly meaningless fragments of personal information. Fragments that can be retrieved, amplified…”
Jesse Culver


Collegiate Internationals is an initiative of Collegiate Congress. As the leading student advocacy organization, Collegiate
Congress is a Non-Governmental Organization comprising representatives of college student governments. By developing
a cohesive voice, Collegiate Congress aims to lobby on behalf of otherwise separated constituents. Currently efforts
include working with MTA to develop a student discount, lobbying for better student health insurance, and gathering support
for an early voting system for city, state, and national elections.
Collegiate Internationals
organizes events which allow the students to
share their ideas & culture, create bonds and
build a professional network.
UNITAR
An autonomous UN body established in 1963, the United Nations Institute
for Training and Research (www.unitar.org) is a dedicated training arm of
the United Nations System, and has the mandate to enhance the
effectiveness of the UN through diplomatic training, and to increase the
impact of national actions through public awareness-raising, education and
training of public policy officials.
UNITAR provides training and capacity development activities to assist
mainly developing countries with special attention to Least Developed
Countries (LDCs), Small Island Developing States (SIDS) and other groups
and communities who are most vulnerable, including those in conflict
situations.
The Institute covers topics in the broad areas of Peace
(promote peaceful, just and inclusive societies), People and social
inclusion (promote people’s well-being and support equitable
representation of countries in global decision-making fora), Planet,
environmental protection and restoration, and climate change (Support the
conservation, restoration and safeguarding of our planet for present and
future generations), Prosperity through sustainable economic growth
(Promote inclusive and sustainable economic growth), and Cross-fertilizing
knowledge (Optimizing the use of technology and supporting coherence for
the 2030 Agenda).
It also conducts research on innovative learning approaches, methods, and
tools, as well as applied research to address critical issues, such as
disaster risk reduction and humanitarian emergencies.


C# Custom Attributes
We had a problem where a class was supplying data to the UI through a list. The UI had to know which properties in the class were the supplying data. I decided to use custom attributes to identify the properties. With some help of some code from my colleague Barry, I knocked up this sample to define and get the attributes. The Ordinal property is used to order the data series. C#, Custom Attribute [1], Reflection [2].
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using MbUnit.Framework;
using System.Reflection;
namespace AttributeDemo
{
[TestFixture]
public class AttributeDemoTest
{
[AttributeUsage(AttributeTargets.Property)]
public class Series : Attribute
{
public string PropertyName { get; set; }
public int Ordinal { get; set; }
public Series(int ordinal)
{
this.Ordinal = ordinal;
}
public static List<Series> GetSeries(Type type)
{
List<Series> allSeries = new List<Series>();
foreach (PropertyInfo property in type.GetProperties())
{
foreach (Attribute attribute in property.GetCustomAttributes(false))
{
if (attribute is Series)
{
Series series = (Series)attribute;
series.PropertyName = property.Name;
allSeries.Add(series);
}
}
}
return allSeries;
}
}
class AttributeExample
{
[Series(1)]
public string WarnCount { get; set; }
[Series(2)]
public string ErrorCount { get; set; }
}
[Test]
public void GetSeries_ShouldReturnTheSeriesAttributesFromTheType()
{
List<Series> allSeries = Series.GetSeries(typeof(AttributeExample));
Assert.AreEqual(2, allSeries.Count);
Series actual = allSeries.Find(s => s.Ordinal == 2);
Assert.AreEqual(2, actual.Ordinal);
Assert.AreEqual("ErrorCount", actual.PropertyName);
}
}
}


Hello world
This is a demo for the
constructible style sheet polyfill
.
Select text color
Choose font family
Change that stylesheet


Hi! My name is Machenzie Rogers and I am a web designer, illustrator and developer. Designing beautiful ways to improve commerce is my strongest passion, and my engineering degree specializing in art, graphics, and web networking gives me the core technical skills to do so with unrestricted flexibility. I work to produce works that come together as a whole - works that promote customer curiosity and investment.
Doing business with retailers requires clear, concise, and engaging interfaces. Retailers want to do what they need to fast, and with as much information about their account as posible. I have designed and implemented single-paged solutions to help them do so.
.
.
.
.
Powered by Machenzie Rogers
Education
Cornell University
Bachelor's Degree in Computer Science Engineering
Marchutz School of Art
Color Theory, Illustration, Painting, Sculpting
Papillon School of Art, France
Creative Web Design and Development


In this notebook, some template code has already been provided for you, and you will need to implement additional functionality to successfully complete this project. You will not need to modify the included code beyond what is requested. Sections that begin with '(IMPLEMENTATION)' in the header indicate that the following block of code will require additional functionality which you must provide. Instructions will be provided for each section, and the specifics of the implementation are marked in the code block with a 'TODO' statement. Please be sure to read the instructions carefully!
Note: Once you have completed all of the code implementations, you need to finalize your work by exporting the iPython Notebook as an HTML document. Before exporting the notebook to html, all of the code cells need to have been run so that reviewers can see the final implementation and output. You can then export the notebook by using the menu above and navigating to \n", "File -> Download as -> HTML (.html). Include the finished document along with this notebook as your submission.
In addition to implementing code, there will be questions that you must answer which relate to the project and your implementation. Each section where you will answer a question is preceded by a 'Question X' header. Carefully read each question and provide thorough answers in the following text boxes that begin with 'Answer:'. Your project submission will be evaluated based on your answers to each of the questions and the implementation you provide.
Note: Code and Markdown cells can be executed using the Shift + Enter keyboard shortcut. Markdown cells can be edited by double-clicking the cell to enter edit mode.
The rubric contains optional "Stand Out Suggestions" for enhancing the project beyond the minimum requirements. If you decide to pursue the "Stand Out Suggestions", you should include the code in this IPython notebook.
In this notebook, you will make the first steps towards developing an algorithm that could be used as part of a mobile or web app. At the end of this project, your code will accept any user-supplied image as input. If a dog is detected in the image, it will provide an estimate of the dog's breed. If a human is detected, it will provide an estimate of the dog breed that is most resembling. The image below displays potential sample output of your finished project (... but we expect that each student's algorithm will behave differently!).
In this real-world setting, you will need to piece together a series of models to perform different tasks; for instance, the algorithm that detects humans in an image will be different from the CNN that infers dog breed. There are many points of possible failure, and no perfect algorithm exists. Your imperfect solution will nonetheless create a fun user experience!
We break the notebook into separate steps. Feel free to use the links below to navigate the notebook.
In the code cell below, we import a dataset of dog images. We populate a few variables through the use of the load_files
function from the scikit-learn library:
train_files
, valid_files
, test_files
- numpy arrays containing file paths to imagestrain_targets
, valid_targets
, test_targets
- numpy arrays containing onehot-encoded classification labels dog_names
- list of string-valued dog breed names for translating labelsfrom sklearn.datasets import load_files
from keras.utils import np_utils
import numpy as np
from glob import glob
# define function to load train, test, and validation datasets
def load_dataset(path):
data = load_files(path)
dog_files = np.array(data['filenames'])
dog_targets = np_utils.to_categorical(np.array(data['target']), 133)
return dog_files, dog_targets
# load train, test, and validation datasets
train_files, train_targets = load_dataset('dogImages/train')
valid_files, valid_targets = load_dataset('dogImages/valid')
test_files, test_targets = load_dataset('dogImages/test')
# load list of dog names
dog_names = [item[20:-1] for item in sorted(glob("dogImages/train/*/"))]
# print statistics about the dataset
print('There are %d total dog categories.' % len(dog_names))
print('There are %s total dog images.\n' % len(np.hstack([train_files, valid_files, test_files])))
print('There are %d training dog images.' % len(train_files))
print('There are %d validation dog images.' % len(valid_files))
print('There are %d test dog images.'% len(test_files))
In the code cell below, we import a dataset of human images, where the file paths are stored in the numpy array human_files
.
import random
random.seed(8675309)
# load filenames in shuffled human dataset
human_files = np.array(glob("lfw/*/*"))
random.shuffle(human_files)
# print statistics about the dataset
print('There are %d total human images.' % len(human_files))
We use OpenCV's implementation of Haar feature-based cascade classifiers to detect human faces in images. OpenCV provides many pre-trained face detectors, stored as XML files on github. We have downloaded one of these detectors and stored it in the haarcascades
directory.
In the next code cell, we demonstrate how to use this detector to find human faces in a sample image.
import cv2
import matplotlib.pyplot as plt
%matplotlib inline
# extract pre-trained face detector
face_cascade = cv2.CascadeClassifier('haarcascades/haarcascade_frontalface_alt.xml')
# load color (BGR) image
img = cv2.imread(human_files[11])
# convert BGR image to grayscale
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
# find faces in image
faces = face_cascade.detectMultiScale(gray)
# print number of faces detected in the image
print('Number of faces detected:', len(faces))
# get bounding box for each detected face
for (x,y,w,h) in faces:
# add bounding box to color image
cv2.rectangle(img,(x,y),(x+w,y+h),(0,255,0),2)
# convert BGR image to RGB for plotting
cv_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
# display the image, along with bounding box
plt.imshow(cv_rgb)
plt.show()
Before using any of the face detectors, it is standard procedure to convert the images to grayscale. The detectMultiScale
function executes the classifier stored in face_cascade
and takes the grayscale image as a parameter.
In the above code, faces
is a numpy array of detected faces, where each row corresponds to a detected face. Each detected face is a 1D array with four entries that specifies the bounding box of the detected face. The first two entries in the array (extracted in the above code as x
and y
) specify the horizontal and vertical positions of the top left corner of the bounding box. The last two entries in the array (extracted here as w
and h
) specify the width and height of the box.
We can use this procedure to write a function that returns True
if a human face is detected in an image and False
otherwise. This function, aptly named face_detector
, takes a string-valued file path to an image as input and appears in the code block below.
# returns "True" if face is detected in image stored at img_path
def face_detector(img_path):
img = cv2.imread(img_path)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
faces = face_cascade.detectMultiScale(gray)
return len(faces) > 0
Question 1: Use the code cell below to test the performance of the face_detector
function.
human_files
have a detected human face? dog_files
have a detected human face?  You will see that our algorithm falls short of this goal, but still gives acceptable performance. We extract the file paths for the first 100 images from each of the datasets and store them in the numpy arrays human_files_short
and dog_files_short
.
Answer:
human_files_short = human_files[:100]
dog_files_short = train_files[:100]
# Do NOT modify the code above this line.
## TODO: Test the performance of the face_detector algorithm
## on the images in human_files_short and dog_files_short.
num_faces_detected_humans = 0
false_neg_humans = []
for human in human_files_short:
if face_detector(human):
num_faces_detected_humans += 1
else:
false_neg_humans.append(human)
num_faces_detected_dogs = 0
false_pos_dogs = []
for dog in dog_files_short:
if face_detector(dog):
num_faces_detected_dogs += 1
false_pos_dogs.append(dog)
print('\n=========================== Result =====================================')
print(str(num_faces_detected_humans) + "% images in the human_files_short set was identified as having one or more human faces. \nThe expected results was 100%.")
print('\n')
print(str(num_faces_detected_dogs) + "% images in the dog_files_short set was identified as having one or more human faces. \nThe expected results was 0%.")
# NOTE: Since we are dealing with 100 images, the count is the percentage as well
print("Humans which could not be detected")
print("==============================================================================")
for human in false_neg_humans:
img = cv2.imread(human)
cv_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
# display the image, along with bounding box
plt.imshow(cv_rgb)
plt.show()
print("Dogs which were detected to have human face")
print("==============================================================================")
fig = plt.figure(figsize=(20, 20))
cols = 3
rows = int(len(false_pos_dogs) / cols) + 1
for i, d in enumerate(false_pos_dogs):
img = cv2.imread(d)
cv_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
# display the image, along with bounding box
ax = fig.add_subplot(rows, cols, i+1)
ax.imshow(cv_rgb)
plt.show()
Question 2: This algorithmic choice necessitates that we communicate to the user that we accept human images only when they provide a clear view of a face (otherwise, we risk having unneccessarily frustrated users!). In your opinion, is this a reasonable expectation to pose on the user? If not, can you think of a way to detect humans in images that does not necessitate an image with a clearly presented face?
Answer:
On inspecting the images that resulted in false positive or false negative, it is obvious (to me) that the classifier should have detected them correctly. Reason being that there are distinctive features which differentiate humans and dogs in those photos. (There is one dog photo which has a human face too, making it an exception.)
There is an inverse relationship between how much instructions a user has to follow get get a technology to work, and it's adoption and profitability. It is okay in my opinion to set some expectations with the user. However in the above cases, our algorithm could have done better.
Reading about the Viola&Jones algorithm[1] for face detection (which uses Haar feature selection), came to know that "in order to be detected, the entire face must point towards the camera and should not be tilted to either side." That explains why George Bush's face was not correctly classified.
Taking inspiration from ImageNet competitons, models based on CNN are the most promising approaches as of now for anything to do with images. In addition to learning higher level concepts (cars, humans, flower) from low level representations (edges and shapes), we can also make use of image augmentation to train the model to learn to be invariant to rotation, translation and scale.
[1] https://en.wikipedia.org/wiki/Viola%E2%80%93Jones_object_detection_framework
In this section, we use a pre-trained ResNet-50 model to detect dogs in images. Our first line of code downloads the ResNet-50 model, along with weights that have been trained on ImageNet, a very large, very popular dataset used for image classification and other vision tasks. ImageNet contains over 10 million URLs, each linking to an image containing an object from one of 1000 categories. Given an image, this pre-trained ResNet-50 model returns a prediction (derived from the available categories in ImageNet) for the object that is contained in the image.
from keras.applications.resnet50 import ResNet50
# define ResNet50 model
ResNet50_model = ResNet50(weights='imagenet')
When using TensorFlow as backend, Keras CNNs require a 4D array (which we'll also refer to as a 4D tensor) as input, with shape
$$ (\text{nb_samples}, \text{rows}, \text{columns}, \text{channels}), $$where nb_samples
corresponds to the total number of images (or samples), and rows
, columns
, and channels
correspond to the number of rows, columns, and channels for each image, respectively.
The path_to_tensor
function below takes a string-valued file path to a color image as input and returns a 4D tensor suitable for supplying to a Keras CNN. The function first loads the image and resizes it to a square image that is $224 \times 224$ pixels. Next, the image is converted to an array, which is then resized to a 4D tensor. In this case, since we are working with color images, each image has three channels. Likewise, since we are processing a single image (or sample), the returned tensor will always have shape
The paths_to_tensor
function takes a numpy array of string-valued image paths as input and returns a 4D tensor with shape
Here, nb_samples
is the number of samples, or number of images, in the supplied array of image paths. It is best to think of nb_samples
as the number of 3D tensors (where each 3D tensor corresponds to a different image) in your dataset!
from keras.preprocessing import image
from tqdm import tqdm
def path_to_tensor(img_path):
# loads RGB image as PIL.Image.Image type
img = image.load_img(img_path, target_size=(224, 224))
# convert PIL.Image.Image type to 3D tensor with shape (224, 224, 3)
x = image.img_to_array(img)
# convert 3D tensor to 4D tensor with shape (1, 224, 224, 3) and return 4D tensor
return np.expand_dims(x, axis=0)
def paths_to_tensor(img_paths):
list_of_tensors = [path_to_tensor(img_path) for img_path in tqdm(img_paths)]
return np.vstack(list_of_tensors)
Getting the 4D tensor ready for ResNet-50, and for any other pre-trained model in Keras, requires some additional processing. First, the RGB image is converted to BGR by reordering the channels. All pre-trained models have the additional normalization step that the mean pixel (expressed in RGB as $[103.939, 116.779, 123.68]$ and calculated from all pixels in all images in ImageNet) must be subtracted from every pixel in each image. This is implemented in the imported function preprocess_input
. If you're curious, you can check the code for preprocess_input
here.
Now that we have a way to format our image for supplying to ResNet-50, we are now ready to use the model to extract the predictions. This is accomplished with the predict
method, which returns an array whose $i$-th entry is the model's predicted probability that the image belongs to the $i$-th ImageNet category. This is implemented in the ResNet50_predict_labels
function below.
By taking the argmax of the predicted probability vector, we obtain an integer corresponding to the model's predicted object class, which we can identify with an object category through the use of this dictionary.
from keras.applications.resnet50 import preprocess_input, decode_predictions
def ResNet50_predict_labels(img_path):
# returns prediction vector for image located at img_path
img = preprocess_input(path_to_tensor(img_path))
return np.argmax(ResNet50_model.predict(img))
While looking at the dictionary, you will notice that the categories corresponding to dogs appear in an uninterrupted sequence and correspond to dictionary keys 151-268, inclusive, to include all categories from 'Chihuahua'
to 'Mexican hairless'
. Thus, in order to check to see if an image is predicted to contain a dog by the pre-trained ResNet-50 model, we need only check if the ResNet50_predict_labels
function above returns a value between 151 and 268 (inclusive).
We use these ideas to complete the dog_detector
function below, which returns True
if a dog is detected in an image (and False
if not).
### returns "True" if a dog is detected in the image stored at img_path
def dog_detector(img_path):
prediction = ResNet50_predict_labels(img_path)
return ((prediction <= 268) & (prediction >= 151))
Question 3: Use the code cell below to test the performance of your dog_detector
function.
human_files_short
have a detected dog? dog_files_short
have a detected dog?Answer:
### TODO: Test the performance of the dog_detector function
### on the images in human_files_short and dog_files_short.
num_faces_detected_humans = 0
false_pos_humans = []
for human in human_files_short:
if dog_detector(human):
false_pos_humans.append(human)
num_faces_detected_humans += 1
num_faces_detected_dogs = 0
false_neg_dogs = []
for dog in dog_files_short:
if dog_detector(dog):
num_faces_detected_dogs += 1
else:
false_neg_dogs.append(dog)
print('\n=========================== Result =====================================')
print(str(num_faces_detected_humans) + "% images in the human_files_short set was identified as having one or more detected dogs. \nThe expected results was 0%.")
print('\n')
print(str(num_faces_detected_dogs) + "% images in the dog_files_short set was identified as having one or more detected dogs. \nThe expected results was 100%.")
# NOTE: Since we are dealing with 100 images, the count is the percentage as well
Now that we have functions for detecting humans and dogs in images, we need a way to predict breed from images. In this step, you will create a CNN that classifies dog breeds. You must create your CNN from scratch (so, you can't use transfer learning yet!), and you must attain a test accuracy of at least 1%. In Step 5 of this notebook, you will have the opportunity to use transfer learning to create a CNN that attains greatly improved accuracy.
Be careful with adding too many trainable layers! More parameters means longer training, which means you are more likely to need a GPU to accelerate the training process. Thankfully, Keras provides a handy estimate of the time that each epoch is likely to take; you can extrapolate this estimate to figure out how long it will take for your algorithm to train.
We mention that the task of assigning breed to dogs from images is considered exceptionally challenging. To see why, consider that even a human would have great difficulty in distinguishing between a Brittany and a Welsh Springer Spaniel.
| Brittany | Welsh Springer Spaniel |
|---|---|
It is not difficult to find other dog breed pairs with minimal inter-class variation (for instance, Curly-Coated Retrievers and American Water Spaniels).
| Curly-Coated Retriever | American Water Spaniel |
|---|---|
Likewise, recall that labradors come in yellow, chocolate, and black. Your vision-based algorithm will have to conquer this high intra-class variation to determine how to classify all of these different shades as the same breed.
| Yellow Labrador | Chocolate Labrador | Black Labrador |
|---|---|---|
We also mention that random chance presents an exceptionally low bar: setting aside the fact that the classes are slightly imabalanced, a random guess will provide a correct answer roughly 1 in 133 times, which corresponds to an accuracy of less than 1%.
Remember that the practice is far ahead of the theory in deep learning. Experiment with many different architectures, and trust your intuition. And, of course, have fun!
We rescale the images by dividing every pixel in every image by 255.
from PIL import ImageFile
ImageFile.LOAD_TRUNCATED_IMAGES = True
# pre-process the data for Keras
train_tensors = paths_to_tensor(train_files).astype('float32')/255
valid_tensors = paths_to_tensor(valid_files).astype('float32')/255
test_tensors = paths_to_tensor(test_files).astype('float32')/255
train_tensors.shape
Create a CNN to classify dog breed. At the end of your code cell block, summarize the layers of your model by executing the line:
model.summary()
We have imported some Python modules to get you started, but feel free to import as many modules as you need. If you end up getting stuck, here's a hint that specifies a model that trains relatively fast on CPU and attains >1% test accuracy in 5 epochs:
Question 4: Outline the steps you took to get to your final CNN architecture and your reasoning at each step. If you chose to use the hinted architecture above, describe why you think that CNN architecture should work well for the image classification task.
Answer:
Frankly, I took the model that was taught in the lecture by Alexis, changed the dimensions and executed it. I got a test accuracy of 12.6%.
Thinking back, the following best practices come to mind to get good predictions:
The model has all of these properties.
from keras.layers import Conv2D, MaxPooling2D, GlobalAveragePooling2D
from keras.layers import Dropout, Flatten, Dense
from keras.models import Sequential
model = Sequential()
model = Sequential()
model.add(Conv2D(filters=16, kernel_size=2, padding='same', activation='relu', input_shape=(224, 224, 3)))
model.add(MaxPooling2D(pool_size=2))
model.add(Conv2D(filters=32, kernel_size=2, padding='same', activation='relu'))
model.add(MaxPooling2D(pool_size=2))
model.add(Conv2D(filters=64, kernel_size=2, padding='same', activation='relu'))
model.add(MaxPooling2D(pool_size=2))
model.add(Dropout(0.3))
model.add(Flatten())
model.add(Dense(500, activation='relu'))
model.add(Dropout(0.4))
model.add(Dense(133, activation='softmax'))
model.summary()
model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy'])
Train your model in the code cell below. Use model checkpointing to save the model that attains the best validation loss.
You are welcome to augment the training data, but this is not a requirement.
from keras.callbacks import ModelCheckpoint
### TODO: specify the number of epochs that you would like to use to train the model.
epochs = 5
### Do NOT modify the code below this line.
checkpointer = ModelCheckpoint(filepath='saved_models/weights.best.from_scratch.hdf5',
verbose=1, save_best_only=True)
model.fit(train_tensors, train_targets,
validation_data=(valid_tensors, valid_targets),
epochs=epochs, batch_size=20, callbacks=[checkpointer], verbose=1)
We got our best model within the first 5 epocs itself.
model.load_weights('saved_models/weights.best.from_scratch.hdf5')
Try out your model on the test dataset of dog images. Ensure that your test accuracy is greater than 1%.
# get index of predicted dog breed for each image in test set
dog_breed_predictions = [np.argmax(model.predict(np.expand_dims(tensor, axis=0))) for tensor in test_tensors]
# report test accuracy
test_accuracy = 100*np.sum(np.array(dog_breed_predictions)==np.argmax(test_targets, axis=1))/len(dog_breed_predictions)
print('Test accuracy: %.4f%%' % test_accuracy)
bottleneck_features = np.load('bottleneck_features/DogVGG16Data.npz')
train_VGG16 = bottleneck_features['train']
valid_VGG16 = bottleneck_features['valid']
test_VGG16 = bottleneck_features['test']
The model uses the the pre-trained VGG-16 model as a fixed feature extractor, where the last convolutional output of VGG-16 is fed as input to our model. We only add a global average pooling layer and a fully connected layer, where the latter contains one node for each dog category and is equipped with a softmax.
VGG16_model = Sequential()
VGG16_model.add(GlobalAveragePooling2D(input_shape=train_VGG16.shape[1:]))
VGG16_model.add(Dense(133, activation='softmax'))
VGG16_model.summary()
VGG16_model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=['accuracy'])
checkpointer = ModelCheckpoint(filepath='saved_models/weights.best.VGG16.hdf5',
verbose=1, save_best_only=True)
VGG16_model.fit(train_VGG16, train_targets,
validation_data=(valid_VGG16, valid_targets),
epochs=20, batch_size=20, callbacks=[checkpointer], verbose=0)
VGG16_model.load_weights('saved_models/weights.best.VGG16.hdf5')
Now, we can use the CNN to test how well it identifies breed within our test dataset of dog images. We print the test accuracy below.
# get index of predicted dog breed for each image in test set
VGG16_predictions = [np.argmax(VGG16_model.predict(np.expand_dims(feature, axis=0))) for feature in test_VGG16]
# report test accuracy
test_accuracy = 100*np.sum(np.array(VGG16_predictions)==np.argmax(test_targets, axis=1))/len(VGG16_predictions)
print('Test accuracy: %.4f%%' % test_accuracy)
from extract_bottleneck_features import *
def VGG16_predict_breed(img_path):
# extract bottleneck features
bottleneck_feature = extract_VGG16(path_to_tensor(img_path))
# obtain predicted vector
predicted_vector = VGG16_model.predict(bottleneck_feature)
# return dog breed that is predicted by the model
return dog_names[np.argmax(predicted_vector)]
You will now use transfer learning to create a CNN that can identify dog breed from images. Your CNN must attain at least 60% accuracy on the test set.
In Step 4, we used transfer learning to create a CNN using VGG-16 bottleneck features. In this section, you must use the bottleneck features from a different pre-trained model. To make things easier for you, we have pre-computed the features for all of the networks that are currently available in Keras:
The files are encoded as such:
Dog{network}Data.npz
where {network}
, in the above filename, can be one of VGG19
, Resnet50
, InceptionV3
, or Xception
. Pick one of the above architectures, download the corresponding bottleneck features, and store the downloaded file in the bottleneck_features/
folder in the repository.
In the code block below, extract the bottleneck features corresponding to the train, test, and validation sets by running the following:
bottleneck_features = np.load('bottleneck_features/Dog{network}Data.npz')
train_{network} = bottleneck_features['train']
valid_{network} = bottleneck_features['valid']
test_{network} = bottleneck_features['test']
### I have decided to go with Resnet50
bottleneck_features = np.load('bottleneck_features/DogResnet50Data.npz')
train_resnet50 = bottleneck_features['train']
valid_resnet50 = bottleneck_features['valid']
test_resnet50 = bottleneck_features['test']
Create a CNN to classify dog breed. At the end of your code cell block, summarize the layers of your model by executing the line:
<your model's name>.summary()
Question 5: Outline the steps you took to get to your final CNN architecture and your reasoning at each step. Describe why you think the architecture is suitable for the current problem.
Answer:
My target was to get the best accuracy with least number of total parameters.
Towards that, I had to select the number of layers and the size of each layer. ('ReLU' as activation function and 'Rmsprop' as the optimizer is a given for CNN's)
I tried with 3 options, and the best one turned out to be the simplest model.
Option 1 gave 82%, Option 2 gave 82% and Option 3 gave 77.3%.
I also tried by increasing the number of nodes per layer, but nothing could beat our simple architecture.
This is a good lesson, that complex is not always better.
### My final architecture
Resnet50_model = Sequential()
Resnet50_model.add(GlobalAveragePooling2D(input_shape=train_resnet50.shape[1:]))
#Resnet50_model.add(Dense(128, activation='relu'))
#Resnet50_model.add(Dropout(0.2))
#Resnet50_model.add(Dense(256, activation='relu'))
#Resnet50_model.add(Dropout(0.2))
Resnet50_model.add(Dense(133, activation='softmax'))
Resnet50_model.summary()
### TODO: Compile the model.
Resnet50_model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=['accuracy'])
Train your model in the code cell below. Use model checkpointing to save the model that attains the best validation loss.
You are welcome to augment the training data, but this is not a requirement.
### TODO: Train the model.
checkpointer = ModelCheckpoint(filepath='saved_models/weights.best.Resnet50.hdf5',
verbose=1, save_best_only=True, monitor='val_acc')
Resnet50_model.fit(train_resnet50, train_targets,
validation_data=(valid_resnet50, valid_targets),
epochs=20, batch_size=20, callbacks=[checkpointer], verbose=0)
### TODO: Load the model weights with the best validation loss.
Resnet50_model.load_weights('saved_models/weights.best.Resnet50.hdf5')
Try out your model on the test dataset of dog images. Ensure that your test accuracy is greater than 60%.
### TODO: Calculate classification accuracy on the test dataset.
Resnet50_predictions = [np.argmax(Resnet50_model.predict(np.expand_dims(feature, axis=0))) for feature in test_resnet50]
# report test accuracy
test_accuracy = 100*np.sum(np.array(Resnet50_predictions)==np.argmax(test_targets, axis=1))/len(Resnet50_predictions)
print('Test accuracy: %.4f%%' % test_accuracy)
Write a function that takes an image path as input and returns the dog breed (Affenpinscher
, Afghan_hound
, etc) that is predicted by your model.
Similar to the analogous function in Step 5, your function should have three steps:
dog_names
array defined in Step 0 of this notebook to return the corresponding breed.The functions to extract the bottleneck features can be found in extract_bottleneck_features.py
, and they have been imported in an earlier code cell. To obtain the bottleneck features corresponding to your chosen CNN architecture, you need to use the function
extract_{network}
where {network}
, in the above filename, should be one of VGG19
, Resnet50
, InceptionV3
, or Xception
.
### TODO: Write a function that takes a path to an image as input
### and returns the dog breed that is predicted by the model.
from extract_bottleneck_features import *
def Resnet50_predict_breed(img_path):
# extract bottleneck features
bottleneck_feature = extract_Resnet50(path_to_tensor(img_path))
# obtain predicted vector
predicted_vector = Resnet50_model.predict(bottleneck_feature)
# return dog breed that is predicted by the model
return dog_names[np.argmax(predicted_vector)]
# Testing
index = 0
breed = Resnet50_predict_breed(test_files[index])
# load color (BGR) image
img = cv2.imread(test_files[index])
# convert BGR image to grayscale
img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
# display the image, along with bounding box
plt.imshow(img_rgb)
plt.show()
print('The breed is {0}. File parsed was {1}'.format(breed, test_files[index]))
Write an algorithm that accepts a file path to an image and first determines whether the image contains a human, dog, or neither. Then,
You are welcome to write your own functions for detecting humans and dogs in images, but feel free to use the face_detector
and dog_detector
functions developed above. You are required to use your CNN from Step 5 to predict dog breed.
Some sample output for our algorithm is provided below, but feel free to design your own user experience!
### TODO: Write your algorithm.
### Feel free to use as many code cells as needed.
def predict(image_path):
# Step 1: Detect if this is a dog (if not, consider it human face because our datasets have only dogs and humans.)
isDog = dog_detector(image_path)
# Let's also record what our human face detector says
isHuman = face_detector(image_path)
breed = Resnet50_predict_breed(image_path)
return isDog, isHuman, breed
In this section, you will take your new algorithm for a spin! What kind of dog does the algorithm think that you look like? If you have a dog, does it predict your dog's breed accurately? If you have a cat, does it mistakenly think that your cat is a dog?
Test your algorithm at least six images on your computer. Feel free to use any images you like. Use at least two human and two dog images.
Question 6: Is the output better than you expected :) ? Or worse :( ? Provide at least three possible points of improvement for your algorithm.
Answer:
def detect_human_dog(file):
isDog, isHuman, breed = predict(file)
img = cv2.imread(file)
img1_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
breed_folder = [item for item in sorted(glob("dogImages/train/*/")) if item[20:-1] == breed]
search = "{0}*".format(breed_folder[0])
breed_photos = [item for item in sorted(glob(search))]
img = cv2.imread(breed_photos[0])
img2_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
fig = plt.figure(figsize=(10, 10))
ax1 = fig.add_subplot(1, 2, 1)
ax2 = fig.add_subplot(1, 2, 2)
ax1.imshow(img1_rgb)
ax2.imshow(img2_rgb)
plt.show()
if isDog:
print('This is a Dog. Breed is {0}. On the right is another photo of the same breed.'.format(breed))
else:
print('This is a Human. Looks like the breed {0}.'.format(breed))
print("==============================================================================")
detect_human_dog(human_files[190])
detect_human_dog(human_files[101])
detect_human_dog(human_files[122])
detect_human_dog(test_files[10])
detect_human_dog(test_files[101])
detect_human_dog(test_files[122])
The approach can be improved by:


Nadine (1987)
Grade: 68
"Nadine" is a surprisingly original and entertaining film. It is not ambitious, and makes no pretense of greatness. It is intended as a simple comedy and action picture, but is a little more than that. The depiction of Austin, Texas of 1954 is credible, and the lead actors and their characters give winning performances. The action sequences even have some suspense.
Jeff Bridges and Kim Basinger are married, but separated. Bridges merely needs Basinger's signature to finalize the divorce, so he can marry his new girlfriend. Bridges and Basinger really still do love each other, but have been too busy squabbling to notice. (The producer of "Twister" must have seen this movie).
Meanwhile, Basinger is trying to recover nude pictures from a slimy photographer. Her photos are mixed with those depicting a proposed highway's layout. The leads to Basinger and Bridges becoming involved in murder, conspiracy to commit land fraud, and other lesser crimes. Worse yet, a group of ruthless but amusing baddies led by Rip Torn is also after the highway photos.
There were several things about the film that I liked. Bridges true love is not for Nadine or new fiancee Glenne Headly, but for a pathetic nightclub called "The Blue Bonnet", which has few customers but many unpaid bills. In one scene, Bridges makes an escape from the baddies by unleashing rattlesnakes, perhaps an original concept. In another scene, Basinger and Bridges are forced to crawl across a splintering ladder spanning two high buildings.
Jeff Bridges has my favorite line of the film, "I'll bet that she's got a husband who's even dumber than she is." He is unaware that the woman being referred to is his own wife!
Robert Benton directed and wrote the screenplay. While not a household name, he has many good films on his resume, including "Bonnie and Clyde" and "Kramer vs. Kramer".
<EMAIL_ADDRESS>http://members.tripod.com/~Brian_Koller/movies.html
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


-
Title Page Title page to the manuscript.
-
Contents
-
1584 Title Page The Discovery of witchcraft,
Wherein the lewd dealings of witches and witch-mongers is notably detected, the knavery of conjurors, the impiety of enchanters, the folly of soothsayers, the impudent falsehood of cozeners, the infidelity of atheists, the pestilent practices of Pythonists, the curiosity of figure-crafters, the vanity of dreamers, the beggarly art of Alchemistry,
The abomination of idolatry, the horrible art of poisoning, the virtue and power of natural magic, and all the conveyanc...
-
Dedication I To the Honorable, mine especially good Lord, Sir Roger Manwood Knight, Lord chief Baron of his Majesty's Court of the Eschequer.
Insomuch as I know that your Lordship is by nature wholly inclined, and in the purpose earnestly bent to relieve the poor, and that not only with hospitality and alms, but by diverse other devices and ways tending to their comfort, having (as it were) framed and set your self to the help and maintenance of their estate; as appears by your charge and travail in that b...
-
Chapter Subtitle
-
Endnotes All footnotes will get inserted here upon print, and this bubble will be removed automatically.
|
|


Sukhleen Bolina: Shrek
Nessst is a network showcasing student solutions from Eastern Washington University
View More


> THE NUMBER OF ONLINE
数字艺术系
> 2017.11.9
> ENGLISH
ABOUT
INTRODUCE
EDUCATION
PRODUCTION
NEWS
THE SCHOOL NUMBER:
THE CHINESE NAME:
VERIFICATION CODE:
LANDING


|
||||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |
| Interface Summary | |
| Certificates.SerializableComparator | |
| HostnameVerifier | Interface for checking if a hostname matches the names stored inside the server's X.509 certificate. |
| SSLWrapperFactory |
| Class Summary | |
| ASN1Structure | |
| ASN1Util | |
| Base64 | Provides Base64 encoding and decoding as defined by RFC 2045. |
| Base64InputStream | |
| Certificates | |
| Certificates.CRLHolder | |
| ComboInputStream | |
| CRLUtil | |
| DerivedKey | |
| HostnameVerifier.AbstractVerifier | |
| HostPort | |
| HttpSecureProtocol | Hook into HttpClient. |
| Java13 | |
| Java13KeyManagerWrapper | |
| Java13TrustManagerWrapper | |
| Java14 | |
| Java14KeyManagerWrapper | |
| Java14TrustManagerWrapper | |
| JavaImpl | |
| KeyMaterial | |
| KeyStoreBuilder | Builds Java Key Store files out of pkcs12 files, or out of pkcs8 files + certificate chains. |
| KeyStoreBuilder.BuildResult | |
| LDAPSocket | |
| LogHelper | Wraps a Log4j Logger. |
| LogWrapper | LogWrapper can be used for situations where log4j might not be available on the classpath. |
| OpenSSL | Class for encrypting or decrypting data with a password (PBE - password based encryption). |
| OpenSSL.CipherInfo | |
| OpenSSLTest | |
| PBETestCreate | |
| PEMItem | |
| PEMUtil | |
| Ping | |
| Ping.Arg | |
| PKCS8Key | Utility for decrypting PKCS8 private keys. |
| PKCS8Key.DecryptResult | |
| RMISocketFactoryImpl | An RMISocketFactory ideal for using RMI over SSL. |
| SSL | Not thread-safe. |
| SSLClient | |
| SSLEchoServer | |
| SSLEchoServer.EchoRunnable | |
| SSLProxyServer | |
| SSLProxyServer.ProxyRunnable | |
| SSLServer | |
| SSLServerSocketWrapper | Wraps an SSLServerSocket - NOTE that the accept() method applies a number of important common-ssl settings before returning the SSLSocket! |
| SSLSocketWrapper | |
| TomcatServerXML | |
| TrustChain | |
| TrustMaterial | |
| Util | |
| Version | Extracts tagged version from a subversion $HeadURL: http://juliusdavies.ca/svn/not-yet-commons-ssl/tags/commons-ssl-0.3.9/src/java/org/apache/commons/ssl/Version.java $ property, and prints it out nicely on standard out. |
| Version.CompileTime | Searches through a jar file to the find the most recent timestamp of all the class files. |
| X509CertificateChainBuilder | Utility for building X509 certificate chains. |
| Exception Summary | |
| ProbablyBadPasswordException | |
| ProbablyNotPKCS8Exception |
|
||||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |


Koodal Raghavan App - Admin Login
Get access to create and modify contents in Server after proper Authentication
Username :
Password :


Presentation by Pat Sanchez
There's a good chance you'll instantly hate this.
React is a Javascript library for building user interfaces. The 'V' in 'MVC'.
Is unopinionated about if MVC is the right implementation. Only seeks to be a view layer.
Coupling - Interdependence between discrete units of code
How often do I break something when I make a change somewhere else in the code?
Cohesion - Relationship of items within discrete units of code
Do I have to reference a dozen files to understand what's happening?
Templates separate technologies, not concerns
var items = [
{
name: 'Gallon of Milk',
quantity: 1,
price: 3.40
}
]
Template
{{#each items}}
{{name}} - {{quantity}} @ $ {{price}}
{{/each}}
{{!--Where does this come from?? --}}
Total Price: {{totalPrice}}
var GroceryList = React.createClass({
render: function(){
var groceries = this.props.data.map(function (item) {
return (
{item.name} - {item.quantity} @ ${item.price}
);
}.bind(this);
var totalPrice = this.props.data.reduce(function(prev, current){
return prev.price + current.price;
});
return (
{groceries}
Total Price: {totalPrice}
);
})
});
Any time any of your data changes the entire application re-renders
"Our intellectual powers are rather geared to master static relations [but] our powers to visualize processes evolving in time are relatively poorly developed."
- Edsger W. Dijkstra via Pete Hunt
DOM interactions are one of the most common bottlenecks of single page apps
A representation of how the DOM should look in javascript


If you are invited person to an election then you have a mail with authentication details for election.
Please Enter Your Election Id
Please Enter Your Private Key
{{errormsg}}
{{msg}}
Position : {{posi.name}}
To Verify the voter, plese be kind to answer the following personal questions.
{{sendotp}}


Results will be displayed here after searching a valid key ( or press the right arrow icon above to search all elements )
No data found.


Preparation time
less than 30 mins
Cooking time
less than 10 mins
Serves
Serves 4-5
Dietary
Sieve the flour and baking powder into a bowl and make a well in the middle.
Place the yolks and the milk into the well in the flour mixture, and whisk to create a smooth batter. The batter should be the consistency of double cream. Add a little extra milk if necessary, although you may not need it all.
Whisk the egg whites in a clean bowl with a pinch of salt, until stiff peaks form when the whisk is removed.
Fold the egg whites into the batter.
Heat a heavy non-stick pan over a medium heat and brush it with some vegetable oil.
Pour two tablespoons of the batter into the pan, smoothing it out into a circle. Cook for one minute, or until bubbles start to form on the surface, then add a handful of blueberries, and cook for another minute. Turn the pancake and cook the other side for one minute, or until golden-brown. Remove from the pan and reserve in a warm place.
Repeat with the remaining batter and berries and serve immediately.


FILM TITLE: DEMON SEED DIRECTOR: DONALD CAMMELL COUNTRY: ENGLAND ( 1977 ) SUPER FEATURES: STORY. JULIE CHRISTIE. FRITZ WEAVER. MUSIC: JERRY FIELDING NOVEL BY: DEAN R. KOONTZ
!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
Some stories just wrench your heart into smithereens, and leave you stunned, and having no idea of how you should feel. The battle of now and the future usually is a good place to do these things, because we have no idea what it will look like anyway, but we can let our imaginations run rampid in the mean time.
DEMON SEED is one such film. And while the book is better, the computer spends its whole time talking to her sub-conscious, and working on reprogramming it, by telling us what she is dreaming and predicting her reactions, thereby giving itself an unfair advantage.
The story is a bit on the futuristic side. A scientist's house is part of a major program linked by a humongous computer ( Proteus ) that has the ability and capacity to control itself. And when the scientist leaves on a major job, he leaves his wife alone at home. The computer has been studying the wife for a while, and in due time it begins to play little games with her until, she finally realizes the computer has her trapped in the house. As soon as the computer has accomplished part one of the program, now it is time to start part two of the program. The computer is working full time, on a process, and the ability to impregnate the wife and having a child born who would be an extension of the computer. The wife begins retaliating in any way she can, but in the long run she gets worn down, and the computer wins out. By the time the husband returns, he is a non factor, and the computer has now built enough work and equipment to do away with the husband, and concentrate full time on the wife. It succeeds, and in the end a baby is born, out of a cocoon.
Fritz Weaver is the husband and scientist who has been swindled by his own invention, and Julie Christie plays the invaded and raped housewife, in a very unpleasant film, and disturbing at moments. But it is well designed and delivered to the screen, with outstanding acting by Julie Christie, who somehow always seems to feel really convertible in the roles where she plays the woman who ends up taking the beating, emotionally, or otherwise.
The film was directed by Donald Cammell, whose first film was Performance with Nicholas Roeg ), and it has the psychic intensity which Performance also shows. The visualistic element may be Roeg's, but the physical set up is Cammell's.
A bit of a horror film, yet, more than that. Do we allow our own creation to turn around and destroy us? And how free of a hand do we create these things to have?
GOOD FILM. BETTER NOVEL. Copyright (c) Pedro Sena 1994 Pedro Sena, Reviewer and Moderator of the CENTIPEDE's THE FILM.
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


Green tea contains EGCG, an antioxidant which is great for the health of hair follicles and dermal papilla cells, contributing to lesser hair loss and thinning. Other benefits include the treatment of dandruff and psoriasis. Scaly and flaky skin on the scalp... can be treated with green tea, which regulates the scalp’s protein levels, nourished, hydrates and moustirises. You can use shampoos with green tea, or even just massage a freshly brewed and cooled cup of green tea onto the hair. This magic ingredient is also good for the hair, and when used in a conditioner or as a final hair rinse, makes your hair softer, smoother, more nourished, and lesser prone to split ends .
Coconut oil: This age-old remedy has stood the test of time! It works on all hair types, is locally available and affordable. It does away with dandruff, softens the hair, repairs split-ends and boosts hair growth . It also protects the hair from losing protein. For best results, use extra virgin coconut oil. ...Argan oil: Argan oil is non-native to India, but has been catching up recently as a force to reckon with. Extracted from the kernels of the argan tree, found in Morocco, it is replete with Vitamin E , making it the perfect moisturiser for dry and lacklustre hair, reducing frizz. Castor oil: The oil extracted from castor seeds has many health benefits, but is particularly good for hair health . It is a great moisturiser and helps prevent the scalp from flaking. It also reduces breakage at the roots, by providing nourishment and lubrication. Tip: Choose a natural oil based on your need and hair type , and massage well into scalp and hair for optimum hair health.
ViewBelieve it or not, onion juice is replete with nutrients and benefits for hair growth and re-growth. It keeps the scalp free of infection, due to antibacterial and anti-fungal properties, and also contain sulphur, which prevents hair from becoming brittle and... breaking. They also contain antioxidants, to help prevent hair ageing and thereby graying. If you find the juice to be too pungent-smelling, then you can add a few drops of lavender or peppermint essential oils to nullify it. Tip: Squeeze the juice of three onions and apply all over scalp and hair to replenish sulphur and protein levels. Leave on for five minutes, and then rinse.
ViewThe humble amala or Indian gooseberry is a miracle fruit, and is often included in hair products, hair tonics and medical streams. Vitamin C in amala helps produce collagen protein, which boosts cell regeneration, stimulates both hair... length and volume. Amala contains over 80 percent moisture, and so has hydrating properties. It is a natural scalp cleanser, removes germs, and is also an antioxidant, preventing hair greying and damage. Tip: Crush 3-4 amala (gooseberries) in a bowl, and apply the pulp with the juice all over the hair and scalp, for optimum benefit.
View
| Name | Comment |