Attn: Sir, My name is Mr. Akim I work in the International operation department in a Bank here in Africa. On a routine inspection I discovered a dormant Domiciliary account with a Balance of $26,000,000 USD (Twenty Six Million USD) on further circumspection, I also discovered that the account holder has long passed away (dead) leaving no beneficiary to the account. The bank will approve this money to any foreigner with the correct account information which i will present on your behalf because the former operator of the account is a foreigne. He died in a car accident eight years ago, nobody else knows about these funds, and only a foreigner with the legal documents of the account can claim this money, so that’s why I need your cooperation for i cannot do this myself or with anybody here in my country. I will provide the necessary information needed in order to claim this money, But you will need to provide an account where this money can be transferred. I wish for utmost confidentiality in handling this transaction as my job and the future of my family would be jeopardized if it were breached. I want to assure you that the transaction is without risk if due process is followed accordingly. Finally, I will give you 29% of the total sum for your contribution and efforts. If interested and capable to assist me in this transaction, please get back to me immediately. I look forward to a favorable response from you through the contacts below. Yours Mr. Akim Email:><EMAIL_ADDRESS>Phone:> +234-80-42141411


|
BitShares-Core
6.1.0
BitShares blockchain implementation and command-line interface software
|
Maintains global state information (committee_member list, current fees)This is an implementation detail. The values here are calculated during normal chain operations and reflect the current values of global blockchain properties. More...
#include <global_property_object.hpp>
Public Types | |
| enum | dynamic_flag_bits { maintenance_flag = 0x01 } |
Public Attributes | |
| uint32_t | head_block_number = 0 |
| block_id_type | head_block_id |
| time_point_sec | time |
| witness_id_type | current_witness |
| time_point_sec | next_maintenance_time |
| time_point_sec | last_vote_tally_time |
| time_point_sec | last_budget_time |
| share_type | witness_budget |
| share_type | total_pob |
| share_type | total_inactive |
| uint32_t | accounts_registered_this_interval = 0 |
| uint32_t | recently_missed_count = 0 |
| uint64_t | current_aslot = 0 |
| fc::uint128_t | recent_slots_filled |
| uint32_t | dynamic_flags = 0 |
| uint32_t | last_irreversible_block_num = 0 |
| Public Attributes inherited from graphene::db::object | |
| object_id_type | id |
Additional Inherited Members | |
| Public Member Functions inherited from graphene::db::abstract_object< dynamic_global_property_object, implementation_ids, impl_dynamic_global_property_object_type > | |
| abstract_object () | |
| object_id< SpaceID, TypeID > | get_id () const |
| Public Member Functions inherited from graphene::db::base_abstract_object< dynamic_global_property_object > | |
| std::unique_ptr< object > | clone () const override |
| void | move_from (object &obj) override |
| fc::variant | to_variant () const override |
| std::vector< char > | pack () const override |
| Public Member Functions inherited from graphene::db::object | |
| object ()=default | |
| object (uint8_t space_id, uint8_t type_id) | |
| virtual | ~object ()=default |
| Static Public Attributes inherited from graphene::db::abstract_object< dynamic_global_property_object, implementation_ids, impl_dynamic_global_property_object_type > | |
| static constexpr uint8_t | space_id |
| static constexpr uint8_t | type_id |
Maintains global state information (committee_member list, current fees)
This is an implementation detail. The values here are calculated during normal chain operations and reflect the current values of global blockchain properties.
Definition at line 62 of file global_property_object.hpp.
Definition at line 106 of file global_property_object.hpp.
| uint32_t graphene::chain::dynamic_global_property_object::accounts_registered_this_interval = 0 |
Definition at line 76 of file global_property_object.hpp.
| uint64_t graphene::chain::dynamic_global_property_object::current_aslot = 0 |
The current absolute slot number. Equal to the total number of slots since genesis. Also equal to the total number of missed slots plus head_block_number.
Definition at line 91 of file global_property_object.hpp.
| witness_id_type graphene::chain::dynamic_global_property_object::current_witness |
Definition at line 69 of file global_property_object.hpp.
| uint32_t graphene::chain::dynamic_global_property_object::dynamic_flags = 0 |
dynamic_flags specifies chain state properties that can be expressed in one bit.
Definition at line 102 of file global_property_object.hpp.
| block_id_type graphene::chain::dynamic_global_property_object::head_block_id |
Definition at line 67 of file global_property_object.hpp.
| uint32_t graphene::chain::dynamic_global_property_object::head_block_number = 0 |
Definition at line 66 of file global_property_object.hpp.
| time_point_sec graphene::chain::dynamic_global_property_object::last_budget_time |
Definition at line 72 of file global_property_object.hpp.
| uint32_t graphene::chain::dynamic_global_property_object::last_irreversible_block_num = 0 |
Definition at line 104 of file global_property_object.hpp.
| time_point_sec graphene::chain::dynamic_global_property_object::last_vote_tally_time |
Definition at line 71 of file global_property_object.hpp.
| time_point_sec graphene::chain::dynamic_global_property_object::next_maintenance_time |
Definition at line 70 of file global_property_object.hpp.
| fc::uint128_t graphene::chain::dynamic_global_property_object::recent_slots_filled |
used to compute witness participation.
Definition at line 96 of file global_property_object.hpp.
| uint32_t graphene::chain::dynamic_global_property_object::recently_missed_count = 0 |
Every time a block is missed this increases by RECENTLY_MISSED_COUNT_INCREMENT, every time a block is found it decreases by RECENTLY_MISSED_COUNT_DECREMENT. It is never less than 0.
Definition at line 84 of file global_property_object.hpp.
| time_point_sec graphene::chain::dynamic_global_property_object::time |
Definition at line 68 of file global_property_object.hpp.
| share_type graphene::chain::dynamic_global_property_object::total_inactive |
Definition at line 75 of file global_property_object.hpp.
| share_type graphene::chain::dynamic_global_property_object::total_pob |
Definition at line 74 of file global_property_object.hpp.
| share_type graphene::chain::dynamic_global_property_object::witness_budget |
Definition at line 73 of file global_property_object.hpp.


