|
|
In this part of the article we will focus on estimating the time complexity for recursive programs. In essence, this will lead to finding the order of growth for solutions of recurrence equations. Don't worry if you don't understand what exactly is a recurrence solution, we will explain it in the right place at the right time. But first we will consider a simpler case - programs without recursion. First of all let's consider simple programs that contain no function calls. The rule of thumb to find an upper bound on the time complexity of such a program is:
Example 1. Estimating the time complexity of a random piece of code.
int result=0; // 1 for (int i=0; i<N; i++) // 2 for (int j=i; j<N; j++) { // 3 for (int k=0; k<M; k++) { // 4 int x=0; // 5 while (x<N) { result++; x+=3; } // 6 } // 7 for (int k=0; k<2*M; k++) // 8 if (k%7 == 4) result++; // 9 } // 10The time complexity of the while-cycle in line 6 is clearly O(N) - it is executed no more than N/3 + 1 times. Now consider the for-cycle in lines 4-7. The variable k is clearly incremented O(M) times. Each time the whole while-cycle in line 6 is executed. Thus the total time complexity of the lines 4-7 can be bounded by O(MN). The time complexity of the for-cycle in lines 8-9 is O(M). Thus the execution time of lines 4-9 is O(MN + M) = O(MN). This inner part is executed O(N2) times - once for each possible combination of i and j. (Note that there are only N(N + 1)/2 possible values for [i, j]. Still, O(N2) is a correct upper bound.) From the facts above follows that the total time complexity of the algorithm in Example 1 is O(N2.MN) = O(MN3). From now on we will assume that the reader is able to estimate the time complexity of simple parts of code using the method demonstrated above. We will now consider programs using recursion (i.e. a function occasionally calling itself with different parameters) and try to analyze the impact of these recursive calls on their time complexity. Using recursion to generate combinatorial objects One common use of recursion is to implement a backtracking algorithm to generate all possible solutions of a problem. The general idea is to generate the solution incrementally and to step back and try another way once all solutions for the current branch have been exhausted. This approach is not absolutely universal, there may be problems where it is impossible to generate the solution incrementally. However, very often the set of all possible solutions of a problem corresponds to the set of all combinatorial objects of some kind. Most often it is the set of all permutations (of a given size), but other objects (combinations, partitions, etc.) can be seen from time to time. As a side note, it is always possible to generate all strings of zeroes and ones, check each of them (i.e. check whether it corresponds to a valid solution) and keep the best found so far. If we can find an upper bound on the size of the best solution, this approach is finite. However, this approach is everything but fast. Don't use it if there is any other way. Example 2. A trivial algorithm to generate all permutations of numbers 0 to N - 1.
vector<int> permutation(N); vector<int> used(N,0); void try(int which, int what) { // try taking the number "what" as the "which"-th element permutation[which] = what; used[what] = 1; if (which == N-1) outputPermutation(); else // try all possibilities for the next element for (int next=0; next<N; next++) if (!used[next]) try(which+1, next); used[what] = 0; } int main() { // try all possibilities for the first element for (int first=0; first<N; first++) try(0,first); } In this case a trivial lower bound on the time complexity is the number of possible solutions. Backtracking algorithms are usually used to solve hard problems - i.e. such that we don't know whether a significantly more efficient solution exists. Usually the solution space is quite large and uniform and the algorithm can be implemented so that its time complexity is close to the theoretical lower bound. To get an upper bound it should be enough to check how much additional (i.e. unnecessary) work the algorithm does. The number of possible solutions, and thus the time complexity of such algorithms, is usually exponential - or worse. Divide&conquer using recursion From the previous example we could get the feeling that recursion is evil and leads to horribly slow programs. The contrary is true. Recursion can be a very powerful tool in the design of effective algorithms. The usual way to create an effective recursive algorithm is to apply the divide&conquer paradigm - try to split the problem into several parts, solve each part separately and in the end combine the results to obtain the result for the original problem. Needless to say, the "solve each part separately" is usually implemented using recursion - and thus applying the same method again and again, until the problem is sufficiently small to be solved by brute force. Example 3. The sorting algorithm MergeSort described in pseudocode.
MergeSort(sequence S) { if (size of S <= 1) return S; split S into S_1 and S_2 of roughly the same size; MergeSort(S_1); MergeSort(S_2); combine sorted S_1 and sorted S_2 to obtain sorted S; return sorted S; } Clearly O(N) time is enough to split a sequence with N elements into two parts. (Depending on the implementation this may be even possible in constant time.) Combining the shorter sorted sequences can be done in (N): Start with an empty S. At each moment the smallest element not yet in S is either at the beginning of S1 or at the beginning of S2. Move this element to the end of S and continue. Thus the total time to MergeSort a sequence with N elements is (N) plus the time needed to make the two recursive calls. Let f (N) be the time complexity of MergeSort as defined in the previous part of our article. The discussion above leads us to the following equation:
where p is a linear function representing the amount of work spent on splitting the sequence and merging the results. Basically, this is just a recurrence equation. If you don't know this term, please don't be afraid. The word "recurrence" stems from the latin phrase for "to run back". Thus the name just says that the next values of f are defined using the previous (i.e. smaller) values of f. Well, to be really formal, for the equation to be complete we should specify some initial values - in this case, f (1). This (and knowing the implementation-specific function p) would enable us to compute the exact values of f. But as you hopefully understand by now, this is not necessarily our goal. While it is theoretically possible to compute a closed-form formula for f (N), this formula would most probably be really ugly... and we don't really need it. We only want to find a -bound (and sometimes only an O-bound) on the growth of f. Luckily, this can often be done quite easily, if you know some tricks of the trade. As a consequence, we won't be interested in the exact form of p, all we need to know is that p(N) = (N). Also, we don't need to specify the initial values for the equation. We simply assume that all problem instances with small N can be solved in constant time. The rationale behind the last simplification: While changing the initial values does change the solution to the recurrence equation, it usually doesn't change its asymptotic order of growth. (If your intuition fails you here, try playing with the equation above. For example fix p and try to compute f (8), f (16) and f (32) for different values of f (1).) If this would be a formal textbook, at this point we would probably have to develop some theory that would allow us to deal with the floor and ceiling functions in our equations. Instead we will simply neglect them from now on. (E.g. we can assume that each division will be integer division, rounded down.) A reader skilled in math is encouraged to prove that if p is a polynomial (with non-negative values on N) and q(n) = p(n + 1) then q(n) = (p(n)). Using this observation we may formally prove that (assuming the f we seek is polynomially-bounded) the right side of each such equation remains asymptotically the same if we replace each ceiling function by a floor function. The observations we made allow us to rewrite our example equation in a more simple way: Note that this is not an equation in the classical sense. As in the examples in the first part of this article, the equals sign now reads "is asymptotically equal to". Usually there are lots of different functions that satisfy such an equation. But usually all of them will have the same order of growth - and this is exactly what we want to determine. Or, more generally, we want to find the smallest upper bound on the growth of all possible functions that satisfy the given equation. In the last sections of this article we will discuss various methods of solving these "equations". But before we can do that, we need to know a bit more about logarithms. By now, you may have already asked one of the following questions: If the author writes that some complexity is e.g. O(N log N), what is the base of the logarithm? In some cases, wouldn't O(N log2N) be a better bound? The answer: The base of the logarithm does not matter, all logarithmic functions (with base > 1) are asymptotically equal. This is due to the well-known equation: Note that given two bases a, b, the number 1/logba is just a constant, and thus the function logaN is just a constant multiple of logbN. To obtain more clean and readable expressions, we always use the notation log N inside big-Oh expressions, even if logarithms with a different base were used in the computation of the bound. By the way, sadly the meaning of log N differs from country to country. To avoid ambiguity where it may occur: I use log N to denote the decadic (i.e. base-10) logarithm, ln N for the natural (i.e. base-e) logarithm, lg N for the binary logarithm and logbN for the general case.
Now we will show some useful tricks involving logarithms, we will need them later. Suppose a, b are given constants such that a, b > 1. From (2) we get:
Using this knowledge, we can simplify the term as follows: This method can be summarized in one sentence: Guess an asymptotic upper bound on f and (try to) prove it by induction. As an example, we will prove that if f satisfies the equation (1) then f (N) = O(N log N). From (1) we know that
for some c. Now we will prove that if we take a large enough (but constant) d then for almost all N we have f (N) dN lg N. We will start by proving the induction step. Assume that f (N/2) d (N/2)lg(N/2). Then
In other words, the induction step will hold as long as d > c. We are always able to choose such d. We are only left with proving the inequality for some initial value N.  The general idea is that if the d we found so far is not large enough, we can always increase it to cover the initial cases. Note that for our example equation we won't be able to prove it for N = 1, because lg 1 = 0. However, by taking d > 2(f (1) + f (2) + f (3) + c) we can easily prove the inequality for N = 2 and N = 3, which is more than enough. Please note what exactly did we prove. Our result is that if f satisfies the equation (1) then for almost all N we have f (N) dN lg N, where d is some fixed constant. Conclusion: from (1) it follows that f (N) = O(N lg N). To a beginner, the previous method won't be very useful. To use it successfully we need to make a good guess - and to make a good guess we need some insight. The question is, how to gain this insight? Let's take a closer look at what's happening, when we try to evaluate the recurrence (or equivalently, when we run the corresponding recursive program). We may describe the execution of a recursive program on a given input by a rooted tree. Each node will correspond to some instance of the problem the program solves. Consider an arbitrary vertex in our tree. If solving its instance requires recursive calls, this vertex will have children corresponding to the smaller subproblems we solve recursively. The root node of the tree is the input of the program, leaves represent small problems that are solved by brute force. Now suppose we label each vertex by the amount of work spent solving the corresponding problem (excluding the recursive calls). Clearly the runtime is exactly the sum of all labels. As always, we only want an asymptotic bound. To achieve this, we may "round" the labels to make the summation easier. Again, we will demonstrate this method on examples. Example 4. The recursion tree for MergeSort on 5 elements.
The recursion tree for the corresponding recurrence equation. This time, the number inside each vertex represents the number of steps the algorithm makes there.
Note that in a similar way we may sketch the general form of the recursion tree for any recurrence. Consider our old friend, the equation (1). Here we know that there is a number c such that the number of operations in each node can be bound by (c times the current value of N). Thus the tree in the example below is indeed the worst possible case. Example 5. A worst-case tree for the general case of the recurrence equation (1).
Now, the classical trick from combinatorics is to sum the elements in an order different from the order in which they were created. In this case, consider an arbitrary level of the tree (i.e. a set of vertices with the same depth). It is not hard to see that the total work on each of the levels is cN. Now comes the second question: What is the number of levels? Clearly, the leaves correspond to the trivial cases of the algorithm. Note that the size of the problem is halved in each step. Clearly after lg N steps we are left with a trivial problem of size 1, thus the number of levels is (log N). Combining both observations we get the final result: The total amount of work done here is (cN x log N) = (N log N). A side note. If the reader doesn't trust the simplifications we made when using this method, he is invited to treat this method as a "way of making a good guess" and then to prove the result using the substitution method. However, with a little effort the application of this method could also be upgraded to a full formal proof. By now you should be asking: Was it really only a coincidence that the total amount of work on each of the levels in Example 5 was the same? The answer: No and yes. No, there's a simple reason why this happened, we'll discover it later. Yes, because this is not always the case - as we'll see in the following two examples. Example 6. Let's try to apply our new "recursion tree" method to solve the following recurrence equation:
The recursion tree will look as follows:
Let's try computing the total work for each of the first few levels. Our results:
Clearly as we go deeper in the tree, the total amount of work on the current level decreases. The question is, how fast does it decrease? As we move one level lower, there will be three times that many subproblems. However, their size gets divided by 2, and thus the time to process each of them decreases to one eighth of the original time. Thus the amount of work is decreased by the factor 3/8. But this means that the entries in the table above form a geometric progression. For a while assume that this progression is infinite. Then its sum would be
Thus the total amount of work in our tree is (N3) (summing the infinite sequence gives us an upper bound). But already the first element of our progression is (N3). It follows that the total amount of work in our tree is (N3) and we are done. The important generalization of this example: If the amounts of work at subsequent levels of the recursion tree form a decreasing geometric progression, the total amount of work is asymptotically the same as the amount of work done in the root node. From this result we can deduce an interesting fact about the (hypothetical) algorithm behind this recurrence equation: The recursive calls didn't take much time in this case, the most time consuming part was preparing the recursive calls and/or processing the results. (I.e. this is the part that should be improved if we need a faster algorithm.) Example 7. Now let's try to apply our new "recursion tree" method to solve the following recurrence equation:
The recursion tree will look as follows:
Again, let's try computing the total work for each of the first few levels. We get:
This time we have the opposite situation: As we go deeper in the tree, the total amount of work on the current level increases. As we move one level lower, there will be five times that many subproblems, each of them one third of the previous size, the processing time is linear in problem size. Thus the amount of work increased by the factor 5/3. Again, we want to compute the total amount of work. This time it won't be that easy, because the most work is done on the lowest level of the tree. We need to know its depth. The lowest level corresponds to problems of size 1. The size of a problem on level k is N/3k. Solving the equation 1 = N/3k we get k = log3N. Note that this time we explicitly state the base of the logarithm, as this time it will be important. Our recursion tree has log3N levels. Each of the levels has five times more vertices than the previous one, thus the last level has levels. The total work done on this level is then . Note that using the trick (3) we may rewrite this as . Now we want to sum the work done on all levels of the tree. Again, this is a geometric progression. But instead of explicitly computing the sum, we now reverse it. Now we have a decreasing geometric progression...and we are already in the same situation as in the previous example. Using the same reasoning we can show that the sum is asymptotically equal to the largest element. It follows that the total amount of work in our tree is and we are done. Note that the base-3 logarithm ends in the exponent, that's why the base is important. If the base was different, also the result would be asymptotically different. We already started to see a pattern here. Given a recurrence equation, take the corresponding recurrence tree and compute the amounts of work done on each level of the tree. You will get a geometric sequence. If it decreases, the total work is proportional to work done in the root node. If it increases, the total work is proportional to the number of leaves. If it remains the same, the total work is (the work done on one level) times (the number of levels). Actually, there are a few ugly cases, but almost often one of these three cases occurs. Moreover, it is possible to prove the statements from the previous paragraph formally. The formal version of this theorem is known under the name Master Theorem. For reference, we give the full formal statement of this theorem. (Note that knowing the formal proof is not necessary to apply this theorem on a given recurrence equation.) Let a 1 and b > 1 be integer constants. Let p be a non-negative non-decreasing function. Let f be any solution of the recurrence equation
Then:
Case 1 corresponds to our Example 7. Most of the time is spent making the recursive calls and it's the number of these calls that counts. Case 2 corresponds to our Example 5. The time spent making the calls is roughly equal to the time to prepare the calls and process the results. On all levels of the recursion tree we do roughly the same amount of work, the depth of the tree is always logarithmic. Case 3 corresponds to our Example 6. Most of the time is spent on preparing the recursive calls and processing the results. Usually the result will be asymptotically equal to the time spent in the root node. Note the word "usually" and the extra condition in Case 3. For this result to hold we need p to be somehow "regular" - in the sense that for each node in the recursion tree the time spent in the node must be greater than the time spent in its chidren (excluding further recursive calls). This is nothing to worry about too much, most probably all functions p you will encounter in practice will satisfy this condition (if they satisfy the first condition of Case 3). Example 8. Let f (N) be the time Strassen's fast matrix multiplication algorithm needs to multiply two N x N square matrices. This is a recursive algorithm, that makes 7 recursive calls, each time multiplying two (N/2) x (N/2) square matrices, and then computes the answer in (N2) time. This leads us to the following recurrence equation:
Using the Master Theorem, we see that Case 1 applies. Thus the time complexity of Strassen's algorithm is . Note that by implementing the definition of matrix multiplication we get only a (N3) algorithm. Example 9. Occasionally we may encounter the situation when the problems in the recursive calls are not of the same size. An example may be the "median-of-five" algorithm to find the k-th element of an array. It can be shown that its time complexity satisfies the recurrence equation
How to solve it? Can the recursion tree be applied also in such asymmetric cases? Is there a more general version of Master Theorem that handles also these cases? And what should I do with the recurrence f (N) = 4f (N/4) + (N log N), where the Master Theorem doesn't apply? We won't answer these questions here. This article doesn't claim to be the one and only reference to computational complexity. If you are already asking these questions, you understand the basics you need for programming contests - and if you are interested in knowing more, there are good books around that can help you. Thanks for reading this far. If you have any questions, comments, bug reports or any other feedback, please use the Round tables. I'll do my best to answer.
|
|
|
Home |
About TopCoder |
Press Room |
Contact Us |
Careers |
Privacy |
Terms
Competitions | Cockpit |
| Copyright TopCoder, Inc. 2001-2011 |


| Home | Services | Contact Us | Service Area | About Us | Reviews |
Carpet Savers is a Beaverton carpet cleaning & repair business that's family owned and operated, serving the entire Portland, OR - Vancouver, WA Metro area. Carpet Savers offers a wide and affordable array of services, including carpet cleaning, carpet restretching, carpet patching and more!


Try out our Premium Member services: Virtual Legal Assistant, Query Alert Service and an ad-free experience. Free for one month and pay only if you like it.
907 wp 303 of 2018.doc IN THE HIGH COURT OF JUDICATURE AT BOMBAY CIVIL APPELLATE JURISDICTION WRIT PETITION NO.303 OF 2018 M/s. Kale Entertainment and Resorts Pvt. Ltd. ... Petitioner Versus Union of India and others ... Respondents ALONGWITH PUBLIC INTEREST LITIGATION NO.87 OF 2013 Vanashakti Public Trust ... Petitioner versus Union of India and others ... Respondents Mr. Subhash Abhyankar with Ms. Anu Karadharan, for Petitioner in WP No.303 of 2018. Mr. Zaman Ali with Ms. Sheetal Alvarez, for Petitioner in PIL 87 of 2013. Mr. N.R.Bubna, for Respondent No.1 in WP No.303 of 2018. Mr. P.P.Kakade, Govt. Pleader, with Ms. M.P.Thakur, AgP, for State in WP No.303 of 2018. Mr. G.W.Mattos, AGP, for Respondent in PIL 87 of 2013. Ms. Swati Sagvekar, for Respondent Nos.3 and 4 in WP No.303 of 2018. Ms. Sharmila Deshmukh, for Respondent No.10 in PIL 87 of 2013. Mr. Milan Bhise with Mr. Amit Bhave, Mr. Vinod Sakpal, Mr. Akshay Kandarkar i/by Mr. Rajesh Datar, for Applicant in NMS 151 of 2017. Mr. Anil Diggikar, Principal Secretary, Environment Dept., present. CORAM: S.J. KATHAWALLA & B.P.COLABAWALLA, JJ.
DATE: 15th JANUARY, 2020 P.C.:
1. In May 2010, under the sponsorship of Central Government - Ministry of Environment, Forests and Climate Change, the Space Application Centre (SAC), SSP 1/10 ::: Uploaded on - 16/01/2020 ::: Downloaded on - 17/01/2020 00:40:27 ::: 907 wp 303 of 2018.doc Ahmedabad & Maharashtra Remote Sensing Application Centre (MRSAC), Nagpur prepared a National Wetland Atlas for Maharashtra for the following reasons :
"Utility-wise, wetlands directly and indirectly support millions of people in providing services such as food, fiber and raw materials. They play important roles in storm and flood control, in supply of clean water, alongwith other educational and recreational benefits. Despite these benefits, wetlands are the first target of human interference and are among the most threatened of all natural resources. Around 50% of the earth's wetlands are estimated to already have disappeared worldwide over the last hundred years through conversion to industrial, agricultural and residential purposes. Even in current scenario, when the ecosystem services provided by wetlands are better understood - degradation and conversion of wetlands continues.
Aware of their importance, the Government of India has formulated several policies and plans for the conservation and preservation of these crucial ecosystems. Realising the need of an updated geospatial data base of these natural resources as the pre-requisite for management and conservation planning, National Wetland Inventory and Assessment (NWIA) project was formulated as a joint vision of Ministry of Environment & Forestry, Govt. of India, and Space Applications Centre (ISRO)." (emphasis supplied)
2. The National Wetlands Atlas for Maharashtra identifies a total of 46,460 Wetlands in the entire State of Maharashtra. A Chart showing district wise break-up of all Wetlands in Maharashtra as per the said Atlas is tendered in Court. The same is SSP 2/10 ::: Uploaded on - 16/01/2020 ::: Downloaded on - 17/01/2020 00:40:27 ::: 907 wp 303 of 2018.doc taken on record and marked 'X' for identification.
3. On 14th October, 2013 this Court in Public Interest Litigation (PIL) No.87 of 2013 passed the following order :
"1. By order dated 16th September, 2013, we had directed the State Government to take a decision whether they propose to adopt the Wetland Atlas prepared by the Central Government and whether they would like to prepare a brief document in respect of Wetland Atlas for the State of Maharashtra as envisaged under Rules 6(2) and 6(3) of the Wetland Rules, 2020. Unfortunately, the said direction does not appear to have been incorporated in our order dated 16 th September, 2013. We therefore, now direct the Secretary, Department of Environment and the Secretary of Forest Department, Government of Maharashtra to take a decision whether they propose to adopt Wetland Atlas, prepared by the Central Government under the said Rules and whether they would like to prepare their own brief document in respect of Wetland Atlas for the State of Maharashtra. If the State of Maharashtra does not propose to adopt the Wetland Atlas prepared by the Central Government, the Secretary, Department of Environment and the Secretary of Forest Department, State of Maharashtra to inform this Court the time frame within which the said brief document shall be prepared for the State of Maharashtra.
2. In the meantime, however, we deem it fit and proper to give a direction in respect of the areas which have been identified as Wetland Areas in the Wetland Atlas by the Central Government that no reclamation of land and any kind of construction shall be permitted without leave of this Court. The Secretary, Urban Development Department, Government of Maharashtra is directed to issue a circular SSP 3/10 ::: Uploaded on - 16/01/2020 ::: Downloaded on - 17/01/2020 00:40:28 ::: 907 wp 303 of 2018.doc informing the direction given by this Court to all the Corporations and the Zilha Parishad. Stand over to 29th October, 2013".
4. On 19th March, 2014 this Court in PIL No.87 of 2013 passed the following order :
"2. Pursuant to the directions given by this court the learned A.G.P. has submitted report in respect of certain areas. Perusal of the report indicates that there is rampant destruction of wetlands and land is reclaimed after systematic destruction of wetlands. We have seen photographs which are tendered by the petitioners which also clearly demonstrate that apart from destruction of wetlands, the land is reclaimed and illegal reclamation is being carried out by certain persons. As of today, no permanent machinery is set up by the State Government for the purpose of stopping destruction of wetlands. We are, therefore, of the opinion that it would be necessary to impose total ban on destruction and reclamation of wetlands which are described in the Atlas prepared by the Central Government. permission should be granted for destruction Hereinafter no and reclamation of wetlands and prompt action including lodging of FIR/complaint be taken. This action should be taken by the Collector, who is authority in respect of entire Revenue District and also by the Regional Officers of State Pollution Control Board, who have been delegated powers under section 20, 21, 23 of the Water (Prevention and Control of Pollution) Act, 1974. The steps should also be taken by these authorities and they should submit report about the steps taken by them in respect of reclamation of wetlands as indicated in the report submitted by Chief Conservator of Forests, Mangrove Cell, Mumbai."
SSP 4/10
::: Uploaded on - 16/01/2020 ::: Downloaded on - 17/01/2020 00:40:28 :::
907 wp 303 of 2018.doc
5. On 16th December, 2019 this Court in Writ Petition No.303 of 2018 passed the following order :
"1. By an order dated 14th October, 2013 passed by this Court in PIL No.87 of 2013, directions were given to the Department of Environment and Secretary to the Forest Department, State of Maharashtra to decide whether they propose to adopt the Wetland Atlas prepared by the Central Government under Rules 6(2) and 6(3) of the Wetland Rules, 2010 or whether they would like to prepare their own document in respect of the Wetland Atlas for the State of Maharashtra.
2. Mr. Sanjay Baliram Sandanshiv, Scientist II Cum Under Secretary, has filed his Affidavit dated 12th December, 2019 setting out as follows : "7. This Department vide GR dated 06.02.2018 has constituted Wetland Authority, under the Chairmanship of Hon'ble Minister of Environment. In view of the directions of the Hon'ble High Court, all District Collectors, are informed to prepare brief documents to submit before the wetland authority. On 27 th August, 2019 State Wetland Authority reviewed the progress of the preparation of brief documents in respect of wetlands in State. Accordingly, all District Collectors are instructed to prepare brief documents within 15 days."
3. The said statements made in the Affidavit are of no assistance to the Court. No particulars are provided as to what exactly is done from 14th October, 2013. No detailed particulars of the steps taken from 6 th February, 2018, i.e. the date of the GR, are provided. This is so because hardly any steps are taken in the matter, which conduct is strongly deprecated. The fact remains that the orders passed by the Court are not complied with by the State Government since a very SSP 5/10 ::: Uploaded on - 16/01/2020 ::: Downloaded on - 17/01/2020 00:40:28 ::: 907 wp 303 of 2018.doc long time. The State Government is directed to prepare the brief document, if so interested, within a period of four weeks from today.
4. Stand over to 13th January, 2020, high on board."
6. On 13th January, 2020 this Court after reproducing the order dated 16 th December, 2018 interalia recorded in brief the contents of the Affidavit of Mr. Sanjay Baliram Sandanshiv, Scientist II Cum Under Secretary, in paragraph 2 of the order which is reproduced hereunder :
"2. Today, an Affidavit is filed by Shri. Sanjay Baliram Sandanshiv, Under Secretary, Environment Department, Government of Maharashtra, wherein he has stated as follows :-
(i) that pursuant to the directions of this Court dated 14 th October, 2013, the Revenue and Forest Department constituted the Maharashtra State Wetland Committee chaired by the Chief Secretary vide GR dated 30 th April, 2014 ;
(ii) that the Environment Department had instructed all District Collectors of 28 districts for preparation of brief documents vide letters dated 17th November 2015, 18th November 2015, 12th April 2016, 22nd July 2016, 11th August 2016, 3rd October 2016, 17th May 2018, 18th January 2019, 2nd May 2019, 17th May 2019 and 18th December 2019;
(iii) that the Environment Department constituted State Wetland Authority, Grievance Committee and Technical Committee vide G.R. dated 6th February, 2018 for scrutinizing the brief documents submitted by the concerned Districts ;
(iv) that on 19th December, 2019, the Environment Department brought to the notice of all Divisional Commissioners and District Collectors of the SSP 6/10 ::: Uploaded on - 16/01/2020 ::: Downloaded on - 17/01/2020 00:40:28 ::: 907 wp 303 of 2018.doc State regarding directions given by this Court dated 16 th December, 2019 and instructed them to submit brief documents of wetland area within 15 days time, failing which they will be solely responsible for the delay ;
(v) that again on 20th December, 2019, the Principal Secretary (Environment) vide D.O. letter instructed all Divisional Commissioners and all District Collectors to prepare brief documents of wetland area within 15 days time, failing which they will be solely responsible for the delay ;
(vi) that on 24th December, 2019 all concerned officers of the Konkan Division District Collector Offices remained present for further guidance and technical assistance for preparation of brief documents ;
(vii) that on 26th December, 2019 all Divisional Commissioners and all District Collectors were reminded for the preparation of brief documents of wetland in the light of this Court order dated 16th December, 2019 ;
(viii) that on 7th January 2020 all Divisional Commissioners and all District Collectors were requested by the Environment Department to send the progress report about the preparation of brief documents of wetland within two days in the light of the order dated 16th December, 2020 ;
(ix) that out of 36 Districts of State of Maharashtra, 2 Districts namely, Sindhudurg and Ratnagiri have completed brief documents and submitted online to Environment Department ;
(x) that in Parbhani and Nagpur, there are no wetlands.
(xi) that so far as Thane and Mumbai Suburban Districts are concerned, the work of wetland is already completed. However, due to some technical issues, the brief documents are not uploaded online.
(xii) that the Raigad and Palghar Districts shall prepare the brief documents within a period of 15 days ;
(xiii) that so far as balance 28 Districts are concerned, the District
SSP 7/10
::: Uploaded on - 16/01/2020 ::: Downloaded on - 17/01/2020 00:40:28 :::
907 wp 303 of 2018.doc
Collectors are already informed to complete the process to prepare brief documents, failing which the concerned officer shall be solely responsible, for the delay."
In the said order, this Court after recording that the Additional Commissioners and Collectors have failed to comply with the orders passed by this Court and also the directions/reminders given pursuant thereto by the Environment Department, including the Principal Secretary (Environment), directed the Principal Secretary (Environment) to appear before the court on 15 th January, 2020 at 11.00 a.m., and inform the Court about the action taken / proposed to be taken against the Divisional Commissioners and District Collectors for not complying with the directions of this Court more so because in the communication addressed by him to the Divisional Commissioners and District Collectors, he had already warned them that if they fail to submit the brief documents within the prescribed time, they will be solely responsible for the delay.
7. Today, Mr. Anil Diggikar, the Principal Secretary (Environment) is present in Court. Mr. Diggikar has placed before the Court an order dated 14 th January, 2020 issued by the Chief Secretary, Govt. of Maharashtra, to all the Collectors and Divisional Commissioners, directing them to forthwith prepare and submit the brief documents of wetlands as per the directions of the Court, failing which necessary action will be taken against them for evading the orders of this Court. The Collectors and Divisional Commissioners shall therefore prepare and submit the brief documents SSP 8/10 ::: Uploaded on - 16/01/2020 ::: Downloaded on - 17/01/2020 00:40:28 ::: 907 wp 303 of 2018.doc of wetland within a period of two weeks from today. A copy of this order shall be forthwith forwarded to all the Collectors and Divisional Commissioners.
8. Since the Under Secretary, Environment Department has tendered an Affidavit in Writ Petition No.303 of 2018 stating that in Parabhani, Nandurbar and Nagpur Districts, there are no wetlands, Mr. Zaman Ali, Advocate appearing for the Petitioner in PIL No.87 of 2013 referred to the district wise break up prepared by the Petitioner as per the National Wetland Atlas for Maharashtra and pointed out that :
(i) Nandurbar District has a total of 735 Wetlands (Item No.1, Chart at Annexure - A);
(ii) Nagpur District has a total of 1054 Wetlands (Item No.9, Chart at Annexure - A);
(iii) Parbhani District has a total of 276 Wetlands (Item No.17, Chart at Annexure - A);
Advocate Mr. Zaman Ali submitted that therefore, a stark difference is prima facie observed between the data submitted by the Under Secretary, Environment Department and the available scientific data on number of wetlands identified in Maharashtra by premier scientific agencies (SAC and MRSAC). He submitted that in view of the above, it is highly misleading and incorrect for the Under Secretary, Environment Department to submit on oath that there are no wetlands in Nandurbar, Nagpur and Parbhani Districts.
9. In view thereof, the Principal Secretary (Environment) who is present in Court, has agreed to look into the above grievance of the Petitioner and make his SSP 9/10 ::: Uploaded on - 16/01/2020 ::: Downloaded on - 17/01/2020 00:40:28 ::: 907 wp 303 of 2018.doc submissions on the adjourned date. Also, copies of all brief documents prepared for all wetlands in the State of Maharashtra shall be supplied to the Petitioner so as to enable the Petitioner to verify whether brief documents of all wetlands as already identified under the National Wetlands Atlas - Maharashtra, are being prepared and in a proper manner.
10. Stand over to 29th January, 2020 first on board.
( B.P.COLABAWALLA, J. ) ( S.J.KATHAWALLA, J. )
SSP 10/10
::: Uploaded on - 16/01/2020 ::: Downloaded on - 17/01/2020 00:40:28 :::


--- layout: post title: blade runner spinner car from lego date: '2008-07-02T13:00:32+01:00' tags: [] tumblr_url: http://backlog.robbevan.com/post/40679997/blade-runner-spinner-car-from-lego ---
Blade Runner “Spinner” car from LEGO


HTML5
Home
Test
Links
Title of an article
Subtitle for an article
Test paragraph
Title of an article2
Subtitle for an article2
Another Test paragraph


Block #{{block_height}}
| Summary |
| Number of Transactions |
{{block_txn_count}} |
|
Timestamp |
{{block_txn_timestamp}} |
| Height |
{{block_height}} |
|
Total Output |
{{block_output}} |
| Confirmations |
{{block_confirmation}} |
|
Transaction Fees |
{{block_txn_fee}} |
| Version |
{{block_version}} |
|
Block Hash |
{{block_hash}} |
| Difficulty |
{{block_difficulty}} |
|
Previous Block |
{{block_prev}} |
| Bits |
{{block_bits}} |
|
Next Block |
{{block_next}} |
| Nonce |
{{block_nonce}} |
|
Merkle Root |
{{block_merkle}} |
| Size |
{{block_size}} |
|
Chainwork |
{{block_chainwork}} |
| Weight |
{{block_weight}} |
|
|


New photos of I'm A Celebrity campmates tease first challenges
The series will begin on Sunday
by Rebecca CarterNew photos of the I'm A Celebrity campmates have teased the first lot of terrifying challenges.
The likes of American TV star Caitlyn Jenner, former EastEnders actress Jacqueline Jossa and Good Morning Britain presenter Kate Garraway are heading into the Aussie jungle this weekend.
But it seems the stars have already been through their paces with their first lot of challenges, which will be shown during the launch this Sunday.
Read more: I'm A Celebrity's Ant and Dec arrive in a speedboat in first photo of filming
The pictures show some of the stars, which appear to be in a team, diving off a boat.
In the photo, James Haskell, Nicole Coyle, Kate, Ian Wright and Myles Stephenson were seen jumping into the water.
As they were diving, hosts Ant McPartlin and Dec Donnelly yelled at them through a megaphone on the beach.
As the celebs swam around, Ant and Dec gave them instructions from the shore.
As they finally made it to shore and waded out of the water, the team were seen relaxing on the beach completely drenched.
Others stars taking on the jungle are radio 1 DJ Adele Roberts, comedian Andrew Maxwell, Caitlyn, capital radio DJ Roman Kemp and Jacqueline.
In other photos, Jacqueline, Adele, Roman, Caitlyn and Andrew were seen standing on the beach as Dec spoke to them.
Earlier this week, it was reported that the launch was under threat because of the deadly bushfires that have been sweeping parts of Australia over the past couple of weeks.
The show bosses said they will "closely monitor" the fires ahead of the launch.
However, due to the fires, it may mean the campfire - which the celebrities use to cook and keep warm - is banned.
The NSW Rural Fire Service has been keeping locals updated on the fires and has imposed a strict fire ban until it becomes less intense.
Their website states: "Bush fires are more likely to spread and cause damage on days when the weather is very hot, dry and windy. These are usually on very high to extreme fire days.
"To reduce the risk of fires damaging or destroying life, property and the environment the NSW RFS Commissioner may declare a Total Fire Ban (TOBAN). In a Total Fire Ban no fire may be lit in the open and all fire permits are suspended."
Read more: The I’m A Celebrity campfire 'could be banned for the first time in history'
A show source told us: "We're monitoring the situation on an hourly basis and have contingencies in place for all eventualities."
A spokesperson for the programme added: "We are in constant contact with the NSW fire brigade and are closely monitoring the situation. The health and safety of all our production crew and celebrities are the utmost important."
Leave us a comment on our Facebook page @EntertainmentDailyFix and let us know what you think of this story.


With its text set in hiranori accompanied percussion instruments in strict rhythm, the Sageuta is the first of a sequence of five consecutive congruent shōdan. The text of the second act has now shifted from prose to verse.
A nostalgic tone is introduced. It started with the preceding shōdan’s : “Rain dampens Genken's (Yüan Hsien) gate,” in which rain is a metaphor for tears. It continues in the Sageuta which starts with another metaphor for tears: . This is carried over to the next shōdan, the Ageuta with a reference to the soaring over a desolate evening. The source of the nostalgia is only revealed in the following shōdan – the Rongi, when the shite asks “,” a clear and poignant reference to a lover's yearning.
The positioning of this short chant between the Issei-chant and the Ageuta is easier to appreciate when the viewer considers the shape of the vocal line across the three shōdan. The Sageuta begins in the low register, completing the descending trajectory from high to medium of the Issei-chant, before moving up towards the medium range, thus serving as a transition towards the high range of the coming Ageuta.


Minimal Example Web App
Structure
This example defines the structure of a minimal functioning web app.
It is set up in the reccomended structure for your apps.
- web-app
- static
- default.css
- index.html
- main.js
- [Other statically served files]
- test
- server.js
- [Other server side files – private to the server]
- [Files related to the project, i.e. github files, node modules, vscode, etc]
Server Interaction
Tasks
To make sure you've set up your environment correctly,
complete the following tasks:
- Install Node.js
-
Install and configure Firefox Developer Edition
- Install AXE extension
-
Install VS Code
- Install Debugger for Firefox extension
- Install JSLint extension
- Install Mocha Test Explorer extension
-
GitHub
- Create your own GitHub Account
- Accept the GitHub Classroom coursework assignment.
- Find the fourier-space /
Computing-2-Applications repo
-
Set Up VSCode
- Create a new folder for Computing 2
- Clone the module repo into your workspace
- Clone your assignment repo into your workspace
-
Check you can run the module sample web app.
- Can you see this webpage!
- Edit the README.md file in your submission repo with your CID and push.


Before Change
def __call__(self, current_file: ProtocolFile) -> Annotation:
speech_regions = self.sad_.get(
current_file["uri"], Annotation()).get_timeline()
return current_file["annotation"].crop(speech_regions)
After Change
// aka only keep speech regions
try:
annotation = current_file["annotation"]
return annotation.crop(speech_regions.get_timeline())
// this haapens when current_file has no "annotation" key
// (e.g. for file1 and file2 in speaker verification trials)
// in that case, we return speech regions directly


--- layout: post authors: ["Greg Wilson"] title: "Citing Us In Your CV" date: 2013-11-16 time: "07:00:00" tags: ["Administration", "Community"] ---
People volunteer to teach Software Carpentry bootcamps for many reasons. We're always grateful that they do, and would like them to get all the credit they deserve. Here are some of the ways instructors currently mention us in their CVs:
Software Carpentry Instructor Developer, February 2012 – present
- Teach Python, shell, Git, and software engineering skills to scientists and engineers at bootcamps and in online sessions.
- Develop new instructional content.
- Layout and design of software-carpentry.org website.
- Mentoring and administration for Software Carpentry GitHub repositories.
All of these look good to us, and we're always happy to write letters of reference for people who've helped us by teaching, coding, or writing lesson materials—please email us if we can help.


| 4.1 |
Estimated Population of West Bengal by Sex and by Region |
|
|
| 4.2 |
Estimated Population of West Bengal by District |
|
|
| 4.3 |
Projected Total, Urban and Rural Population by Sex of West Bengal |
|
|
| 4.4 |
Annual Estimated Rates of Vital Events in West Bengal |
|
|
| 4.5 |
Expectation of Life at Birth by Sex in West Bengal and India |
|
|
| 4.6 |
Health Facilities in West Bengal |
|
|
| 4.7 |
Number of Registered Medical Practitioners in West Bengal in different years |
|
|
| 4.8 |
A Profile of Malaria in West Bengal |
|
|
| 4.9 |
Reported Cases and Death Due to Kala-azar in West Bengal |
|
|
| 4.10 |
Epidemiological Data on Japanese Encephalitis |
|
|
| 4.11 |
Achievement of Universal Immunization Programme by districts of West Bengal |
|
|


Mist, fog and rain hit the North East and there could be snow on the horizon
The Met Office say Newcastle and the North East will see relatively mild, damp weather this week but the long term forecast predicts some snow and ice
by Hannah GrahamIt's set to be a week of fog, rain and relatively mild temperatures - but things might become more wintry soon.
According to the Met Office, this weekend is set to be fairly warm for the time of year, but beset by rain.
On Saturday, those hoping to catch a first glimpse at Newcastle's Christmas Market will be met with cloud and outbreaks of rain, which will be heavy at times. A cool northeasterly breeze will keep things feeling fairly chilly, but the maximum temperature is a relatively balmy 9 °C.
A "cloudy and damp night" will bring mist and fog patches.
Sunday will see more cloud, with the risk of further light rain or drizzle, but the possibility of sunnier spells and less breeze. The maximum temperature will be 10 °C.
But looking further into the future, Met Office forecasters say things could become somewhat wintrier as November develops.
Next week, weather systems pushing into the UK will make conditions rainy, with strong winds making warmer temperatures feel cold.
And, a spokesperson said: "There is a greater than normal chance of overnight fog forming in any clearer spells overnight, which could be slow to clear in places.
"The showers may continue to be wintry over the highest ground bringing some sleet or snow at times."
Temperatures will be average or slightly above for the time of year. And between November 30 and December 14, rain will become less likely - but frost, as well as the unpleasant-sounding "freezing fog" may start to appear.
Temperatures are expected to be around average, or just above, for the time of year.


Activity Information
Name
error
activity date
status
There is currently no activity information associated with this project.


We couldn't find what you were looking for. Maybe you made a boo-boo: you mistyped something.  If this problem persists, please report it to us here, and we'll fix it and get back to you as soon as possible.


{% extends "base.html" %} {% load static %} {% load divide %} {% block title %}Add Credit Card Details - {{ block.super }}{% endblock %} {% block analytics %} analytics.page("Add Credit Card Details"); {% endblock %} {% block bodyclass %}
{% endblock %} {% block content %}You are ordering the {{ product_name }} for ${{ amount|cents_to_dollars }} USD. After purchase, {% if request.session.giftee_user %}the person you are gifting this to{% else %}you{% endif %} will have access to a product dashboard to download {% if request.session.giftee_user %}the{% else %}your{% endif %} DRM-free files.
{% if not paperback and "Hello Web Design" in product_name %} {% endif %}Hello Web Books uses Stripe for processing. Stripe has been audited by a PCI-certified auditor, and is certified to PCI Service Provider Level 1. This is the most stringent level of certification available. All card numbers are encrypted on disk with AES-256. Click here for more about Stripe's security.


Before Change
bga_eia860_select = bga_eia860_select.where(
bga_eia860_tbl.c.report_date <= end_date
)
bga_eia860_df = pd.read_sql(bga_eia860_select, pudl_engine)
bga_eia860_df = bga_eia860_df.drop(["id"], axis="columns")
out_df = pudl.helpers.extend_annual(bga_eia860_df,
start_date=start_date,
end_date=end_date)
return out_df
def ownership_eia860(pudl_engine, start_date=None, end_date=None):
After Change
bga_eia860_tbl.c.report_date <= end_date
)
out_df = (
pd.read_sql(bga_eia860_select, pudl_engine)
.drop(["id"], axis="columns")
)
return out_df


