weak-typing

I started learning PHP not too long ago and I ran into this issue: <?php $a = 1; $b = 2; echo "$a * $b = " . $a * $b; echo "<br />"; echo "$a / $b = " . $a / $b; echo "<br />"; echo "$a + $b = " . $a + $b; echo "<br />"; echo "$a - $b = " . $a - $b; echo "<br />"; I get the following output: 1 * 2 = 2 1 / 2 = 0.5 3 -1 The last two lines in the output are not what I would expect. Why is this? How are these expressions evaluated? I'm trying to get a better understanding of the language. This is happening because the concatenation operator has a higher precedence than the addition or subtraction

From What I understand, does is dynamic typing the same as weak typing and strong typing is the same as static typing. Whats the difference? Thanks Boumbles Static typing vs dynamic typing: Static typing is when your type checking occurs at compile time. You must define a type for your variables inside of your code and any operations you perform on your data would be checked by the compiler. Dynamic typing is when your type checking occurs at runtime. Instead of errors coming up when you compile your code you will get runtime errors if you try performing operations on incompatible types.

What is meant by strongly typed datasets in .Net? Can anybody explain with a clear and brief example? And also, what is the difference between strongly typed and weakly typed datasets? Strongly Typed Datasets are generated on the basis of a Db Schema. They consists of classes derived form DataSet, DataTable and DataRow. Db Columns become correctly typed properties of the TableRow derived class. An Untyped Dataset simply means the direct use of Dataset, not of a descendant. All column access has to be type-cast. There is no such thing as a Weakly Typed Dataset . Typed Versus Untyped Datasets A

It seems to me that the most invaluable thing about a static/strongly-typed programming language is that it helps refactoring: if/when you change any API, then the compiler will tell you what that change has broken. I can imagine writing code in a runtime/weakly-typed language ... but I can't imagine refactoring without the compiler's help, and I can't imagine writing tens of thousands of lines of code without refactoring. Is this true? I think you're conflating when types are checked with how they're checked. Runtime typing isn't necessarily weak. The main advantage of static types is exactly

As Which equals operator (== vs ===) should be used in JavaScript comparisons? indicates they are basically identical except ' === ' also ensures type equality and hence ' == ' might perform type conversion. In Douglas Crockford's JavaScript: The Good Parts , it is advised to always avoid ' == '. However, I'm wondering what the original thought of designing two set of equality operators was. Have you seen any situation that using ' == ' actually is more suitable than using ' === '? Consider a situation when you compare numbers or strings: if (4 === 4) { // true } but if (4 == "4") { // true }