TABLE OF CONTENTS
A. GS1 Related B. GS2 Related POLITY 1. U.P. plans to digitise medical college records 2. Centre eases norms for sewage plants 3. National anthem in movie halls: SC asks why do people have to wear patriotism on sleeve 4. HC orders penal action over manual scavenging 5. Centre tweaks groundwater extraction rules for industry 6. New policy on the cards to boost medical tourism 7. The gown and the Bench INTERNATIONAL AFFAIRS/BILATERAL RELATIONS 1. Not just strategic ties with Dhaka: Sushma HEALTH ISSUES 1. Has hunger increased in India in recent years? C. GS3 Related INTERNAL SECURITY 1. Law And Immunity D. GS4 Related E. Prelims Fact F. UPSC Prelims Practice Questions G. UPSC Mains Practice Questions
Nothing here for Today!!!
1. U.P. plans to digitise medical college records
In news:
- The Uttar Pradesh government is planning to start an ‘ E-hospital’ facility at State-run medical colleges.
- The six medical colleges of Kanpur, Jhansi, Agra, Meerut and Gorakhpur, and the Laxmipat Singhania Institute of Cardiology in Kanpur, have been picked for the implementation of the new facility under the first phase.
- E-hospital facility to include: Case histories of patients, and information related to hospital staff and stocks of medicines.
- Apart from E-hospitals, the government has also formed a Medical Education Strategy Cell (MESC), the first of its kind in the State, to create a roadmap for phase-wise improvements in the medical education sector.
2. Centre eases norms for sewage plants
In news:
- New Plan: The Central Pollution Control Board (CPCB) has relaxed standards for upcoming sewage treatment plants (STP ), including those to come up on extremely polluted stretches of the Ganga.
Earlier standards:
- As per 2015-proposal the standard set for STP’s was higher: they would have to ensure that the biochemical oxygen demand (Bod) — a marker for organic pollutants — in the treated water had to be no more than 10 mg/litre.
New notification issued:
- A notification by the Union Environment Ministry this month has junked the 10 mg/litre target.
- It says that STPs coming up after June 2019 — except in major State capitals and metropolitan cities — need only conform to 30 mg/litre of BoD.
- These include proposed STPS to treat sewage in stretches of the river downstream of Haridwar, including Kanpur and Allahabad in Uttar Pradesh.
- New STPs in State capitals, however, have to cap BoD at 20 mg/litre.
Why such a move to ease the norms?
- The 10 mg criteria was impractical and required advanced technology that was too costly for most States.
Basic Information:
- Biochemical oxygen demand
- Biochemical oxygen demand (BOD), also called biological oxygen demand) is the amount of dissolved oxygen (DO) needed (i.e., demanded) by aerobic biological organisms to break down organic material present in a given water sample at certain temperature over a specific time period.
- The BOD value is most commonly expressed in milligrams of oxygen consumed per litre of sample during 5 days of incubation at 20 °C and is often used as a surrogate of the degree of organic pollution of water.
- BOD can be used as a gauge of the effectiveness of wastewater treatment plants.
Why is BOD important?
- Biochemical Oxygen Demand is an important water quality parameter because it provides an index to assess the effect discharged wastewater will have on the receiving environment.
- The higher the BOD value, the greater the amount of organic matter or “food” available for oxygen consuming bacteria.
- If the rate of DO consumption by bacteria exceeds the supply of DO from aquatic plants, algae photosynthesis or diffusing from air, unfavourable conditions occur.
- Depletion of DO causes stress on aquatic organisms, making the environment unsuitable for life. Further, dramatic depletion can lead to hypoxia or anoxic environments.
- BOD is also used extensively for wastewater treatment, as decomposition of organic waste by microorganisms is commonly used for treatment.
3. National anthem in movie halls: SC asks why do people have to wear patriotism on sleeve
Issue:
- SC Judge Justice D Y Chandrachud was critical of last year’s apex court order making it mandatory for movie halls to play the national anthem before the start of a film.
- Justice Chandrachud who was part of a three-judge bench which heard a petition filed by a film society seeking recall of its November 30 order making it mandatory for movie halls to play the anthem
Suggestion from the Chief Justice of India
- Chief Justice Misra said the court may modify its earlier order and replace the “shall” in it with “may”
- Appearing for the Centre, Attorney General too agreed with this
- But Venugopal opposed the recall of the entire order saying the singing of the anthem was a “unifying factor” in a country as diverse as India
4. HC orders penal action over manual scavenging
Context:
- The Madras High Court took serious note of a photograph published in The Hindu on October 3, of people involved in manual scavenging at Pondy Bazaar, and directed Additional Advocate General to ensure that those responsible were taken to task, and apprise the court of the action taken.
In news:
- The High Court Bench directed the State government to file a status report on steps taken by it so far for rehabilitation of people involved in manual scavenging in accordance with the provisions of the Prohibition of Employment as Manual Scavengers and their Rehabilitation Act of 2013.
Basic Information:
Prohibition of Employment as Manual Scavengers and their Rehabilitation Act of 2013
Key Provisions:
- The employment of manual scavengers, the manual cleaning of sewers and septic tanks without protective equipment, and the construction of insanitary latrines is prohibited.
- It provides for rehabilitation of manual scavengers and their alternative employment.
- Each local authority, cantonment board and railway authority is responsible for surveying insanitary latrines within its jurisdiction. They shall also construct a number of sanitary community latrines.
- Each occupier of insanitary latrines shall be responsible for converting or demolishing the latrine at his own cost if he fails to do so, the local authority shall convert the latrine and recover the cost from him.
- The implementing authorities shall be District Magistrate and the local authority.
- Offences under the act shall be cognizable and non-bailable, and may be tried summarily.
Context:
- Uniform regulatory framework on groundwater use across the country.
In news:
- New proposal: the Centre has come out with draft guidelines which stipulate existing and new industries, infrastructure and mining projects have to obtain a ` no-objection certificate’ (NOC) from district and state-level authorities for drawing groundwater.
- The draft guidelines exempt farmers from obtaining NOCs. It calls for medium and large farmers to adopt water conservation measures.
Conservation fee:
- The draft also proposes to levy a new water conservation fee based on quantum of groundwater extraction in lieu of existing provision of creating recharge mechanism, including construction of artificial recharge structures, by those undertaking projects.
- The proposed fee is based on water use quantity and groundwater capacity of particular area zone.
- The amount, therefore, varies from Rs 1 to Rs 6 per cubic metre.
- The funds raised through this new fee will be used by states for effective ground water management.
Present Scenario:
- At present, the Central Ground Water Authority (CGWA) has been granting NOC for withdrawal of water by industries, infrastructure, and mining projects.
Basic Information:
- Central Ground Water Authority has been constituted under Section 3 (3) of the Environment (Protection) Act, 1986 to regulate and control development and management of ground water resources in the country.
6. New policy on the cards to boost medical tourism
Context:
- India is considered a preferred destination for cardiology, orthopaedics, transplant and ophthalmology in curative care, it also enjoys high credibility in wellness and prevention and alternative medicine.
In news:
- The government plans to bring out a policy to promote India as a key destination for medical tourism .
- The proposed policy aims to promote integrated treatment with allopathy, ayurveda, yoga, unani, siddha and homoeopathy (AYUSH) streams.
- The Union commerce ministry, along with ministries of tourism and health, has already launched a portal, indiahealthcaretourism.com , in three languages – Arabic, Russian and French— to provide comprehensive information to medical travellers.
- Medical tourism in India is projected to be a $9 billion opportunity by 2020. Currently, medical tourism industry is pegged at $3 billion. Globally, the medical tourism market is estimated at around $40-60 billion.
- Key Facts:
- India is emerging as one of the most credible destinations worldwide for curative treatment.
- With the given scale of healthcare infrastructure and projected growth, India can further strengthen its standing among the currently popular medical value tourism destinations such as Thailand, Singapore, Malaysia, and Mexico.
- A latest knowledge paper by FICCI and Quintiles IMS shows over 5,00,000 foreign patients seek treatment in India each year .
- SAARC countries such as Bangladesh, Afghanistan, and Maldives are the major sources of medical value travel, followed by African countries such as Nigeria, South Africa and Kenya.
- Reasons: Proximity, cultural connect and connectivity are the key reasons for inflow of patients to India from these regions.
Measures implemented to promote medical tourism:
- The process to issue medical visas has been made much more efficient, thus reducing the time taken in visa procurement.
- The scope of e-tourist visa has been expanded to include short- term medical treatment.
- Separate immigration counters and facilitation desks have also been set up at major Indian airports to boost the medical travel industry.
Context:
- New permanent committee and guidelines for designating lawyers in the SC and HC as senior advocates
Guidelines issued by the Supreme Court:
- The SC has laid down guidelines for designating lawyers in the SC and HC as senior advocates
- Now, applications will be examined by a permanent committee known as the Committee for Designation of Senior Advocates
- The committee will publish the names of candidates on the respective courts’ websites to ensure transparency
- Current system: Until now, the judges of the SC and HC had the sole discretion of according this status to advocates
Origin of collegium system: Political interference in the selection of judges in the third and fourth decades of independent India resulted in the collegium system where judges select judges
The Constitution (99th Amendment) Act, 2014 and the National Judicial Appointments Commission (NJAC) Act, 2014
- The opaque system and unsatisfactory selection, transfer, and elevation of judges to the SC caused disquiet and led to the passing of the acts
- The acts sought to give politicians and civil society a final say in the appointment of judges to the highest courts
- In 2015, a Constitution Bench of the SC declared these unconstitutional on the ground that the composition of the NJAC did not provide adequate representation to those from the judiciary
- It is in this context that one has to welcome the permanent committee
Composition of the permanent committee
It will consist of the:
(1) Chief Justice of India,
(2) Two senior-most judges of the Supreme Court/ High Courts,
(3) The Attorney General of India/ the Advocate General of State, and
(4) A member of the Bar to be nominated by the above four members
- The committee will have a permanent secretariat
- All applications for designation of senior advocate will be submitted to the secretariat
- The secretariat will compile all the relevant information with regard to the reputation, conduct, integrity, participation in pro-bono work, reported judgments in which the advocate has appeared, etc. of the candidates
- The committee will examine each candidate’s case, interview the candidate, and make its assessment based on a point-based format
Concerns:
- There may be some reservation on the aspect of publishing names on the official website of the court and inviting suggestions as in the recent past
- There have been reports of motivated complaints and objections
- The secretariat should not be dragged into the jumble of investigating frivolous complaints or objections
The way forward
- This institutional mechanism and selection criteria seem suited to substitute the existing collegium system
- The executive and the legislature could also seriously consider introducing a new version of the NJAC which incorporates the salient features of this institutional mechanism
- The sooner the judiciary adopts such a mechanism for judges too, the better it is for the institution
Category: INTERNATIONAL AFFAIRS/BILATERAL RELATIONS
1. Not just strategic ties with Dhaka: Sushma
Context:
- External Affairs minister visit to Bangladesh.
- India is following a policy of neighbours first, and among the neighbours Bangladesh is foremost
- Bilateral relations between India and Bangladesh have gone beyond a strategic partnership
In news:
- External Affairs Minister highlights India’s willingness to resolve all irritants in ties with Bangladesh with sincerity.
- Inaugurated 15 Indian-assisted development projects worth about $8.7 million.
- The development projects, worth about $8.7 million, include installation of 11 water treatment plants in the southwestern coastline of Pirozpur, 36 community clinics and reconstruction of Dhaka’s historic Ramna Kali Temple destroyed by invading Pakistani troops in the 1971 liberation war.
1. Has hunger increased in India in recent years?
Context:
- India’s ranking in Hunger Index
In news:
- India has ranked at the 100th position among 119 countries in its 2017 Global Hunger Index (GHI) rankings
- India has had a higher rank in previous versions of these rankings
- GHI is done by the Washington-based International Food Policy Research Institute (IFPRI)
Inference:
- These findings have created an impression that the prevalence of hunger has increased in India in recent years
- A closer looks at the numbers suggests that such conclusions are unwarranted
- To start with, the numbers reflect under-nutrition rather than hunger
- And even on that score, India’s performance, has been improving over the past decade although its nutritional indicators still appear poor compared to those of its peers
Basis of GHI 2017 rankings
The 2017 GHI rankings are based on the percentage of under-nourished population and three health indicators for children aged less than five years
(1) Wasting (low weight for height)
(2) Stunting (low height for age) and
(3) Mortality
The GHI can take values between zero to hundred
Zero would indicate absence of any of the indicators, while hundred would indicate the worst possible situation
Reduction in India’s GHI score
- The reduction in the GHI score is not surprising given what the statistics from the Food and Agriculture Organisation (FAO) and the National Family and Health Survey (NFHS)
- FAO data shows that prevalence of undernourishment has been decreasing in India over the past decade
Context:
- An expert committee submitted an interim report on ‘ How to police cyberspace’ to the Union Home Ministry .
- The report recommended amendments to the Indian Penal Code (IPC)
Key Points:
The recommended amendments to the Indian Penal Code (IPC) are noteworthy for two reasons
- One, they bring within the ambit of IPC (through amendments to Sections 153 and 505) any visual, audio, video, verbal or written communication, transmitted or retransmitted through any telecommunication service, device or computer
- They propose that any speech that is disparaging, offensive, indecent, abusive, hate, gravely threatening — and so interpreted — be criminalised
New avatar of Section 66A
- Section 66A of the IT Act may have been struck down in the Shreya Singhal case
- But this is its new, more astute avatar with a better-operating legal-ware
- It seeks to add yet another speech-control legislation to the plethora of existing penal codes
- These are Sections 295A, 124A, 153A, 505 that target acts ranging from malicious, to seditious, to disruptive of public order or morality, to violent, to plain mischievous
Governments’ dubious records on free speech
- There have been many cases where on one or the other pretext of public order, morality, derogatory speech, slander, and defamation was used to outlaw advocacy, mirth, caricature and the worst of all crimes, dissent
- It chooses to turn a deaf ear to posts, threats, and tweets that are deeply offensive, obscene, misogynistic and violently communal
- It chooses to remain unmoved by any civic or national imperative when the target of vicious trolling are journalists, film-makers, authors, writers, painters, common people who are just doing their jobs as citizens
- It even chooses to use an ordinance, as in Rajasthan, to outlaw the investigation into the conduct of judicial or political power
Freedom of speech
- It is nobody’s case that the freedom of speech is an absolute freedom
- But our constitutional commitment to free speech demands that it cannot be suppressed unless the situations created by allowing the freedom are pressing and the community interest is endangered
- This “danger” cannot be remote, hypothetical, or stemming from a poor appetite for mirth and scorn
- It should have, as the Supreme Court said in Shreya Singhal case, a proximate and direct nexus with the expression
Controlled speech adds to impunity of political power
- The trade-off between free speech and public order/morality has never hurt political dispensations
- The more controlled speech is, the greater has been the immunity and impunity of political power
Free speech is signal of healthy democracy
- We need to remember that free speech preconditions the realisation of many of our claims and entitlements
- Less of it translates into less democracy in general
Nothing here for Today!!!
|
Nothing here for Today!!! |
F. Practice Questions for UPSC Prelims Exam
G. UPSC Mains Practice Questions
GS Paper I
- Discuss the contributions of MaulanaAbulKalam Azad to pre- and post-independent India.
GS Paper II
- “Free speech is signal of healthy democracy”. Comment


|
|
Pv power diversion to immersion with SSR ? |
29 |
1 year 28 weeks ago by scobo |
1 year 13 weeks ago by ajscheid |
|
|
EmonTX Current Sensors |
18 |
1 year 28 weeks ago by davekramkowski |
1 year 27 weeks ago by Robert Wall |
|
|
Resistor Current? |
3 |
1 year 28 weeks ago by Harescti |
1 year 28 weeks ago by Harescti |
|
|
Euronet 50-50max |
3 |
1 year 28 weeks ago by helianto |
1 year 28 weeks ago by Robert Wall |
|
|
emonPi USA CTs |
3 |
1 year 28 weeks ago by Adam Byers |
1 year 28 weeks ago by davekramkowski |
|
|
California Duck Curve - in the UK? |
3 |
1 year 28 weeks ago by ChrisBirkett |
1 year 28 weeks ago by dBC |
|
|
EmonPi beginner question - Use with intermittent network connectivity |
8 |
1 year 28 weeks ago by alex_london |
1 year 10 weeks ago by ChrisValentine |
|
|
Computing AC voltage & phase difference(HELP) |
1 |
1 year 27 weeks ago by lamela |
1 year 27 weeks ago by Robert Wall |
|
|
emonTX Shield - how do I set it up? |
9 |
1 year 27 weeks ago by SnaxMuppet |
1 year 27 weeks ago by SnaxMuppet |
|
|
Calibrating EmonTX |
8 |
1 year 27 weeks ago by davekramkowski |
1 year 27 weeks ago by Robert Wall |
|
|
Wrong AC Current reading |
9 |
1 year 27 weeks ago by lamela |
1 year 26 weeks ago by Robert Wall |
|
|
North America 400A 96KW drop from utility broken into two 200A 48KW load centers, 200A current clamps? |
14 |
1 year 27 weeks ago by LukeS |
1 year 27 weeks ago by Robert Wall |
|
|
Question regarding stepping down voltage |
3 |
1 year 27 weeks ago by lamela |
1 year 26 weeks ago by Robert Wall |
|
|
Current only diverter. |
2 |
1 year 26 weeks ago by Cancelor |
1 year 26 weeks ago by Cancelor |
|
|
Using Martin R's solar diverter for remote load switching |
10 |
1 year 26 weeks ago by Paul Reed |
1 year 26 weeks ago by Paul Reed |
|
|
Adding a 7 segment display to Arduino mk2 pv diverter small problem |
4 |
1 year 26 weeks ago by rob1953 |
1 year 25 weeks ago by rob1953 |
|
|
Why do pulse sensor readings from my generation meter differ from the daily outputs recorded on my inverter display? |
11 |
1 year 26 weeks ago by Toberwine |
1 year 25 weeks ago by Toberwine |
|
|
Uploading data to pvoutput.org |
1 |
1 year 26 weeks ago by Toberwine |
1 year 26 weeks ago by Bill Thomson |
|
|
Converting optical kWh pulse count into power reading |
23 |
1 year 26 weeks ago by Toberwine |
1 year 21 weeks ago by Toberwine |
|
|
Solar panel monitoring system project |
0 |
1 year 26 weeks ago by beegee1962 |
n/a |
|
|
Utility detection |
1 |
1 year 25 weeks ago by DRL |
1 year 25 weeks ago by Robert Wall |
|
|
Dragons' Den - Series 13: Episode 6 |
2 |
1 year 25 weeks ago by Geoff Soord |
1 year 25 weeks ago by Geoff Soord |
|
|
Anyone actually monitoring gas meter with a pulse counter? |
0 |
1 year 25 weeks ago by BraileTrail |
n/a |
|
|
Emontx |
0 |
1 year 25 weeks ago by amine dronga |
n/a |
|
|
Off Grid Solar monitoring - Help for what to purchase. |
2 |
1 year 25 weeks ago by dogedart |
1 year 25 weeks ago by Thumperup |
|
|
Openhab nRF24L01+ energy monitor |
16 |
1 year 25 weeks ago by DragosC |
1 year 21 weeks ago by dBC |
|
|
Monitor of Solar system |
5 |
1 year 25 weeks ago by jurgen |
1 year 25 weeks ago by Robert Wall |
|
|
DC Monitoring Working |
2 |
1 year 25 weeks ago by Thumperup |
1 year 23 weeks ago by Thumperup |
|
|
switching fixed load on when surplus pv passes programmed amount. |
14 |
1 year 24 weeks ago by saggers |
1 year 7 weeks ago by calypso_rae |
|
|
Getting weather station data into the emoncms? Anyone got good ideas? |
12 |
1 year 24 weeks ago by goodfidelity |
1 year 17 weeks ago by goodfidelity |
|
|
Robin Mk II was not working - traced to possible installation fault. |
9 |
1 year 24 weeks ago by Chassyh |
1 year 24 weeks ago by Robert Wall |
|
|
the current state of HVAC in Open Energy Monitor? |
0 |
1 year 23 weeks ago by bdg2015 |
n/a |
|
|
OW-Server (EDS) |
0 |
1 year 23 weeks ago by Cyberslow |
n/a |
|
|
The Official Emoncms Android App |
217 |
1 year 22 weeks ago by JumpMaster |
37 weeks 4 days ago by AllenConquest |
|
|
Trystan Lea on Swiss French TV at POC 21 (Proof of concept) |
4 |
1 year 22 weeks ago by daturach |
1 year 22 weeks ago by daturach |
|
|
EmonPI newbie question!! |
1 |
1 year 22 weeks ago by pcmm |
1 year 22 weeks ago by Robert Wall |
|
|
Industruino |
6 |
1 year 21 weeks ago by dBC |
1 year 21 weeks ago by Bill Thomson |
|
|
Making a living from the Open Energy Monitor? |
6 |
1 year 20 weeks ago by cagabi |
1 year 16 weeks ago by cagabi |
|
|
ESP8266 MQTT WIFI energy monitor project |
8 |
1 year 20 weeks ago by hwstar |
1 year 18 weeks ago by hwstar |
|
|
fail pecl.php.net swift/swift |
4 |
1 year 20 weeks ago by camilosti |
1 year 19 weeks ago by Bill Thomson |
|
|
Micro Inverter Momentary Dropouts |
3 |
1 year 19 weeks ago by sheppy |
1 year 18 weeks ago by dBC |
|
|
Solar array monitoring - CT turns recommendations? |
4 |
1 year 18 weeks ago by sheppy |
1 year 15 weeks ago by calypso_rae |
|
|
Can't connect to database |
0 |
1 year 18 weeks ago by stanleyind |
n/a |
|
|
Introducing the Telegea community project |
3 |
1 year 18 weeks ago by ondrej1024 |
1 year 14 weeks ago by ondrej1024 |
|
|
The eMon Possibilities |
3 |
1 year 18 weeks ago by M0n0wall |
1 year 17 weeks ago by Derekb |
|
|
RF69 reliability, timing, temp sensors, mqtt & lowpowerlabs |
24 |
1 year 18 weeks ago by TrystanLea |
1 year 9 weeks ago by TrystanLea |
|
|
RFM69 / 433MHz capacity |
0 |
1 year 18 weeks ago by sheppy |
n/a |
|
|
emonGLCD - Display 4 ct readings - help needed |
7 |
1 year 18 weeks ago by jpbrigg |
1 year 18 weeks ago by jpbrigg |
|
|
OpenEnergyMonitor development history update October 2015 |
0 |
1 year 18 weeks ago by TrystanLea |
n/a |
|
|
Measure single values from 3phase system |
3 |
1 year 18 weeks ago by nigel91 |
1 year 18 weeks ago by Robert Wall |


Unit 3
1. Present perfect: simple vs continuous
Present perfect: simple vs continuous
1. Complete the sentences using the present perfect simple or continuous from of the verbs.
Example: I've been reading (read) this book for ages, but I'm only on page 62.
Remember
We use the present perfect simple to talk about an action that is finished.
- I've read a good book.
We use the present perfect continuous to talk about an action that finished very recently or might continue.
- I've been reading a good book.
2. Present perfect simple with just
Write sentences and quiestions using the present perfect simple with just.
We often use just with the present perfect simple. It is used to reinforce the idea that an action has only bin completed very recently. It is used in affirmative sentences and goes between the auxiliary has / have and the past participle.
3. Present perfect simple with still, yet and already. Choose the correct meanings.
Solution
Solution
Solution
Solution
Solution
Solution
4. Relative clauses
Choose the correct words.


pragma solidity ^0.4.24;
import "zos-lib/contracts/Initializable.sol";
import "../token/ERC20/IERC20.sol";
import "../math/SafeMath.sol";
import "../token/ERC20/SafeERC20.sol";
/**
* @title Crowdsale
* @dev Crowdsale is a base contract for managing a token crowdsale,
* allowing investors to purchase tokens with ether. This contract implements
* such functionality in its most fundamental form and can be extended to provide additional
* functionality and/or custom behavior.
* The external interface represents the basic interface for purchasing tokens, and conform
* the base architecture for crowdsales. They are *not* intended to be modified / overridden.
* The internal interface conforms the extensible and modifiable surface of crowdsales. Override
* the methods to add functionality. Consider using 'super' where appropriate to concatenate
* behavior.
*/
contract Crowdsale is Initializable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
// The token being sold
IERC20 private _token;
// Address where funds are collected
address private _wallet;
// How many token units a buyer gets per wei.
// The rate is the conversion between wei and the smallest and indivisible token unit.
// So, if you are using a rate of 1 with a ERC20Detailed token with 3 decimals called TOK
// 1 wei will give you 1 unit, or 0.001 TOK.
uint256 private _rate;
// Amount of wei raised
uint256 private _weiRaised;
/**
* Event for token purchase logging
* @param purchaser who paid for the tokens
* @param beneficiary who got the tokens
* @param value weis paid for purchase
* @param amount amount of tokens purchased
*/
event TokensPurchased(
address indexed purchaser,
address indexed beneficiary,
uint256 value,
uint256 amount
);
/**
* @param rate Number of token units a buyer gets per wei
* @dev The rate is the conversion between wei and the smallest and indivisible
* token unit. So, if you are using a rate of 1 with a ERC20Detailed token
* with 3 decimals called TOK, 1 wei will give you 1 unit, or 0.001 TOK.
* @param wallet Address where collected funds will be forwarded to
* @param token Address of the token being sold
*/
function initialize(uint256 rate, address wallet, IERC20 token) public initializer {
require(rate > 0);
require(wallet != address(0));
require(token != address(0));
_rate = rate;
_wallet = wallet;
_token = token;
}
// -----------------------------------------
// Crowdsale external interface
// -----------------------------------------
/**
* @dev fallback function ***DO NOT OVERRIDE***
*/
function () external payable {
buyTokens(msg.sender);
}
/**
* @return the token being sold.
*/
function token() public view returns(IERC20) {
return _token;
}
/**
* @return the address where funds are collected.
*/
function wallet() public view returns(address) {
return _wallet;
}
/**
* @return the number of token units a buyer gets per wei.
*/
function rate() public view returns(uint256) {
return _rate;
}
/**
* @return the mount of wei raised.
*/
function weiRaised() public view returns (uint256) {
return _weiRaised;
}
/**
* @dev low level token purchase ***DO NOT OVERRIDE***
* @param beneficiary Address performing the token purchase
*/
function buyTokens(address beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(beneficiary, weiAmount);
// calculate token amount to be created
uint256 tokens = _getTokenAmount(weiAmount);
// update state
_weiRaised = _weiRaised.add(weiAmount);
_processPurchase(beneficiary, tokens);
emit TokensPurchased(
msg.sender,
beneficiary,
weiAmount,
tokens
);
_updatePurchasingState(beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(beneficiary, weiAmount);
}
// -----------------------------------------
// Internal interface (extensible)
// -----------------------------------------
function _hasBeenInitialized() internal view returns (bool) {
return ((_rate > 0) && (_wallet != address(0)) && (_token != address(0)));
}
/**
* @dev Validation of an incoming purchase. Use require statements to revert state when conditions are not met. Use `super` in contracts that inherit from Crowdsale to extend their validations.
* Example from CappedCrowdsale.sol's _preValidatePurchase method:
* super._preValidatePurchase(beneficiary, weiAmount);
* require(weiRaised().add(weiAmount) <= cap);
* @param beneficiary Address performing the token purchase
* @param weiAmount Value in wei involved in the purchase
*/
function _preValidatePurchase(
address beneficiary,
uint256 weiAmount
)
internal
{
require(beneficiary != address(0));
require(weiAmount != 0);
}
/**
* @dev Validation of an executed purchase. Observe state and use revert statements to undo rollback when valid conditions are not met.
* @param beneficiary Address performing the token purchase
* @param weiAmount Value in wei involved in the purchase
*/
function _postValidatePurchase(
address beneficiary,
uint256 weiAmount
)
internal
{
// optional override
}
/**
* @dev Source of tokens. Override this method to modify the way in which the crowdsale ultimately gets and sends its tokens.
* @param beneficiary Address performing the token purchase
* @param tokenAmount Number of tokens to be emitted
*/
function _deliverTokens(
address beneficiary,
uint256 tokenAmount
)
internal
{
_token.safeTransfer(beneficiary, tokenAmount);
}
/**
* @dev Executed when a purchase has been validated and is ready to be executed. Not necessarily emits/sends tokens.
* @param beneficiary Address receiving the tokens
* @param tokenAmount Number of tokens to be purchased
*/
function _processPurchase(
address beneficiary,
uint256 tokenAmount
)
internal
{
_deliverTokens(beneficiary, tokenAmount);
}
/**
* @dev Override for extensions that require an internal state to check for validity (current user contributions, etc.)
* @param beneficiary Address receiving the tokens
* @param weiAmount Value in wei involved in the purchase
*/
function _updatePurchasingState(
address beneficiary,
uint256 weiAmount
)
internal
{
// optional override
}
/**
* @dev Override to extend the way in which ether is converted to tokens.
* @param weiAmount Value in wei to be converted into tokens
* @return Number of tokens that can be purchased with the specified _weiAmount
*/
function _getTokenAmount(uint256 weiAmount)
internal view returns (uint256)
{
return weiAmount.mul(_rate);
}
/**
* @dev Determines how ETH is stored/forwarded on purchases.
*/
function _forwardFunds() internal {
_wallet.transfer(msg.value);
}
uint256[50] private ______gap;
}
|


Graduate Student at San Jose State University with 3+ years of experience as a Software Engineer with hands-on on all phases of web development and a keen interest towards Autonomous Systems, Deep Learning and Computer Vision.
Software Engineering
GPA: 3.39
Electrical and Electronics Engineering
GPA: 3.19


Examples that use the 1st version of the framework:
Example posts
Example users
Example charts
Currently at development:
Example 2.0


Learn Coding
One of FireMiner99's Scratch Projects
Demonstrate Fade In with different parameters usinng jQuery.
Click to fade in boxes


Exodus 35:27
And the rulers brought onyx stones, and stones to be set, for the ephod, and for the breastplate;


{% load static %}
{{user_admin_obj.username}}
School of Engineering and Applied Science
Main
Login as Other User
Gallery
FAQ
Logout
Your Valuable Feedback Of Your Last Visit
{% csrf_token %}
{{errors}}


Provides an API for analysing repetitive parameter estimations and simulations of mathematical models. Examples of mathematical models are Ordinary Differential equations (ODEs) or Stochastic Differential Equations (SDEs) models. Among the analyses for parameter estimation 'sbpiper' calculates statistics and generates plots for parameter density, PCA of the best fits, parameter profile likelihood estimations (PLEs), and 2D parameter PLEs. These results can be generated using all or a subset of the best computed parameter sets. Among the analyses for model simulation 'sbpiper' calculates statistics and generates plots for deterministic and stochastic time courses via cartesian and heatmap plots. Plots for the scan of one or two model parameters can also be generated. This package is primarily used by the software 'SBpipe'. Citation: Dalle Pezze P, Le Novère N. SBpipe: a collection of pipelines for automating repetitive simulation and analysis tasks. BMC Systems Biology. 2017;11:46. <doi:10.1186/s12918-017-0423-3>.
| Version: | 1.9.0 |
| Depends: | R (≥ 3.2.0) |
| Imports: | colorRamps, data.table, factoextra, FactoMineR, ggplot2 (≥ 2.2.0), grDevices, Hmisc, reshape2, scales, stats, stringr, utils |
| Published: | 2018-06-26 |
| Author: | Piero Dalle Pezze [aut, cre, cph] |
| Maintainer: | Piero Dalle Pezze <piero.dallepezze at gmail.com> |
| BugReports: | https://github.com/pdp10/sbpiper/issues |
| License: | MIT + file LICENSE |
| URL: | https://github.com/pdp10/sbpiper |
| NeedsCompilation: | no |
| Citation: | sbpiper citation info |
| Materials: | README |
| CRAN checks: | sbpiper results |
| Reference manual: | sbpiper.pdf |
| Package source: | sbpiper_1.9.0.tar.gz |
| Windows binaries: | r-devel: sbpiper_1.9.0.zip, r-release: sbpiper_1.9.0.zip, r-oldrel: sbpiper_1.9.0.zip |
| OS X binaries: | r-release: sbpiper_1.9.0.tgz, r-oldrel: sbpiper_1.9.0.tgz |
| Old sources: | sbpiper archive |
Please use the canonical form https://CRAN.R-project.org/package=sbpiper to link to this page.


{% extends "layout.html" %} {% block body %}
All data in the SweGen dataset are human allele frequencies estimated from aggregates across large sample groups, rendering contributing individuals non-identifiable. The method used for estimating the frequencies is described in the corresponding publication. Data is versioned and frequencies in different data versions may be different. No individual level genetic data is contained in this dataset. We encourage the use and publication of frequency data for specific targeted sets of variants (for instance, assessing a set of candidate causal variants observed in a collection of rare disease patients).
By accessing the data you agree to the following terms and conditions, irrespective of the method used to retrieve the data (for example vcf file download or variant query through Beacon or other methods):
This dataset is based on individuals from population-based cross-sectional studies. No phenotype information has been used as inclusion criteria in the dataset. Individuals with common diseases occur at the general population prevalence of the disease. As a consequence, genetic variants contributing to disease risk occur in the dataset at the general population frequency. There is no explicit or implicit guarantee that the genetic variants in the dataset do not contribute to risk of disease.
Any use of SweGen data should be cited by our preprint on bioRxiv [http://biorxiv.org/content/early/2016/10/17/081505]


Fintech Startup Capitolis Raises $40 Million
Capitolis develops an online marketplace where banks and financial institutions can manage their capital and establish collaborations
by Meir OrbachFintech startup Capitolis Inc. has raised $40 million in a series B funding round led by Spark Capital and Silicon Valley Bank Capital, the former announced Wednesday. Existing investors Index Ventures, Sequoia Capital, and S Capital also participated in the round.
Capitolis develops an online marketplace where banks and financial institutions can manage their capital and establish collaborations to maximize their economic performance.
The company intends to use the funding to expand its sales and marketing teams, CEO Gil Mandelzis said in an interview with Calcalist.
Capitolis was founded in 2016 by CEO Gil Mandelzis, the former CEO of electronic trading technology company EBS BrokerTec (now NEX Markets) and founder of software company Traiana, and by Chairman Tom Glocer, the former CEO of Thomson Reuters. The company currently employs 55 people in its Tel Aviv, London, and New York Offices and has raised $70 million to date.


Dev Bootcamp's Culture
Why I'm excited and worried to be starting
I’m really excited to be part of an organization that has the mentality of constant growth. In my last job I had a lot of power to change processes or create new ones from scratch and that was one of the things I enjoyed the most about that culture.
In the last six months I could feel myself start to slowly burn out. I started to experience lack of motivation to do tasks that I used to enjoy and decreased satisfaction for everything in my life. When I realized these feelings were starting I knew I needed to make changes. I tried a few things, but came to the conclusion that I needed to try something completely different to get out of the funk and back to being the go-getter I was when I started.
I’m really glad that Dev Bootcamp starts off slower with only 15-25 hours/week. It’s giving me time to take things slower and recover the energy I used to have. I’m still concerned that I won’t have the same drive to start Phase 1 as I did to start my last job, or had all throughout college. However, what I’m more concerned about is that I can tell I started to have a fixed mindset and a lot of cynicism for any changes at the company. These issues seem harder to fix, but I’m really glad that the readings so far have helped me identify those weaknesses so I can begin to make improvements.


During her family's move to the suburbs, a sullen 10-year-old girl wanders into a world ruled by witches and spirits, and where humans are changed into pigs
| Director | Hayao Miyazaki |
| Producer | Toshio Suzuki |
| Written by | Hayao Miyazaki |
| Music by | Joe Hisaishi |
| Cinematography | Atsushi Okui |
| Editor | Takeshi Seyama |
| Cast | |
|---|---|
| Chihiro | Rumi Hiiragi |
| Haku | Miyu Irino |
| Yubaba/Zeniba | Mari Natsuki |
| Kamajii | Bunta Sugawara |
| Lin | Yumi Tamai |
| Chichiyaku | Tsunehiko Kamijō |
| Aniyaku | Takehiko Ono |
| No-Face | Akio Nakamura |
| Aogaeru | Tatsuya Gahūin |
| Bandai-gaeru | Yō Ōizumi |
| Boh | Ryūnosuke Kamiki |
| Father | Takashi Naitō |
| Mother | Yasuko Sawaguchi |
| River Spirit | Koba Hayashi |
| Oshira | Ken Yasuda |


<EMAIL_ADDRESS>expressly disclaims any liability or responsibility for any damages, loss or injury arising out of any business transaction/s or contract/s between the buyer/s, vendor/s and/or any related/not related/involved persons or any other party due to the usage of this website.


Overview of built-in stages and their semantics
Source stages
These built-in sources are available from akka.stream.scaladsl.Source:
fromIterator
Stream the values from an Iterator, requesting the next value when there is demand. The iterator will be created anew for each materialization, which is the reason the method takes a function rather than an iterator directly.
If the iterator perform blocking operations, make sure to run it on a separate dispatcher.
emits the next value returned from the iterator
completes when the iterator reaches its end
apply
Stream the values of an immutable.Seq.
emits the next value of the seq
completes when the last element of the seq has been emitted
single
Stream a single object
emits the value once
completes when the single value has been emitted
repeat
Stream a single object repeatedly
emits the same value repeatedly when there is demand
completes never
cycle
Stream iterator in cycled manner. Internally new iterator is being created to cycle the one provided via argument meaning when original iterator runs out of elements process will start all over again from the beginning of the iterator provided by the evaluation of provided parameter. If method argument provides empty iterator stream will be terminated with exception.
emits the next value returned from cycled iterator
completes never
tick
A periodical repetition of an arbitrary object. Delay of first tick is specified separately from interval of the following ticks.
emits periodically, if there is downstream backpressure ticks are skipped
completes never
fromFuture
Send the single value of the Future when it completes and there is demand. If the future fails the stream is failed with that exception.
emits the future completes
completes after the future has completed
fromCompletionStage
Send the single value of the Java CompletionStage when it completes and there is demand. If the future fails the stream is failed with that exception.
emits the future completes
completes after the future has completed
unfold
Stream the result of a function as long as it returns a Some, the value inside the option consists of a tuple where the first value is a state passed back into the next call to the function allowing to pass a state. The first invocation of the provided fold function will receive the zero state.
Can be used to implement many stateful sources without having to touch the more low level GraphStage API.
emits when there is demand and the unfold function over the previous state returns non empty value
completes when the unfold function returns an empty value
unfoldAsync
Just like unfold but the fold function returns a Future which will cause the source to complete or emit when it completes.
Can be used to implement many stateful sources without having to touch the more low level GraphStage API.
emits when there is demand and unfold state returned future completes with some value
completes when the future returned by the unfold function completes with an empty value
empty
Complete right away without ever emitting any elements. Useful when you have to provide a source to an API but there are no elements to emit.
emits never
completes directly
maybe
Materialize a Promise[Option[T]] that if completed with a Some[T] will emit that T and then complete the stream, or if completed with None complete the stream right away.
emits when the returned promise is completed with some value
completes after emitting some value, or directly if the promise is completed with no value
failed
Fail directly with a user specified exception.
emits never
completes fails the stream directly with the given exception
actorPublisher
Wrap an actor extending ActorPublisher as a source.
emits depends on the actor implementation
completes when the actor stops
actorRef
Materialize an ActorRef, sending messages to it will emit them on the stream. The actor contain a buffer but since communication is one way, there is no back pressure. Handling overflow is done by either dropping elements or failing the stream, the strategy is chosen by the user.
emits when there is demand and there are messages in the buffer or a message is sent to the actorref
completes when the actorref is sent akka.actor.Status.Success or PoisonPill
combine
Combine several sources, using a given strategy such as merge or concat, into one source.
emits when there is demand, but depending on the strategy
completes when all sources has completed
unfoldResource
Wrap any resource that can be opened, queried for next element (in a blocking way) and closed using three distinct functions into a source.
emits when there is demand and read function returns value
completes when read function returns None
unfoldResourceAsync
Wrap any resource that can be opened, queried for next element (in a blocking way) and closed using three distinct functions into a source. Functions return Future to achieve asynchronous processing
emits when there is demand and Future from read function returns value
completes when Future from read function returns None
queue
Materialize a SourceQueue onto which elements can be pushed for emitting from the source. The queue contains a buffer, if elements are pushed onto the queue faster than the source is consumed the overflow will be handled with a strategy specified by the user. Functionality for tracking when an element has been emitted is available through SourceQueue.offer.
emits when there is demand and the queue contains elements
completes when downstream completes
asSubscriber
Integration with Reactive Streams, materializes into a org.reactivestreams.Subscriber.
fromPublisher
Integration with Reactive Streams, subscribes to a org.reactivestreams.Publisher.
zipN
Combine the elements of multiple streams into a stream of sequences.
emits when all of the inputs has an element available
completes when any upstream completes
zipWithN
Combine the elements of multiple streams into a stream of sequences using a combiner function.
emits when all of the inputs has an element available
completes when any upstream completes
Sink stages
These built-in sinks are available from akka.stream.scaladsl.Sink:
head
Materializes into a Future which completes with the first value arriving, after this the stream is canceled. If no element is emitted, the future is be failed.
cancels after receiving one element
backpressures never
headOption
Materializes into a Future[Option[T]] which completes with the first value arriving wrapped in a Some, or a None if the stream completes without any elements emitted.
cancels after receiving one element
backpressures never
last
Materializes into a Future which will complete with the last value emitted when the stream completes. If the stream completes with no elements the future is failed.
cancels never
backpressures never
lastOption
Materialize a Future[Option[T]] which completes with the last value emitted wrapped in an Some when the stream completes. if the stream completes with no elements the future is completed with None.
cancels never
backpressures never
ignore
Consume all elements but discards them. Useful when a stream has to be consumed but there is no use to actually do anything with the elements.
cancels never
backpressures never
cancelled
Immediately cancel the stream
cancels immediately
seq
Collect values emitted from the stream into a collection, the collection is available through a Future or which completes when the stream completes. Note that the collection is bounded to Int.MaxValue, if more element are emitted the sink will cancel the stream
cancels If too many values are collected
foreach
Invoke a given procedure for each element received. Note that it is not safe to mutate shared state from the procedure.
The sink materializes into a Future[Option[Done]] which completes when the stream completes, or fails if the stream fails.
Note that it is not safe to mutate state from the procedure.
cancels never
backpressures when the previous procedure invocation has not yet completed
foreachParallel
Like foreach but allows up to parallellism procedure calls to happen in parallel.
cancels never
backpressures when the previous parallel procedure invocations has not yet completed
onComplete
Invoke a callback when the stream has completed or failed.
cancels never
backpressures never
lazyInit
Invoke sinkFactory function to create a real sink upon receiving the first element. Internal Sink will not be created if there are no elements, because of completion or error. fallback will be invoked if there was no elements and completed is received from upstream.
cancels never
backpressures when initialized and when created sink backpressures
queue
Materialize a SinkQueue that can be pulled to trigger demand through the sink. The queue contains a buffer in case stream emitting elements faster than queue pulling them.
cancels when SinkQueue.cancel is called
backpressures when buffer has some space
fold
Fold over emitted element with a function, where each invocation will get the new element and the result from the previous fold invocation. The first invocation will be provided the zero value.
Materializes into a future that will complete with the last state when the stream has completed.
This stage allows combining values into a result without a global mutable state by instead passing the state along between invocations.
cancels never
backpressures when the previous fold function invocation has not yet completed
reduce
Apply a reduction function on the incoming elements and pass the result to the next invocation. The first invocation receives the two first elements of the flow.
Materializes into a future that will be completed by the last result of the reduction function.
cancels never
backpressures when the previous reduction function invocation has not yet completed
combine
Combine several sinks into one using a user specified strategy
cancels depends on the strategy
backpressures depends on the strategy
actorRef
Send the elements from the stream to an ActorRef. No backpressure so care must be taken to not overflow the inbox.
cancels when the actor terminates
backpressures never
actorRefWithAck
Send the elements from the stream to an ActorRef which must then acknowledge reception after completing a message, to provide back pressure onto the sink.
cancels when the actor terminates
backpressures when the actor acknowledgement has not arrived
actorSubscriber
Create an actor from a Props upon materialization, where the actor implements ActorSubscriber, which will receive the elements from the stream.
Materializes into an ActorRef to the created actor.
cancels when the actor terminates
backpressures depends on the actor implementation
asPublisher
Integration with Reactive Streams, materializes into a org.reactivestreams.Publisher.
fromSubscriber
Integration with Reactive Streams, wraps a org.reactivestreams.Subscriber as a sink
Additional Sink and Source converters
Sources and sinks for integrating with java.io.InputStream and java.io.OutputStream can be found on StreamConverters. As they are blocking APIs the implementations of these stages are run on a separate dispatcher configured through the akka.stream.blocking-io-dispatcher.
fromOutputStream
Create a sink that wraps an OutputStream. Takes a function that produces an OutputStream, when the sink is materialized the function will be called and bytes sent to the sink will be written to the returned OutputStream.
Materializes into a Future which will complete with a IOResult when the stream completes.
Note that a flow can be materialized multiple times, so the function producing the OutputStream must be able to handle multiple invocations.
The OutputStream will be closed when the stream that flows into the Sink is completed, and the Sink will cancel its inflow when the OutputStream is no longer writable.
asInputStream
Create a sink which materializes into an InputStream that can be read to trigger demand through the sink. Bytes emitted through the stream will be available for reading through the InputStream
The InputStream will be ended when the stream flowing into this Sink completes, and the closing the InputStream will cancel the inflow of this Sink.
fromInputStream
Create a source that wraps an InputStream. Takes a function that produces an InputStream, when the source is materialized the function will be called and bytes from the InputStream will be emitted into the stream.
Materializes into a Future which will complete with a IOResult when the stream completes.
Note that a flow can be materialized multiple times, so the function producing the InputStream must be able to handle multiple invocations.
The InputStream will be closed when the Source is canceled from its downstream, and reaching the end of the InputStream will complete the Source.
asOutputStream
Create a source that materializes into an OutputStream. When bytes are written to the OutputStream they are emitted from the source.
The OutputStream will no longer be writable when the Source has been canceled from its downstream, and closing the OutputStream will complete the Source.
asJavaStream
Create a sink which materializes into Java 8 Stream that can be run to trigger demand through the sink. Elements emitted through the stream will be available for reading through the Java 8 Stream.
The Java 8 Stream will be ended when the stream flowing into this Sink completes, and closing the Java Stream will cancel the inflow of this Sink. Java Stream throws exception in case reactive stream failed.
Be aware that Java Stream blocks current thread while waiting on next element from downstream.
fromJavaStream
Create a source that wraps a Java 8 Stream. Source uses a stream iterator to get all its elements and send them downstream on demand.
javaCollector
Create a sink which materializes into a Future which will be completed with a result of the Java 8 Collector transformation and reduction operations. This allows usage of Java 8 streams transformations for reactive streams. The Collector will trigger demand downstream. Elements emitted through the stream will be accumulated into a mutable result container, optionally transformed into a final representation after all input elements have been processed. The Collector can also do reduction at the end. Reduction processing is performed sequentially
Note that a flow can be materialized multiple times, so the function producing the Collector must be able to handle multiple invocations.
javaCollectorParallelUnordered
Create a sink which materializes into a Future which will be completed with a result of the Java 8 Collector transformation and reduction operations. This allows usage of Java 8 streams transformations for reactive streams. The Collector is triggering demand downstream. Elements emitted through the stream will be accumulated into a mutable result container, optionally transformed into a final representation after all input elements have been processed. The Collector can also do reduction at the end. Reduction processing is performed in parallel based on graph Balance.
Note that a flow can be materialized multiple times, so the function producing the Collector must be able to handle multiple invocations.
File IO Sinks and Sources
Sources and sinks for reading and writing files can be found on FileIO.
fromFile
Emit the contents of a file, as ByteString s, materializes into a Future which will be completed with a IOResult upon reaching the end of the file or if there is a failure.
toFile
Create a sink which will write incoming ByteString s to a given file.
Flow stages
All flows by default backpressure if the computation they encapsulate is not fast enough to keep up with the rate of incoming elements from the preceding stage. There are differences though how the different stages handle when some of their downstream stages backpressure them.
Most stages stop and propagate the failure downstream as soon as any of their upstreams emit a failure. This happens to ensure reliable teardown of streams and cleanup when failures happen. Failures are meant to be to model unrecoverable conditions, therefore they are always eagerly propagated. For in-band error handling of normal errors (dropping elements if a map fails for example) you should use the supervision support, or explicitly wrap your element types in a proper container that can express error or success states (for example Try in Scala).
Simple processing stages
These stages can transform the rate of incoming elements since there are stages that emit multiple elements for a single input (e.g. mapConcat') or consume multiple elements before emitting one output (e.g. ``filter`). However, these rate transformations are data-driven, i.e. it is the incoming elements that define how the rate is affected. This is in contrast with Backpressure aware stages which can change their processing behavior depending on being backpressured by downstream or not.
map
Transform each element in the stream by calling a mapping function with it and passing the returned value downstream.
emits when the mapping function returns an element
backpressures when downstream backpressures
completes when upstream completes
mapConcat
Transform each element into zero or more elements that are individually passed downstream.
emits when the mapping function returns an element or there are still remaining elements from the previously calculated collection
backpressures when downstream backpressures or there are still available elements from the previously calculated collection
completes when upstream completes and all remaining elements has been emitted
statefulMapConcat
Transform each element into zero or more elements that are individually passed downstream. The difference to mapConcat is that the transformation function is created from a factory for every materialization of the flow.
emits when the mapping function returns an element or there are still remaining elements from the previously calculated collection
backpressures when downstream backpressures or there are still available elements from the previously calculated collection
completes when upstream completes and all remaining elements has been emitted
filter
Filter the incoming elements using a predicate. If the predicate returns true the element is passed downstream, if it returns false the element is discarded.
emits when the given predicate returns true for the element
backpressures when the given predicate returns true for the element and downstream backpressures
completes when upstream completes
filterNot
Filter the incoming elements using a predicate. If the predicate returns false the element is passed downstream, if it returns true the element is discarded.
emits when the given predicate returns false for the element
backpressures when the given predicate returns false for the element and downstream backpressures
completes when upstream completes
collect
Apply a partial function to each incoming element, if the partial function is defined for a value the returned value is passed downstream. Can often replace filter followed by map to achieve the same in one single stage.
emits when the provided partial function is defined for the element
backpressures the partial function is defined for the element and downstream backpressures
completes when upstream completes
grouped
Accumulate incoming events until the specified number of elements have been accumulated and then pass the collection of elements downstream.
emits when the specified number of elements has been accumulated or upstream completed
backpressures when a group has been assembled and downstream backpressures
completes when upstream completes
sliding
Provide a sliding window over the incoming stream and pass the windows as groups of elements downstream.
Note: the last window might be smaller than the requested size due to end of stream.
emits the specified number of elements has been accumulated or upstream completed
backpressures when a group has been assembled and downstream backpressures
completes when upstream completes
scan
Emit its current value which starts at zero and then applies the current and next value to the given function emitting the next current value.
Note that this means that scan emits one element downstream before and upstream elements will not be requested until the second element is required from downstream.
emits when the function scanning the element returns a new element
backpressures when downstream backpressures
completes when upstream completes
fold
Start with current value zero and then apply the current and next value to the given function, when upstream complete the current value is emitted downstream.
emits when upstream completes
backpressures when downstream backpressures
completes when upstream completes
reduce
Start with first element and then apply the current and next value to the given function, when upstream complete the current value is emitted downstream. Similar to fold.
emits when upstream completes
backpressures when downstream backpressures
completes when upstream completes
drop
Drop n elements and then pass any subsequent element downstream.
emits when the specified number of elements has been dropped already
backpressures when the specified number of elements has been dropped and downstream backpressures
completes when upstream completes
take
Pass n incoming elements downstream and then complete
emits while the specified number of elements to take has not yet been reached
backpressures when downstream backpressures
completes when the defined number of elements has been taken or upstream completes
takeWhile
Pass elements downstream as long as a predicate function return true for the element include the element when the predicate first return false and then complete.
emits while the predicate is true and until the first false result
backpressures when downstream backpressures
completes when predicate returned false or upstream completes
dropWhile
Drop elements as long as a predicate function return true for the element
emits when the predicate returned false and for all following stream elements
backpressures predicate returned false and downstream backpressures
completes when upstream completes
recover
Allow sending of one last element downstream when a failure has happened upstream.
emits when the element is available from the upstream or upstream is failed and pf returns an element
backpressures when downstream backpressures, not when failure happened
completes when upstream completes or upstream failed with exception pf can handle
recoverWith
Allow switching to alternative Source when a failure has happened upstream.
emits the element is available from the upstream or upstream is failed and pf returns alternative Source
backpressures downstream backpressures, after failure happened it backprssures to alternative Source
completes upstream completes or upstream failed with exception pf can handle
detach
Detach upstream demand from downstream demand without detaching the stream rates.
emits when the upstream stage has emitted and there is demand
backpressures when downstream backpressures
completes when upstream completes
throttle
Limit the throughput to a specific number of elements per time unit, or a specific total cost per time unit, where a function has to be provided to calculate the individual cost of each element.
emits when upstream emits an element and configured time per each element elapsed
backpressures when downstream backpressures
completes when upstream completes
intersperse
Intersperse stream with provided element similar to List.mkString. It can inject start and end marker elements to stream.
emits when upstream emits an element or before with the start element if provided
backpressures when downstream backpressures
completes when upstream completes
limit
Limit number of element from upstream to given max number.
emits when upstream emits and the number of emitted elements has not reached max
backpressures when downstream backpressures
completes when upstream completes and the number of emitted elements has not reached max
limitWeighted
Ensure stream boundedness by evaluating the cost of incoming elements using a cost function. Evaluated cost of each element defines how many elements will be allowed to travel downstream.
emits when upstream emits and the number of emitted elements has not reached max
backpressures when downstream backpressures
completes when upstream completes and the number of emitted elements has not reached max
log
Log elements flowing through the stream as well as completion and erroring. By default element and completion signals are logged on debug level, and errors are logged on Error level. This can be changed by calling Attributes.logLevels(...) on the given Flow.
emits when upstream emits
backpressures when downstream backpressures
completes when upstream completes
recoverWithRetries
Switch to alternative Source on flow failure. It stays in effect after a failure has been recovered up to attempts number of times. Each time a failure is fed into the partial function and a new Source may be materialized.
emits when element is available from the upstream or upstream is failed and element is available from alternative Source
backpressures when downstream backpressures
completes when upstream completes or upstream failed with exception provided partial function can handle
Asynchronous processing stages
These stages encapsulate an asynchronous computation, properly handling backpressure while taking care of the asynchronous operation at the same time (usually handling the completion of a Future).
mapAsync
Pass incoming elements to a function that return a Future result. When the future arrives the result is passed downstream. Up to n elements can be processed concurrently, but regardless of their completion time the incoming order will be kept when results complete. For use cases where order does not mather mapAsyncUnordered can be used.
If a Future fails, the stream also fails (unless a different supervision strategy is applied)
emits when the Future returned by the provided function finishes for the next element in sequence
backpressures when the number of futures reaches the configured parallelism and the downstream backpressures
completes when upstream completes and all futures has been completed and all elements has been emitted
mapAsyncUnordered
Like mapAsync but Future results are passed downstream as they arrive regardless of the order of the elements that triggered them.
If a Future fails, the stream also fails (unless a different supervision strategy is applied)
emits any of the Futures returned by the provided function complete
backpressures when the number of futures reaches the configured parallelism and the downstream backpressures
completes upstream completes and all futures has been completed and all elements has been emitted
Timer driven stages
These stages process elements using timers, delaying, dropping or grouping elements for certain time durations.
takeWithin
Pass elements downstream within a timeout and then complete.
emits when an upstream element arrives
backpressures downstream backpressures
completes upstream completes or timer fires
dropWithin
Drop elements until a timeout has fired
emits after the timer fired and a new upstream element arrives
backpressures when downstream backpressures
completes upstream completes
groupedWithin
Chunk up the stream into groups of elements received within a time window, or limited by the given number of elements, whichever happens first.
emits when the configured time elapses since the last group has been emitted
backpressures when the group has been assembled (the duration elapsed) and downstream backpressures
completes when upstream completes
initialDelay
Delay the initial element by a user specified duration from stream materialization.
emits upstream emits an element if the initial delay already elapsed
backpressures downstream backpressures or initial delay not yet elapsed
completes when upstream completes
delay
Delay every element passed through with a specific duration.
emits there is a pending element in the buffer and configured time for this element elapsed
backpressures differs, depends on OverflowStrategy set
completes when upstream completes and buffered elements has been drained
Backpressure aware stages
These stages are aware of the backpressure provided by their downstreams and able to adapt their behavior to that signal.
conflate
Allow for a slower downstream by passing incoming elements and a summary into an aggregate function as long as there is backpressure. The summary value must be of the same type as the incoming elements, for example the sum or average of incoming numbers, if aggregation should lead to a different type conflateWithSeed can be used:
emits when downstream stops backpressuring and there is a conflated element available
backpressures when the aggregate function cannot keep up with incoming elements
completes when upstream completes
conflateWithSeed
Allow for a slower downstream by passing incoming elements and a summary into an aggregate function as long as there is backpressure. When backpressure starts or there is no backpressure element is passed into a seed function to transform it to the summary type.
emits when downstream stops backpressuring and there is a conflated element available
backpressures when the aggregate or seed functions cannot keep up with incoming elements
completes when upstream completes
batch
Allow for a slower downstream by passing incoming elements and a summary into an aggregate function as long as there is backpressure and a maximum number of batched elements is not yet reached. When the maximum number is reached and downstream still backpressures batch will also backpressure.
When backpressure starts or there is no backpressure element is passed into a seed function to transform it to the summary type.
Will eagerly pull elements, this behavior may result in a single pending (i.e. buffered) element which cannot be aggregated to the batched value.
emits when downstream stops backpressuring and there is a batched element available
backpressures when batched elements reached the max limit of allowed batched elements & downstream backpressures
completes when upstream completes and a "possibly pending" element was drained
batchWeighted
Allow for a slower downstream by passing incoming elements and a summary into an aggregate function as long as there is backpressure and a maximum weight batched elements is not yet reached. The weight of each element is determined by applying costFn. When the maximum total weight is reached and downstream still backpressures batch will also backpressure.
Will eagerly pull elements, this behavior may result in a single pending (i.e. buffered) element which cannot be aggregated to the batched value.
emits downstream stops backpressuring and there is a batched element available
backpressures batched elements reached the max weight limit of allowed batched elements & downstream backpressures
completes upstream completes and a "possibly pending" element was drained
expand
Allow for a faster downstream by expanding the last incoming element to an Iterator. For example Iterator.continually(element) to keep repating the last incoming element.
emits when downstream stops backpressuring
backpressures when downstream backpressures
completes when upstream completes
buffer (Backpressure)
Allow for a temporarily faster upstream events by buffering size elements. When the buffer is full backpressure is applied.
emits when downstream stops backpressuring and there is a pending element in the buffer
backpressures when buffer is full
completes when upstream completes and buffered elements has been drained
buffer (Drop)
Allow for a temporarily faster upstream events by buffering size elements. When the buffer is full elements are dropped according to the specified OverflowStrategy:
- dropHead drops the oldest element in the buffer to make space for the new element
- dropTail drops the youngest element in the buffer to make space for the new element
- dropBuffer drops the entire buffer and buffers the new element
- dropNew drops the new element
emits when downstream stops backpressuring and there is a pending element in the buffer
backpressures never (when dropping cannot keep up with incoming elements)
completes upstream completes and buffered elements has been drained
buffer (Fail)
Allow for a temporarily faster upstream events by buffering size elements. When the buffer is full the stage fails the flow with a BufferOverflowException.
emits when downstream stops backpressuring and there is a pending element in the buffer
backpressures never, fails the stream instead of backpressuring when buffer is full
completes when upstream completes and buffered elements has been drained
Nesting and flattening stages
These stages either take a stream and turn it into a stream of streams (nesting) or they take a stream that contains nested streams and turn them into a stream of elements instead (flattening).
prefixAndTail
Take up to n elements from the stream (less than n only if the upstream completes before emitting n elements) and returns a pair containing a strict sequence of the taken element and a stream representing the remaining elements.
emits when the configured number of prefix elements are available. Emits this prefix, and the rest as a substream
backpressures when downstream backpressures or substream backpressures
completes when prefix elements has been consumed and substream has been consumed
groupBy
Demultiplex the incoming stream into separate output streams.
emits an element for which the grouping function returns a group that has not yet been created. Emits the new group there is an element pending for a group whose substream backpressures
completes when upstream completes (Until the end of stream it is not possible to know whether new substreams will be needed or not)
splitWhen
Split off elements into a new substream whenever a predicate function return true.
emits an element for which the provided predicate is true, opening and emitting a new substream for subsequent elements
backpressures when there is an element pending for the next substream, but the previous is not fully consumed yet, or the substream backpressures
completes when upstream completes (Until the end of stream it is not possible to know whether new substreams will be needed or not)
splitAfter
End the current substream whenever a predicate returns true, starting a new substream for the next element.
emits when an element passes through. When the provided predicate is true it emits the element * and opens a new substream for subsequent element
backpressures when there is an element pending for the next substream, but the previous is not fully consumed yet, or the substream backpressures
completes when upstream completes (Until the end of stream it is not possible to know whether new substreams will be needed or not)
flatMapConcat
Transform each input element into a Source whose elements are then flattened into the output stream through concatenation. This means each source is fully consumed before consumption of the next source starts.
emits when the current consumed substream has an element available
backpressures when downstream backpressures
completes when upstream completes and all consumed substreams complete
flatMapMerge
Transform each input element into a Source whose elements are then flattened into the output stream through merging. The maximum number of merged sources has to be specified.
emits when one of the currently consumed substreams has an element available
backpressures when downstream backpressures
completes when upstream completes and all consumed substreams complete
Time aware stages
Those stages operate taking time into consideration.
initialTimeout
If the first element has not passed through this stage before the provided timeout, the stream is failed with a TimeoutException.
emits when upstream emits an element
backpressures when downstream backpressures
completes when upstream completes or fails if timeout elapses before first element arrives
cancels when downstream cancels
completionTimeout
If the completion of the stream does not happen until the provided timeout, the stream is failed with a TimeoutException.
emits when upstream emits an element
backpressures when downstream backpressures
completes when upstream completes or fails if timeout elapses before upstream completes
cancels when downstream cancels
idleTimeout
If the time between two processed elements exceeds the provided timeout, the stream is failed with a TimeoutException. The timeout is checked periodically, so the resolution of the check is one period (equals to timeout value).
emits when upstream emits an element
backpressures when downstream backpressures
completes when upstream completes or fails if timeout elapses between two emitted elements
cancels when downstream cancels
backpressureTimeout
If the time between the emission of an element and the following downstream demand exceeds the provided timeout, the stream is failed with a TimeoutException. The timeout is checked periodically, so the resolution of the check is one period (equals to timeout value).
emits when upstream emits an element
backpressures when downstream backpressures
completes when upstream completes or fails if timeout elapses between element emission and downstream demand.
cancels when downstream cancels
keepAlive
Injects additional (configured) elements if upstream does not emit for a configured amount of time.
emits when upstream emits an element or if the upstream was idle for the configured period
backpressures when downstream backpressures
completes when upstream completes
cancels when downstream cancels
initialDelay
Delays the initial element by the specified duration.
emits when upstream emits an element if the initial delay is already elapsed
backpressures when downstream backpressures or initial delay is not yet elapsed
completes when upstream completes
cancels when downstream cancels
Fan-in stages
These stages take multiple streams as their input and provide a single output combining the elements from all of the inputs in different ways.
merge
Merge multiple sources. Picks elements randomly if all sources has elements ready.
emits when one of the inputs has an element available
backpressures when downstream backpressures
completes when all upstreams complete (This behavior is changeable to completing when any upstream completes by setting eagerComplete=true.)
mergeSorted
Merge multiple sources. Waits for one element to be ready from each input stream and emits the smallest element.
emits when all of the inputs have an element available
backpressures when downstream backpressures
completes when all upstreams complete
mergePreferred
Merge multiple sources. Prefer one source if all sources has elements ready.
emits when one of the inputs has an element available, preferring a defined input if multiple have elements available
backpressures when downstream backpressures
completes when all upstreams complete (This behavior is changeable to completing when any upstream completes by setting eagerComplete=true.)
zip
Combines elements from each of multiple sources into tuples and passes the tuples downstream.
emits when all of the inputs have an element available
backpressures when downstream backpressures
completes when any upstream completes
zipWith
Combines elements from multiple sources through a combine function and passes the returned value downstream.
emits when all of the inputs have an element available
backpressures when downstream backpressures
completes when any upstream completes
zipWithIndex
Zips elements of current flow with its indices.
emits upstream emits an element and is paired with their index
backpressures when downstream backpressures
completes when upstream completes
concat
After completion of the original upstream the elements of the given source will be emitted.
emits when the current stream has an element available; if the current input completes, it tries the next one
backpressures when downstream backpressures
completes when all upstreams complete
++
Just a shorthand for concat
emits when the current stream has an element available; if the current input completes, it tries the next one
backpressures when downstream backpressures
completes when all upstreams complete
prepend
Prepends the given source to the flow, consuming it until completion before the original source is consumed.
If materialized values needs to be collected prependMat is available.
emits when the given stream has an element available; if the given input completes, it tries the current one
backpressures when downstream backpressures
completes when all upstreams complete
orElse
If the primary source completes without emitting any elements, the elements from the secondary source are emitted. If the primary source emits any elements the secondary source is cancelled.
Note that both sources are materialized directly and the secondary source is backpressured until it becomes the source of elements or is cancelled.
Signal errors downstream, regardless which of the two sources emitted the error.
emits when an element is available from first stream or first stream closed without emitting any elements and an element is available from the second stream
backpressures when downstream backpressures
completes the primary stream completes after emitting at least one element, when the primary stream completes without emitting and the secondary stream already has completed or when the secondary stream completes
interleave
Emits a specifiable number of elements from the original source, then from the provided source and repeats. If one source completes the rest of the other stream will be emitted.
emits when element is available from the currently consumed upstream
backpressures when upstream backpressures
completes when both upstreams have completed
Fan-out stages
These have one input and multiple outputs. They might route the elements between different outputs, or emit elements on multiple outputs at the same time.
unzip
Takes a stream of two element tuples and unzips the two elements ino two different downstreams.
emits when all of the outputs stops backpressuring and there is an input element available
backpressures when any of the outputs backpressures
completes when upstream completes
unzipWith
Splits each element of input into multiple downstreams using a function
emits when all of the outputs stops backpressuring and there is an input element available
backpressures when any of the outputs backpressures
completes when upstream completes
broadcast
Emit each incoming element each of n outputs.
emits when all of the outputs stops backpressuring and there is an input element available
backpressures when any of the outputs backpressures
completes when upstream completes
balance
Fan-out the stream to several streams. Each upstream element is emitted to the first available downstream consumer.
emits when any of the outputs stops backpressuring; emits the element to the first available output
backpressures when all of the outputs backpressure
completes when upstream completes
partition
Fan-out the stream to several streams. Each upstream element is emitted to one downstream consumer according to the partitioner function applied to the element.
emits when the chosen output stops backpressuring and there is an input element available
backpressures when the chosen output backpressures
completes when upstream completes and no output is pending
Watching status stages
watchTermination
Materializes to a Future that will be completed with Done or failed depending whether the upstream of the stage has been completed or failed. The stage otherwise passes through elements unchanged.
emits when input has an element available
backpressures when output backpressures
completes when upstream completes
monitor
Materializes to a FlowMonitor that monitors messages flowing through or completion of the stage. The stage otherwise passes through elements unchanged. Note that the FlowMonitor inserts a memory barrier every time it processes an event, and may therefore affect performance.
emits when upstream emits an element
backpressures when downstream backpressures
completes when upstream completes
Contents