{% extends 'registration/home_base.html' %} {% block title %}VIA-1 - Registration Code Generator{% endblock %} {% block additional_head %} {% endblock %} {% block content %}
Use this page to generate registration codes for attendees. When a user inputs a registration code on the home page, it will automatically mark that user as "registered" in the system OR bring them to a PayPal payment page, depending on the code type. These codes are to only be generated for special-case attendees such as waitlist, staff, schools that bulk-buy registration, or banquet-only. There's also a "Special" code type, which can be used for scholarship winners.
| Code | Date Created | Expires On | # Left | Code Type | Includes Hotel? | Remove? |
|---|---|---|---|---|---|---|
| {{ code.code }} | {{ code.date_created }} | {{ code.date_expired }} | {{ code.usages_left }} | {{ code.code_type }} | {% if code.includes_hotel %}Yes{% else %}No{% endif %} | Remove |
No records found.
{% endif %}


Critical thinker with an entrepreneurial spirit. Driven by a passion to learn.
I'm a soon to be NSS grad, specializing in full stack JS. I got into code because I love to create things, and I wanted to make cool stuff, and in my six months at NSS I have gotten to do a lot of both. Now, I can't wait to make career out of writing software.
Currently, I'm looking for a junior role, and I really want to be somewhere that I can grow quickly as a developer. So naturally, Im looking for a place that has a solid mentorship culture and will push my limits daily. If you'd like to get like to get together to talk code over a cup of coffee or a beer, you can find my contact info in the footer.


