Increment: Fill & Download for Free

Yes, it is true.To properly understand this, we need to understand the organisational structure of ISRO.Any scientist/engineer who joins ISRO starts at the level of Sci./Eng. “SC”.After first promotion, she becomes Sci./Eng. “SD”.Third Promotion - Sci./Eng. “SE”.Fourth Promotion - Sci./Eng. “SF”.Fifth Promotion - Sci./Eng. “SG”.Sixth Promotion - Sci./Eng. “G”.There are higher levels as well but that is not useful for the answer.The promotion and salary of the scientist/engineers of ISRO are decided using PRIS (Performance Related Incentive Scheme) for a very long time. It is not something new as suggested in the newspaper and the other answer.In PRIS system, candidate is evaluated for promotion through an interview.Now at the time of every promotion, these were the following hikes that a candidate used to get -Increase in basic pay that is used to calculate DA, TA, HRA etc.PRIS increments (of Rs. 2000 each for “SC” -> “SD”). Number of increments depended upon the performance of the candidate in the interview. There were 3 types of such increments -Variable increments - maximum 4. On every 6 months delay in the promotion, the number of this increment decreased by 1. So, if candidate faced 1 year of delay in his promotion then he would only get 2 such increments.Variable increments - maximum 2. Depending upon the performance of the candidate, the interviewing committee may give 0, 1 or 2 increments to the candidate.Fixed increments - 2. Every candidate from “SD” till “SG” used to get 2 increments. This was fixed. But it was only applicable till “SG” level. It was not applicable for “G” and higher levels.All 3 increments would be added together. So, many instances could be seen when the salary of a candidate decreased on getting promoted from “SG” to “G” due to point “c” mentioned above. This was a long pending issue in front of Dept. of Space, Govt. of India.So, to settle this issue, govt. decided to take away the 2 fixed increments from every scientist/engineer from level “SD” till “SG”.This is what has been told to me by my seniors who are at “SF” level (I am at “SC” level currently).PS: Salaries being offered by ISRO are already very competitive with respect to what is being offered in the private companies. For eg. at “SC” level, total taxable income is already close to 12 LPA. At “SF” level, salaries become even higher than the private sector (gross income in between 24 to 30 LPA). So I do not agree with the statements mentioned in the newspaper that the employees of ISRO are struggling to support their families now because of this decision.Also I would like to dispel this notion that employees of ISRO are under-paid. Truly speaking, they are not!! They get salaries which are comparable to the private sector atleast at the lower and intermediate levels.

*sigh*Yes, it’s true that you should prefer ++i over i++ in C++ for isolated increments, as the former may have a performance benefit.There’s no guarantee it will be faster, however. In fact, with modern compilers and processors, it won’t be measurably faster for most code and most datatypes. That said, there are cases where it makes a difference.Let’s start at the beginning: ++i and i++ mean different things.++i increments the variable i and returns the newly computed value.i++ increments the variable i and returns the previous value.The above is a slight over-simplification. The ++ operator does mean increment when used with the fundamental types. When used with class objects, it invokes one of two flavors of operator++ for that class, and in theory those could do anything. In a reasonable program, it should still behave as an increment semantically, even if it’s not actually adding 1 to something.In any case, the difference comes down to the value returned from the operation: Is it the new, incremented value, or is it the previous value? For i++, the compiler (or operator++) will need to keep a copy of the original value to return after incrementing the variable. That copy may have non-trivial cost.If you don’t actually use the value returned by an increment, then the two expressions are largely identical, since nothing consumes the value returned from the expression. In most cases, the compiler can and will delete the copy implied by i++ if you don’t actually need it. See for yourself:int i;  void preinc() { ++i; } void postinc() { i++; } Both functions produced identical code:preinc():  add DWORD PTR i[rip], 1  ret postinc():  add DWORD PTR i[rip], 1  ret So, for the fundamental data types, if you’re not using the value returned by an increment expression, there’s likely no performance difference associated with pre-increment vs. post-increment.What about other object types?C++ containers and algorithms rely on a pointer-like concept called iterators. Iterators allow you to step through data in an orderly fashion. They’re an abstraction above pointers.Iterators allow you to use expressions such as *i++ to access an object in a container and move to the next object, for example. The ++ here may not be a simple “add 1.” In a std::map, it actually has to traverse an RB-tree.Thus, with iterators, you could see a much bigger difference between i++ and ++i when the cost of copying an iterator is non-trivial.More generally, if the copy-constructor for a class that overloads these operators has a side effect, the compiler may not be able to optimize it away.For example:#include <atomic>  class clown {  static std::atomic_ullong allocations;  int value;   public:  clown() : value(0) { allocations++; }  clown(const clown& rhs) : value(rhs.value) {  allocations++;  }  clown& operator=(const clown& rhs) {  value = rhs.value;  allocations++;  }   // pre-increment:  clown& operator++() { value++; return *this; }   // post-increment:  clown& operator++(int) {  clown tmp = *this;  operator++(); // implement in terms of pre-increment  return tmp;  } };  clown car;  void preinc() { ++car; } void postinc() { car++; } Notice that post-increment is implemented in terms of pre-increment, with an extra copy to preserve the original value. This is the usual way to implement post-increment.Now preinc() and postinc() produce different code:preinc():  add DWORD PTR car[rip], 1  ret postinc():  lock add QWORD PTR _ZN5clown11allocationsE[rip], 1  add DWORD PTR car[rip], 1  ret Notice that lock add there? That’s due to the atomic increment in the copy constructor. That copy constructor got invoked in operator++(int) (the post-increment), since we needed to make a copy of our object to return after the increment.Sure, this is a concocted case. But the reality is: Copies are sometimes expensive, and the compiler can’t always eliminate them. i++ has an implicit copy that ++i does not.The compiler will eliminate as much dead code as it can, and so most of the time, you won’t see a difference between ++i and i++ for standalone increments. When you start getting into iterators or other objects, though, you’re more likely to see small performance differences.Addendum: The observations above also apply to --i and i--.

Original question asked: “What are the rings on mortar rounds for?”These rings at the base of the rounds, right above the fins on all but the right most round?Those are the propellent “increments". To hit a target at a specific range, with a specific round, at a specific elevation, the mortarmen will take off the increments until the round has the charge called for in the firing calculations (all the way to “Increment Zero" - super close, because you're basically relying only on the charge in the tail that is both your first charge and your ignition charge).The discarded increments are generally piled up in a hole or barrel and burned, to avoid donating high grade propellent to the enemy when you move out.