Simple Tooltips
Orientation
North
West
North
Pole
North
East
West
North
East
North
Wild
West
Middle
East
West
South
East
South
South
West
South
(Default)
South
East
Content
Pre-Wrapped Content


Schools are still not doing enough to ensure the most able children fulfil their potential, an Ofsted survey has found.
The
most able students report
, published today (4 March 2015), finds that many of the most able children who attend non-selective secondary schools are failing to achieve their potential, compared with students who attend selective and independent schools. The report follows up on an
earlier survey carried out in 2013
– and concludes that very few improvements have been made over the intervening 2 years.
In the most successful non-selective schools, the most able students thrive because school leaders provide a challenging curriculum and are tenacious in making sure that teaching is consistently good or better for all students. Successful leaders use the information they receive from primary schools to make sure that students are doing work that stretches them as soon as they join year 7. This continues throughout the students’ time at the school and culminates in their successful applications to the best universities, training providers and employers.
Launching the report today, Sean Harford, Ofsted’s National Director of Schools, said:
Schools exist to help all young people fulfil their potential. They must identify and nurture the talents of their students, so they can go on to achieve the best that they can. To do this, schools must ensure that the education they provide challenges and encourages children at all levels.
This report has focused particularly on those identified as the most able. While inspectors found pockets of excellence, too many of these children are not being challenged sufficiently – and thousands of highly performing primary pupils are not realising their early promise when they move to secondary school.
For our part, Ofsted will make sure that inspections keep focusing sharply on the progress made by the most able students, particularly those from poorer backgrounds. Inspectors will also report more sharply about how well schools promote the needs of the most able through the quality of the curriculum and the information, advice and guidance they offer to their most able students.
It is especially disappointing to find that, almost 2 years on from our first report, the same problems remain. I hope school leaders see this report as a call to action – and raise the bar higher for their most able pupils, so that they can reach their full potential.
Ofsted inspectors visited 40 secondary and 10 primary, non-selective schools to assess the teaching, curriculum and guidance they provide for their most able students. In a further 130 routine inspections, schools were asked how they supported these students. The report also draws upon the evidence from interviews with university admissions tutors and over 600 online responses from secondary school students.
Inspectors found that the needs of many of the most able students – defined as those who achieved the highest national curriculum level at the end of key stage 2 – were not being prioritised by schools. Too many were receiving teaching within a curriculum that did not sufficiently challenge them and around a quarter of those who showed very strong potential in English and maths at age 11 did not go on to achieve a B grade at GCSE.
Inspectors also saw complacency in many of the schools they visited; aspirations of what students could achieve were simply not high enough. Moreover, the report concludes that:
-
the most able students’ achievement suffers even more when they are from poorer backgrounds
-
the most able girls continue to outperform the most able boys significantly, and where there is a reasonable proportion of most able students, they do far better than when they are in a small minority in a school
-
many secondary schools are still not giving demanding work to the most able students in their opening years in secondary schools
-
information, advice and guidance to students about accessing the most appropriate courses at universities, or in preparation for demanding apprenticeship and other training opportunities are not good enough
-
students’ classes in key stage 3 are often affected by low-level disruption
-
school leaders are not properly evaluating how to help prepare the most able for universities
As a matter of urgency, Ofsted recommends that school leaders must:
-
develop a culture of high expectations for students and teachers in secondary school
-
make sure that teachers use information provided by primary schools about the most able students to help manage their transition to secondary school
-
appoint staff and governors with responsibilities specifically to champion the needs of the most able students from poorer backgrounds
-
involve universities in training school staff to provide advice to the most able
-
provide training for all teachers so that their teaching challenges the most able students
Notes to editors
-
The most able students – an update on progress since June 2013
is on GOV.UK.
-
The Office for Standards in Education, Children’s Services and Skills (Ofsted) regulates and inspects to achieve excellence in the care of children and young people, and in education and skills for learners of all ages. It regulates and inspects childcare and children’s social care, and inspects the Children and Family Court Advisory and Support Service (Cafcass), schools, colleges, initial teacher training, work-based learning and skills training, adult and community learning, and education and training in prisons and other secure establishments. It assesses council children’s services, and inspects services for looked after children, safeguarding and child protection.