Homepage
Sales
Add New Store
Enter Location:
Enter Minimum Customers/Hour:
Enter Maximum Customers/Hour:
Enter Average Cookies Sold/Customer:
Submit


JMX Object Name: org.apache.accumulo.server.metrics:type=MasterMetricsMBean,name= <current thread name>
| Method Name | Description |
| public long getPingCount(); | Number of pings to tablet servers |
| public long getPingAvgTime(); | Average time for each ping |
| public long getPingMinTime(); | Minimum time for each ping |
| public long getPingMaxTime(); | Maximum time for each ping |
| public String getTServerWithHighestPingTime(); | tablet server with highest ping |
| public void reset(); | Resets all counters to zero |
JMX Object Name: org.apache.accumulo.server.metrics:type=LogWriterMBean,name= <current thread name>
| Method Name | Description |
| public long getCloseCount(); | Number of closed log files |
| public long getCloseAvgTime(); | Average time to close a log file |
| public long getCloseMinTime(); | Minimum time to close a log file |
| public long getCloseMaxTime(); | Maximum time to close a log file |
| public long getCopyCount(); | Number of log files copied |
| public long getCopyAvgTime(); | Average time to copy a log file |
| public long getCopyMinTime(); | Minimum time to copy a log file |
| public long getCopyMaxTime(); | Maximum time to copy a log file |
| public long getCreateCount(); | Number of log files created |
| public long getCreateMinTime(); | Minimum time to create a log file |
| public long getCreateMaxTime(); | Maximum time to create a log file |
| public long getCreateAvgTime(); | Average time to create a log file |
| public long getLogAppendCount(); | Number of times logs have been appended |
| public long getLogAppendMinTime(); | Minimum time to append to a log file |
| public long getLogAppendMaxTime(); | Maximum time to append to a log file |
| public long getLogAppendAvgTime(); | Average time to append to a log file |
| public long getLogFlushCount(); | Number of log file flushes |
| public long getLogFlushMinTime(); | Minimum time to flush a log file |
| public long getLogFlushMaxTime(); | Maximum time to flush a log file |
| public long getLogFlushAvgTime(); | Average time to flush a log file |
| public long getLogExceptionCount(); | Number of log exceptions |
| public void reset(); | Resets all counters to zero |
JMX Object Name: org.apache.accumulo.server.metrics:type=TabletServerMBean,name= <current thread name>
| Method Name | Description |
| public int getOnlineCount(); | Number of tablets online |
| public int getOpeningCount(); | Number of tablets that are being opened |
| public int getUnopenedCount(); | Number or unopened tablets |
| public int getMajorCompactions(); | Number of Major Compactions currently running |
| public int getMajorCompactionsQueued(); | Number of Major Compactions yet to run |
| public int getMinorCompactions(); | Number of Minor Compactions currently running |
| public int getMinorCompactionsQueued(); | Number of Minor Compactions yet to run |
| public int getShutdownStage(); | Current stage in the shutdown process |
| public long getEntries(); | Number of entries in all the tablets |
| public long getEntriesInMemory(); | Number of entries in memory on all tablet servers |
| public long getQueries(); | Number of queries currently running on all the tablet servers |
| public long getIngest(); | Number of entries currently being ingested on all the tablet servers |
| public long getTotalMinorCompactions(); | Number of Minor Compactions completed |
| public double getHoldTime(); | Number of seconds that ingest is waiting for memory to be freed on tablet servers |
| public String getName(); | Address of the master |
JMX Object Name: org.apache.accumulo.server.metrics:type=TabletServerMinCMetricsMBean,name= <current thread name>
| Method Name | Description |
| public long getMinorCompactionCount(); | Number of completed Minor Compactions on all tablet servers |
| public long getMinorCompactionAvgTime(); | Average time to complete Minor Compaction |
| public long getMinorCompactionMinTime(); | Minimum time to complete Minor Compaction |
| public long getMinorCompactionMaxTime(); | Maximum time to complete Minor Compaction |
| public long getMinorCompactionQueueCount(); | Number of Minor Compactions yet to be run |
| public long getMinorCompactionQueueAvgTime(); | Average time Minor Compaction is in the queue |
| public long getMinorCompactionQueueMinTime(); | Minimum time Minor Compaction is in the queue |
| public long getMinorCompactionQueueMaxTime(); | Maximum time Minor Compaction is in the queue |
| public void reset(); | Resets all counters to zero |
JMX Object Name: org.apache.accumulo.server.metrics:type=TabletServerScanMetricsMBean,name= <current thread name>
| Method Name | Description |
| public long getScanCount(); | Number of scans completed |
| public long getScanAvgTime(); | Average time for scan operation |
| public long getScanMinTime(); | Minimum time for scan operation |
| public long getScanMaxTime(); | Maximum time for scan operation |
| public long getResultCount(); | Number of scans that returned a result |
| public long getResultAvgSize(); | Average size of scan result |
| public long getResultMinSize(); | Minimum size of scan result |
| public long getResultMaxSize(); | Maximum size of scan result |
| public void reset(); | Resets all counters to zero |
JMX Object Name: org.apache.accumulo.server.metrics:type=TabletServerUpdateMetricsMBean,name= <current thread name>
| Method Name | Description |
| public long getPermissionErrorCount(); | Number of permission errors |
| public long getUnknownTabletErrorCount(); | Number of unknown tablet errors |
| public long getMutationArrayAvgSize(); | Average size of mutation array |
| public long getMutationArrayMinSize(); | Minimum size of mutation array |
| public long getMutationArrayMaxSize(); | Maximum size of mutation array |
| public long getCommitPrepCount(); | Number of commit preparations |
| public long getCommitPrepMinTime(); | Minimum time for commit preparation |
| public long getCommitPrepMaxTime(); | Maximum time for commit preparatation |
| public long getCommitPrepAvgTime(); | Average time for commit preparation |
| public long getConstraintViolationCount(); | Number of constraint violations |
| public long getWALogWriteCount(); | Number of writes to the Write Ahead Log |
| public long getWALogWriteMinTime(); | Minimum time of a write to the Write Ahead Log |
| public long getWALogWriteMaxTime(); | Maximum time of a write to the Write Ahead Log |
| public long getWALogWriteAvgTime(); | Average time of a write to the Write Ahead Log |
| public long getCommitCount(); | Number of commits |
| public long getCommitMinTime(); | Minimum time for a commit |
| public long getCommitMaxTime(); | Maximum time for a commit |
| public long getCommitAvgTime(); | Average time for a commit |
| public void reset(); | Resets all counters to zero |
JMX Object Name: org.apache.accumulo.server.metrics:type=ThriftMetricsMBean,name= <thread name>
| Method Name | Description |
| public long getIdleCount(); | Number of times the Thrift server has been idle |
| public long getIdleMinTime(); | Minimum amount of time the Thrift server has been idle |
| public long getIdleMaxTime(); | Maximum amount of time the Thrift server has been idle |
| public long getIdleAvgTime(); | Average time the Thrift server has been idle |
| public long getExecutionCount(); | Number of calls processed by the Thrift server |
| public long getExecutionMinTime(); | Minimum amount of time executing method |
| public long getExecutionMaxTime(); | Maximum amount of time executing method |
| public long getExecutionAvgTime(); | Average time executing methods |
| public void reset(); | Resets all counters to zero |


