strong-typing

I am new to Derby and I noticed that I face similar problems as when using the DB2 RDBMS as far as null values are concerned. The Derby documentation states, that a null value must have a type associated with it (something that DB2 finally got rid of in version 9.7): http://db.apache.org/derby/docs/10.7/ref/crefsqlj21305.html Now, I am trying to find a general solution to this problem here as this will be a part of my database abstraction library jOOQ . The below example just documents the problem. Think of any other (more complex) example. The following doesn't work: insert into T_AUTHOR ( ID

I was looking over the TypeScript handbook and I can't seem to find the answer. If I am using a library that no typings exist, what are my options? One is to create the typings file, but this I don't really want to do. What are my other options, I seem to remember some kind of 'declare' keyword ? Or maybe something in the tsconfig ? I assume there is a way of declaring this variable (type) globally so every time I use it, it would just work. And I presume there is a way of just declaring it only available in one file. Of course the best way would be to include a typings file but this won't

This is a hard question about language design, patterns and semantics. Please, don't down-vote just because you don't see the practical value. First, let's think about functions and their parameters. Then we'll look at the analogies between functions with their parameters/arguments and generic classes/functions with their type-parameters/type-arguments. Functions are blocks of code with some unspecified values called " parameters ". You supply the arguments and receive the result. Generic classes are classes with some unspecified " type-parameters ". You supply the type-arguments and then you

Since PHP7 we can now use scalar typehint and ask for strict types on a per-file basis . Are there any performance benefits from using these features? If yes, how? Around the interwebs I've only found conceptual benefits, such as: more precise errors avoiding issues with unwanted type coercion more semantic code, avoiding misunderstandings when using other's code better IDE evaluation of code Today, the use of scalar and strict types in PHP7 does not enhance performance. PHP7 does not have a JIT compiler. If at some time in the future PHP does get a JIT compiler, it is not too difficult to

I have a plain old CLR object which is essentially a wrapper for two entity framework objects, I'm doing this so I can pass this wrapper object to a strongly typed view in the MVC framework. My foo wrapper class is very simple: public class FooWrapper { public FooWrapper(Foo f, Bar b) { this.FooObject = f; this.BarObject = b; } public Foo FooObject { get; private set; } public Bar BarObject { get; private set; } } What I have so far for my ListFoosWithBars function is as follows: public IEnumerable<FooWrapper> ListFoosWithBars(int userID) { IEnumerable<Bar> tempBar = ListBarsByUserID(userID);

Say I have a class with one property Public Class MyClass Public Property MyItem() as Object .... End Property End Class I have to pass the name of the property to a function call. (Please don't ask why it should be done this way, its a third party framework). For example SomeFunc("MyItem") But what I would like to do is, change the string into a strongly typed parameter. Meaning, if the property name is renamed or changed, it should be reflected here too. So something of this type : Dim objectForStrongTyping as New MyClass() SomeFunc(objectForStrongTyping.MyItem().Name()) I am sure this won't

The way I understand it, the following is allowed in PHP because it's a weakly-typed language. $var = 'Hello'; $var = 5; I just installed a Windows version of Python 2.6 and I was expecting it NOT to let me change type just like that, but the Python equivalent of the above code works just like in PHP yikes! >>> var = "Hello" >>> type(var) <type 'str'> >>> var = 5 >>> type(var) <type 'int'> Is my understanding of weak/strong typing flawed? Your example demonstrates dynamic typing, not weak typing. Dynamic typing generally means that the type of data an object can store is mutable; any target

I frequently write C# code that has to use magic strings to express property names. Everyone knows the problems with magic strings. They are very difficult to refactor, they have no compile time checking, and often they lead to hard-to-diagnose issues. Yet C#/.NET uses them all over the place to represent property/class/method names. This issue has persisted for years and years, and the only viable solution currently is to use an expression tree which is then parsed at run-time for the property name. This gets you satisfactory compile-time checking, but it complicates the code (requiring