{{username}} - {{nickname}}
Welcome to our dashboard application. This application guild will introduce you to things that you can d while staying here. All the sections mentioned below can be accessed from the navigation menu on the left side.
Work Section
This section contains the demonstration for all the final products that has been produced in the market
Producer Section
This section contains information about the creator of all the works and how to get in touch with them
Contact Section
This section provides a gateway for users to voice out opinions regarding the application and any other questions or concerns that one might have


Notifies application that user has depressed or released a button to which the application has subscribed.
Further information about button events and button-presses can be found at SDLSubscribeButton.
HMI Status Requirements:
HMILevel:
The application will receive SDLOnButtonEvent notifications for all subscribed buttons when HMILevel is FULL.
The application will receive SDLOnButtonEvent notifications for subscribed media buttons when HMILevel is LIMITED.
Media buttons include SEEKLEFT, SEEKRIGHT, TUNEUP, TUNEDOWN, and PRESET_0-PRESET_9.
The application will not receive SDLOnButtonEvent notification when HMILevel is BACKGROUND.
AudioStreamingState:
SystemContext:
MAIN, VR. In MENU, only PRESET buttons.
In VR, pressing any subscribable button will cancel VR.
See
SDLSubscribeButton
@since SDL 1.0
The name of the button
@property (nonatomic, strong) SDLButtonName _Nonnull buttonName;
var buttonName: SDLButtonName { get set }
Indicates whether this is an UP or DOWN event
@property (nonatomic, strong) SDLButtonEventMode _Nonnull buttonEventMode;
var buttonEventMode: SDLButtonEventMode { get set }
If ButtonName is “CUSTOM_BUTTON”, this references the integer ID passed by a custom button. (e.g. softButton ID)
@since SDL 2.0
Optional, Integer, 0 - 65536
@property (nonatomic, strong, nullable) NSNumber<SDLInt> *customButtonID;
var customButtonID: (NSNumber & SDLInt)? { get set }


{{.Icon}} {{.Id}}
View this as raw text.
View this as wrapped text.
{{.Body|printf "%s"|html}}
Make a new paste.
Make a paste based on this one.


[§481A-1] Title. This chapter may be cited as the Uniform Deceptive Trade Practice Act. [L 1969, c 187, pt of §1]


Roots to Leaves
Roots to Leaves
Email address
We'll never share your email with anyone else.
Password
Sign In
Sign Up