Alumnos aims to help high school students make more well-informed decisions for their post secondary-education. The organization was created by university students who saw the opportunity to bridge the gap between alumni who are eager to give back to their high school community, and students seeking to make a comprehensive, informed decision on the trajectory of the next several years of their lives.
Alumnos works to ensure that high school students can have conversations with current post-secondary students who graduated from their high school. Using our extensive Alumni Database system, Alumnos is able to match students to alumni based on universities of interest, programs, and aspirations. This gives them an insider view from someone who was exactly in their position a few short years ago. When the time comes where the students become alumni, our hope is that the impact they felt will encourage them to bring it back full circle and give back to their high school through the place where it began - Alumnos.
1. Students with questions about post-secondary education (ex. university experience, transitioning from high school to university, work-life balance, etc.) notify their Alumnos high school ambassador.
2. Their Alumnos high school ambassador uses the Alumnos Database system to connect students with a high school alumna/alumnus that can most accurately answer their questions.
3. Students have a meaningful conversation with an alumna/alumnus from their high school to have their post-secondary questions answered.
Students gain an insider view of post-secondary education, and have their questions answered from post-secondary students once in their position.
Students receiving admission to the same institution as the alumni they speak to will have a friend to help ease their transition to post-secondary education.
Alumni have the opportunity to stay connected with their high school community and support younger students that were once in their position.
Alumni will be recognized at our annual Alumnos Appreciation Night for their dedication to supporting students.


First we will argue that testing is a way to evolve without the pain of evolution To understand the need for testing, first we need to understand that path to creation is never a straight line path.
Creators iterate endlessly, learning from their previous mistakes all the time, and repeatedly improving their product. A great product works so flawlessly and obviously that it is easy to think that it is as trivial to create it as it is to use it.
Air travel is very reliable these days, but countless people have lost their lives, including aeroplane pioneers who dared to fly on their budding aeroplanes. We have learnt from automobile accidents, collapse of bridges and so on.
Science books tell us about the laws of the nature, but do not describe how erratic the process of deriving them was.
Nature (or God for the believers) itself creates through trial and error. The bodies of human beings and other animals are products of billions of years of evolution. Nature never ceases to experiment, and some of the genetic mutations lead to diseases, and the lives of affected individuals are destroyed. But that is how nature works.
Making errors is inevitable. Some people implicitly believe that making error is a sign of weakness, something which is not desirable. While they may be true, we cannot do anything about it. Thus, we need to build systems which are take into account that we will make mistakes.
Testing allow us to develop software so that we can make mistakes without impacting real world. This speeds up development process: we can write code without being fully confident that we are writing correct code, since testing allows us to find errors and gives us a chance to correct the code, before we ship it to our customers.
To be able to build a robust software, you will need to test it. In order for you to be able to test it, you need to have a testing mindset.
The testing mindset consists of the following: I accept that the code I write is likely to be incorrect. Hence I will write code in such a way that I can test it, and then I will test it thoroughly.
In practice, the testing mindset implies the following
Writing code is an art. The more you get better at it, the more you are able to appreicate and write beautiful code.
One of the characterstics of a well written code is that it is testable. It is easily possible to write test cases. Note what the the testing mindset describes above says that you need to write code such that you can test it later. It implies that testing cannot be an add-on once you have finished development. Rather, testing needs to be "baked in" during the development process itself.
When beginning to write the code, you must ask yourself: "How will I be able to test this code". The code should be written in a way that it lends itself to testing.
Let's illustrate this point with the help of an example:


PIZZA PALACE.


READY TO TRAVEL WITH FLAMINGO?
Join our WEB/APP to be among the first to try the new service.
You will get a new travel friend, exciting experience
and the top discounts offered by FLAMINGO.
You will get a new travel friend, exciting experience
and the top discounts offered by FLAMINGO.


To invest in this project you must confirm receipt and indicate agreement with the following documents:
I have received and agree to the {{doc_name}}
To invest in this project you must confirm receipt and indicate agreement with the following:
I have sufficient knowledge and experience in financial and business matters so as to be capable of evaluating the merits and risks associated with investing in this offering.
I understand the nature of an investment in this offering and the risks associated with such an investment.
I understand that there is no guarantee of any financial return on this investment and that I run the risk of losing my entire investment.
I acknoledge that I have the right, will be afforded an opportunity, and am encouraged to investigate this offering and review relevant records, agreements, and documents pertaining to this offerring and its business and to ask questions, and receive answers, of a qualified representative of this offering regarding this investment and the operations and method of doin business of this offering.


BankOfOlive
Account succesfully created
Fullname: Amaka Emodi
Email<EMAIL_ADDRESS>Phone number:<PHONE_NUMBER>4
Address: 45, modupe street.
Account type: Savings
Account number:<PHONE_NUMBER>
Account balance: N0.00
Fullname: Amaka Emodi
Email<EMAIL_ADDRESS>Phone number:<PHONE_NUMBER>4
Address: 45, modupe street.
Account type: Savings
Account number:<PHONE_NUMBER>
Account balance: N0.00


This is the second line
This is the second line
This is the second line
This is the second line
This is the second line
This is the second line
This is the second line
This is the second line
This is the second line
This is the second line
With multi-line and icon
With multi-line and icon
With multi-line and icon
With multi-line and icon
With multi-line and icon
With multi-line and icon
With multi-line and icon
With multi-line and icon
With multi-line and icon
With multi-line and icon
with section
with section
with section
with section
with section
with section
with section
with section
with section
with section


Security
HTTP Strict-Transport-Security (HSTS)
Makes the site HTTPS only.
HTTP header Strict-Transport-Security: max-age=31536000; includeSubDomains
(units in seconds; this is a year).
It is ignored in an HTTP site. The setting is saved when you use HTTPS, and is enforced until the age expires.
If you have never visited https://site and go to http://site, the header is ignored. You have to redirect to https in server code. Google has a preload service, so you can the initial HTTP vulnerability.
Content-Security-Policy: upgrade-insecure-requests;
. Note all links, including third party links, become https and will fail if they're not...
Content Security Policy (CSP)
Stops XSS by whitelisting script sources.
ref Http header Content-Security-Policy or <meta http-equiv="Content-Security-Policy"
Content-Security-Policy: default-src 'self' *.mysite.com
All img/script/frame/style from same source (can be a url) plus subdomains
After the default, add whitelisted script-src; img-src; style-src
Inline script/css will be blocked. If you can't remove them, use the workarounds: script-src 'unsafe-inline'; style-src 'unsafe-inline'
Note inline events are blocked as well <button onclick="alert('hi')" >
Subresource Integrity (SRI)
Add a secure hash for scripts/styles, particularly from a CDN, so you are sure they are unaltered.
Ref.
- Add a CSP (see above)
Content-Security-Policy: require-sri-for script; require-sri-for style;
- Add "integrity" attribute to <script> and <link> tags:
<script src="https://cdn/jquery.js" integrity="sha384-h2..." >
Cross-Origin Resource Sharing (CORS)
Ajax (XMLHttpRequest and Fetch) have a same-origin policy; CORS relaxes it (so http://website/ can get data from http://api/).
Ref. Note the browser (not your javascript) is doing the process in ajax calls.
- If simple GET or POST with standard HTTP headers
- The browser ajax automatically adds HTTP header "Origin" with the current site.
- The server returns "Access-Control-Allow-Origin" with the allowed site. If it's not "*" and doesn't match the current site, the browser errors.
- If custom headers (eg authentication) do a "preflight request"
- Browser sends HTTP OPTIONS with Origin, Access-Control-Request-Method (http method) and Access-Control-Request-Headers.
- Server responds with Access-Control-Allow-Origin, Access-Control-Allow-Headers and -Methods, all of which must match.
The server must know what specific calling sites, methods and headers (or use "*", for non-secure access).
By default, no credentials are passed cross-origin. To send credentials:
- JavaScript: xhr.withCredentials = true; or jQuery xhrFields: {withCredentials: true }
- Configure server.
- For .net webapi, indicate in attribute- [EnableCors(origins: "...", SupportsCredentials = true)] Origin of "*" is not allowed.
- For .net Core, in ConfigureServices services.AddCors(o=> o.AddPolicy("name", b=>b.WithOrigins("...").AllowCredentials()))
- Server responds with Access-Control-Allow-Credentials.


Field settings
Field size:
Small
Medium
Large
Field color:
Background color:
Ball settings
Ball size:
Small
Medium
Large
Ball speed:
Slow
Fast
Very fast
Ball color:
Ball outline color:
Player 1 settings
Racket size:
Small
Medium
Large
Racket color:
Nickname:
Player 2 settings
Racket size:
Small
Medium
Large
Racket color:
Nickname: