systems and methods are described hereinafter with respect to type inference activation , among other things . a computer program can be associated with an inference option that indicates whether or not type inference is to apply to a program or portions thereof . type inference can also interact in various manners with other program language features or options of a single program language including early / late binding . still further yet , a program can be analyzed and inference , binding and / or other options recommended or suggested as a function of the analysis to aid programmers in program specification . various aspects of the subject disclosure are now described with reference to the annexed drawings , wherein like numerals refer to like or corresponding elements throughout . it should be understood , however , that the drawings and detailed description relating thereto are not intended to limit the claimed subject matter to the particular form disclosed . rather , the intention is to cover all modifications , equivalents and alternatives falling within the spirit and scope of the claimed subject matter . referring initially to fig1 , a program compiler / translation system 100 is illustrated in accordance with an aspect of the claimed subject matter . the compiler / translation system 100 is operable to analyze and transform or translate a program from a first form to a second form . accordingly , the compiler system 100 can correspond to a source code compiler or a just - in - time ( jit ) compiler , among other things . the compiler system 100 includes an option identifier component 110 and a type inference component 120 . the option identifier component 110 locates or otherwise identifies semantic or compiler options associated with a program . the options can be specified at one or more levels of granularity including project , file and / or construct level among others . further yet , the options can be specified at a compiler command line . where specified options conflict , the option identifier component 110 can resolve the conflict utilizing predefined rules , inference or other mechanisms . for instance , a project option may override a command line prompt , which may take precedence over a file or construct option , or vice versa . in accordance with one aspect , the option identifier component 110 can identify a type inference option . type inference is a convenience mechanism that allows programmers to omit type annotations where the types can subsequently be inferred automatically . accordingly , the type inference option can act as a switch to turn type inference on or off for a program or portion thereof . by way of example and not limitation , the option can be specified as a statement at the beginning of the file such as “ option infer on ” or “ option infer off ” alternatively , it can appear in a command line prompt such as “/ optioninfer : +” or “/ optioninfer −.” the option identifier component 110 can identify options from one or more of such locations . the type inference component 120 is a mechanism that performs type inference in accordance with any conventional or novel inference algorithm native to the compiler or extended by a plug - in or the like . the type inference component 120 can receive , retrieve or otherwise obtain or acquire inference option information from the option identifier component 110 . if the option indicates that type inference is to be performed , the type inference component 120 can be activated to infer types . otherwise , the type inference component 120 remains inactive or unemployed . the result of the type inference component 120 , if successful , is a type . an inferred type or failure to infer a type can be employed by a type checker component ( not shown ) to identify programmatic errors as a function of types , among other things . by way of example , consider a generic variable assignment “ x = 5 .” if type inference were on , then “ x ” would be inferred to its precise type integer since “ 5 ” is an integer and it is assigned to the field / variable “ x .” if inference is off , then the type inference is not performed . in a static language would cause an error since the type of “ x ” was neither declared explicitly as in “ int x = 5 ” or inferred . it should be appreciated that type inference can be applicable to any or all syntactic and / or semantic constructs . the above example pertains to a local variable and more specifically local variable initialization . however , the claimed subject matter is not so limited . type inference can also apply to return results and / or parameters , among other things . furthermore , the granularity of type inference can be explicitly delimited . for example , the inference option can be parameterized or qualified to indicate that type inference is to apply to local variables , returns results and / or method parameters . dually , type inference can be turned on everywhere except for explicitly listed scenarios and / or constructs . for instance , type inference can be specified as on excluding method parameters — meaning , type inference will not be performed with respect to method parameters but will otherwise apply . compiler / translation system 100 is applicable to either static or dynamic languages . moreover , in accordance with an aspect of the claimed subject matter , type inference functionality provided by system 100 can be implemented with respect to a hybrid static / dynamic language . in other words , the system 100 is applicable to a program including both static features such type inference as well as dynamic features such as late binding . turning attention to fig2 , a program compiler / translation system 200 is illustrated in accordance with an aspect of the claimed subject matter . similar to system 100 of fig1 , the system 200 can include the option identifier component 110 and the inference component 120 , as previously described . in brief , the option identifier component 110 locates a semantic and / or compiler option associated with a program that is utilized to switch type inference provided by the component 120 on or off . additionally , the system 200 includes binding component 210 communicatively coupled to the option identifier component 110 . the binding component 210 binds types to objects , among other things . in object - oriented programming , for instance , objects can include members such as methods , functions and / or fields / variables . one feature of object - oriented programming is polymorphism , which refers to a concept that objects of different types can respond to member calls of the same name each one providing a potentially differing functionality . for example , if class “ b ” is derived from class “ a ,” then b need not inherit everything from class a ; it can do some things differently . hence , functionality is determined by a type bound to an object . additionally or alternatively , the binding component 210 can bind types to generic methods or the like . it is to be appreciated that the binding component 220 can include one or more sub - components ( not shown ) for looking up types , inferring types and / or resolving overloads , among other things . the functionality of binding component 210 can be applied early at compile time or late at runtime . type can be bound to objects at compile time if they are known . however , sometimes types cannot be determined at compile time and / or binding is not desired at that time . in this case , binding can be applied at runtime prior to execution . in any event , the functionality provided by the binding component 210 can be substantially similar whether performed at compile time or runtime . applicability of the binding component 210 can be dependent upon an associated option . the option identifier component 110 can identify a binding option ( e . g ., option strict ) that indicates whether binding is to be performed early or late . similar to the inference option , the binding option can be identified from , among other things , a program / project statement and / or a compilation option . moreover and in accordance with one aspect , binding can be dependent upon an explicit type . for example , if a variable is explicitly specified of a root type such as “ object ,” then late binding is on for that expression . in this manner , programmers can opt into late binding via explicit type annotation . it is to be appreciated that there can be interdependencies between binding and inference options . for instance , if late binding is turned on ( e . g ., option strict off ) then type inference can be switched off or alternatively if late binding is off ( e . g ., option strict on ), type inference can be turned on . one issue with the example dependencies is that some users may want to have both late binding and type inference on for flexibility and strong typing , respectively . accordingly , the dependency can be such that when type inference is on , late binding is on or vice versa . any dependencies can be implemented and effectuated by the option identifier component 110 . by way of example , consider an exemplary static typed code segment “ dim x = 3 .” if type inference is on for local variables , a compiler could use the variable &# 39 ; s initialization to determine its type at compile type . here , since “ 3 ” is an integer , “ x ” can be inferred as type integer . this could also be considered early bound code as the variable “ x ” is bound to type integer . alternatively , if type inference is off , then an error could be generated since type is not explicitly specified . if type inference is turned on , the type can be inferred to be of type object , a common super type of integer and string . however , if type inference is on only for local variable initialization , then an error would be produced . in this case , “ x ” would be inferred first to be of type integer . subsequently , an error would be produced with respect to the second line of code , as this would be interpreted as attempting to assign a string “ abc ” to an integer variable . type inference and binding can interact in a myriad of different ways . by way of example , consider a system that requires a global option ( e . g ., option strict off ) and a root type object to indicate late binding is to be applied . consider the following code snippet : here , the type of “ x ” would be inferred to type integer based on the assignment of the integer “ 3 .” programmers can explicitly opt into late bind by explicitly specifying the type as object as follows : referring to fig3 , an exemplary program 300 is illustrated in accordance with an aspect of the claimed subject matter . the program 300 can be a program file , group of files , or project , among other things . program code component 310 includes sequence of one or more statements and / or declarations in a computer programming language ( e . g ., c #, visual basic , java , intermediate language code ( il ) . . . ). the program can also include inference option component 320 and binding option component 320 internal and / or external to the program code component 310 . for instance , options can be specified within a program file or at a project level . the inference option component 320 specifies whether or not and / or where type inference is to apply . for example , the component 320 can be implemented as statement such as “ option infer on / off .” the statement can also be qualified by inclusion and / or exclusion groups such as “ option infer on + local variables ” or “ option infer on − method parameters , results ,” respectively . the binding option component 330 indicates whether types are early bound or late bound . furthermore , the binding options can be specified implicitly or explicitly at varying levels of granularity such as for an entire project or a single expression in a program file . in one instance , the binding option can be implemented as a statement such as “ option strict on / off ,” “ option late bind on / off ,” or “ option early bind on / off .” the statement can also be qualified to include or exclude particular constructs or regions of code . additionally or alternatively , the binding component 330 can include and / or be triggered by an implicit and / or explicit type such as language root type ( e . g ., object ). turning attention to fig4 , an option determination system 400 is illustrated in accordance with an aspect of the disclosure . the system 400 provides a mechanism for providing feedback regarding options and their usage . in one implementation , the system 400 can form a part of a program development component or system such as a program editor , tool , integrated development environment ( ide ) and / or the like . accordingly , the system 400 can be a pluggable extension for conventional program development environments . the option determination system 400 includes an interface component 410 and an analysis component 420 . the interface component 420 provides a mechanism for interacting with a program . in one instance , the interface component can receive and / or retrieve program code and transmit or otherwise make the code available to the analysis component 420 . upon acquisition of program code , the analysis component 420 can analyze the code and make suggestions corresponding to semantic or compiler options such as type inference and / or binding options . in essence , the analyzer component 430 can infer options that result in the least amount of errors . in one implementation , the analysis component 420 can employ control flow analysis to look at types being assigned explicitly or implicitly . based on this analysis , feedback can be provided to a programmer suggesting type inference be turned on or off . furthermore , assistance can be provided to change option state . for instance , feedback can be provided as a warning indicating that the system believes the programmer should utilize a particular option and a smart tag that can be activated to change option state . the aforementioned systems , architectures and the like have been described with respect to interaction between several components . it should be appreciated that such systems and components can include those components or sub - components specified therein , some of the specified components or sub - components , and / or additional components . sub - components could also be implemented as components communicatively coupled to other components rather than included within parent components . further yet , one or more components and / or sub - components may be combined into a single component to provide aggregate functionality . communication between systems , components and / or sub - components can be accomplished in accordance with either a push and / or pull model . the components may also interact with one or more other components not specifically described herein for the sake of brevity , but known by those of skill in the art . furthermore , as will be appreciated , various portions of the disclosed systems and methods may include or consist of artificial intelligence , machine learning , or knowledge or rule based components , sub - components , processes , means , methodologies , or mechanisms ( e . g ., support vector machines , neural networks , expert systems , bayesian belief networks , fuzzy logic , data fusion engines , classifiers . . . ). such components , inter alia , can automate certain mechanisms or processes performed thereby to make portions of the systems and methods more adaptive as well as efficient and intelligent . by way of example and not limitation , the inference component 120 can employ such mechanisms to facilitate identification and binding of types . furthermore , the analysis component 420 can employ machine learning with respect to code analysis and option suggestion . in view of the exemplary systems described sura , methodologies that may be implemented in accordance with the disclosed subject matter will be better appreciated with reference to the flow charts of fig5 - 8 . while for purposes of simplicity of explanation , the methodologies are shown and described as a series of blocks , it is to be understood and appreciated that the claimed subject matter is not limited by the order of the blocks , as some blocks may occur in different orders and / or concurrently with other blocks from what is depicted and described herein . moreover , not all illustrated blocks may be required to implement the methodologies described hereinafter . referring to fig5 , a type inference method 500 is illustrated in accordance with an aspect of the claimed subject matter . the type inference method 500 automatically supplies omitted types for programmatic constructs where the types can be inferred . at reference numeral 510 , an inference option is identified . by way of example and not limitation , the inference option can be identified as an option statement in a program file or project ( e . g ., “ option infer on / off ”). additionally or alternatively , the option can be identified from a compile command prompt , for instance “/ optioninfer [+|−].” still further yet , the option can be inferred or identified as a default . at numeral 520 , the type inference is performed in accordance with an identified option . for example , if the type inference option is on , types can be inferred and bound to objects at compile time . alternatively , no action need be taken . furthermore , it is to be appreciated that type inference can be applied at various levels of syntactic and / or semantic granularity ( e . g ., project , file , file segments , statements . . . ). for example , type inference can be applied for local variables , fields or properties upon initialization , return values and / or parameter types . fig6 depicts a binding method 600 in accordance with an aspect of the subject disclosure . binding refers to binding types to objects at compile time or at runtime . binding at compile time is advantageous in that it increases execution speed and reduces runtime errors . alternatively , runtime binding provides programming flexibility , for instance where a compile type cannot be determined . at reference numeral 610 , a binding option is identified indicating whether binding is early or late . this can be identified from project and / or file metadata . additionally or alternatively , the binding option can be identified from a compiler command line prompt ( e . g ., “/ optionstrict [+|−]”), among other things . at reference 620 , late binding of constructs can occur . late binding can comprise binding types to objects and / or objects to methods or the like . in accordance with one aspect , the binding can occur with respect to constructs explicitly declared of a root type such as “ object .” however , the scope of innovation need not be so limited . referring to fig7 , a method of type inference and binding 700 is illustrated in accordance with an aspect of the claimed subject matter . it is to be appreciated that type inference and binding can be related and / or dependent upon each other . in other words , they can be employed together over a program in a single programming language . at reference numeral 710 , type inference can be performed at compile time with respect to specified programmatic constructs that omit type . in other words , types can be early bound to constructs . for example , local variable types can be inferred and bound thereto upon initialization . at numeral 720 , constructs not early bound are late bound . in accordance with an aspect of the disclosure , late bound constructs can be uniquely identified , for instance via explicit specification of a root type such as object or special static type ( e . g ., dynamic ), among other things . for example , type parameters can be bound to types and / or method bound to objects , among other things . fig8 is a flow chart diagram of a method of provisioning programmatic assistance 800 in accordance with an aspect of the claimed subject matter . at reference numeral 810 , a program is analyzed . for example , control flow and / or data flow analysis can be employed to analyze program specification . at reference numeral 820 , suggestions , recommendations or hints can be provided with respect to type inference and / or binding options . based on particulars of program specification such suggestions or the like can be made with a view toward minimizing errors . for instance , if turning type inference on would produce less errors that when it is off , then a program can be notified that he might like to turn type inference on . similarly , if a late bound program would produce fewer errors , then a late bound option can be recommended . these suggestions can be provided at a program , file and / or construct level . in one instance , a warning can be displayed alone or in combination with a smart tag which would allow a use to toggle options in accordance with a suggestion ( e . g ., option infer on / off , option strict on / off ). as used herein , the terms “ component ,” “ system ” and the like are intended to refer to a computer - related entity , either hardware , a combination of hardware and software , software , or software in execution . for example , a component may be , but is not limited to being , a process running on a processor , a processor , an object , an instance , an executable , a thread of execution , a program , and / or a computer . by way of illustration , both an application running on a computer and the computer can be a component . one or more components may reside within a process and / or thread of execution and a component may be localized on one computer and / or distributed between two or more computers . the word “ exemplary ” is used herein to mean serving as an example , instance or illustration . any aspect or design described herein as “ exemplary ” is not necessarily to be construed as preferred or advantageous over other aspects or designs . furthermore , examples are provided solely for purposes of clarity and understanding and are not meant to limit the subject innovation or relevant portion thereof in any manner . it is to be appreciated that a myriad of additional or alternate examples could have been presented , but have been omitted for purposes of brevity . as used herein , the term “ inference ” or “ infer ” refers generally to the process of reasoning about or inferring states of the system , environment , and / or user from a set of observations as captured via events and / or data . inference can be employed to identify a specific context or action , or can generate a probability distribution over states , for example . the inference can be probabilistic — that is , the computation of a probability distribution over states of interest based on a consideration of data and events . inference can also refer to techniques employed for composing higher - level events from a set of events and / or data . such inference results in the construction of new events or actions from a set of observed events and / or stored event data , whether or not the events are correlated in close temporal proximity , and whether the events and data come from one or several event and data sources . various classification schemes and / or systems ( e . g ., support vector machines , neural networks , expert systems , bayesian belief networks , fuzzy logic , data fusion engines . . . ) can be employed in connection with performing automatic and / or inferred action in connection with the subject innovation . furthermore , all or portions of the subject innovation may be implemented as a method , apparatus or article of manufacture using standard programming and / or engineering techniques to produce software , firmware , hardware , or any combination thereof to control a computer to implement the disclosed innovation . the term “ article of manufacture ” as used herein is intended to encompass a computer program accessible from any computer - readable device or media . for example , computer readable media can include but are not limited to magnetic storage devices ( e . g ., hard disk , floppy disk , magnetic strips . . . ), optical disks ( e . g ., compact disk ( cd ), digital versatile disk ( dvd ) . . . ), smart cards , and flash memory devices ( e . g ., card , stick , key drive . . . ). additionally it should be appreciated that a carrier wave can be employed to carry computer - readable electronic data such as those used in transmitting and receiving electronic mail or in accessing a network such as the internet or a local area network ( lan ). of course , those skilled in the art will recognize many modifications may be made to this configuration without departing from the scope or spirit of the claimed subject matter . in order to provide a context for the various aspects of the disclosed subject matter , fig9 and 10 as well as the following discussion are intended to provide a brief , general description of a suitable environment in which the various aspects of the disclosed subject matter may be implemented . while the subject matter has been described above in the general context of computer - executable instructions of a program that runs on one or more computers , those skilled in the art will recognize that the subject innovation also may be implemented in combination with other program modules . generally , program modules include routines , programs , components , data structures , etc . that perform particular tasks and / or implement particular abstract data types . moreover , those skilled in the art will appreciate that the systems / methods may be practiced with other computer system configurations , including single - processor , multiprocessor or multi - core processor computer systems , mini - computing devices , mainframe computers , as well as personal computers , hand - held computing devices ( e . g ., personal digital assistant ( pda ), phone , watch . . . ), microprocessor - based or programmable consumer or industrial electronics , and the like . the illustrated aspects may also be practiced in distributed computing environments where tasks are performed by remote processing devices that are linked through a communications network . however , some , if not all aspects of the claimed subject matter can be practiced on stand - alone computers . in a distributed computing environment , program modules may be located in both local and remote memory storage devices . with reference to fig9 , an exemplary environment 910 for implementing various aspects disclosed herein includes a computer 912 ( e . g ., desktop , laptop , server , hand held , programmable consumer or industrial electronics . . . ). the computer 912 includes a processing unit 914 , a system memory 916 and a system bus 918 . the system bus 918 couples system components including , but not limited to , the system memory 916 to the processing unit 914 . the processing unit 914 can be any of various available microprocessors . it is to be appreciated that dual microprocessors , multi - core and other multiprocessor architectures can be employed as the processing unit 914 . the system memory 916 includes volatile and nonvolatile memory . the basic input / output system ( bios ), containing the basic routines to transfer information between elements within the computer 912 , such as during start - up , is stored in nonvolatile memory . by way of illustration , and not limitation , nonvolatile memory can include read only memory ( rom ). volatile memory includes random access memory ( ram ), which can act as external cache memory to facilitate processing . computer 912 also includes removable / non - removable , volatile / non - volatile computer storage media . fig9 illustrates , for example , mass storage 924 . mass storage 924 includes , but is not limited to , devices like a magnetic or optical disk drive , floppy disk drive , flash memory or memory stick . in addition , mass storage 924 can include storage media separately or in combination with other storage media . fig9 provides software application ( s ) 928 that act as an intermediary between users and / or other computers and the basic computer resources described in suitable operating environment 910 . such software application ( s ) 928 include one or both of system and application software . system software can include an operating system , which can be stored on mass storage 924 , that acts to control and allocate resources of the computer system 912 . application software takes advantage of the management of resources by system software through program modules and data stored on either or both of system memory 916 and mass storage 924 . the computer 912 also includes one or more interface components 926 that are communicatively coupled to the bus 918 and facilitate interaction with the computer 912 . by way of example , the interface component 926 can be a port ( e . g ., serial , parallel , pcmcia , usb , firewire . . . ) or an interface card ( e . g ., sound , video , network . . . ) or the like . the interface component 926 can receive input and provide output ( wired or wirelessly ). for instance , input can be received from devices including but not limited to , a pointing device such as a mouse , trackball , stylus , touch pad , keyboard , microphone , joystick , game pad , satellite dish , scanner , camera , other computer and the like . output can also be supplied by the computer 912 to output device ( s ) via interface component 926 . output devices can include displays ( e . g ., crt , lcd , plasma . . . ), speakers , printers and other computers , among other things . fig1 is a schematic block diagram of a sample - computing environment 1000 with which the subject innovation can interact . the system 1000 includes one or more client ( s ) 1010 . the client ( s ) 1010 can be hardware and / or software ( e . g ., threads , processes , computing devices ). the system 1000 also includes one or more server ( s ) 1030 . thus , system 1000 can correspond to a two - tier client server model or a multi - tier model ( e . g ., client , middle tier server , data server ), amongst other models . the server ( s ) 1030 can also be hardware and / or software ( e . g ., threads , processes , computing devices ). the servers 1030 can house threads to perform transformations by employing the aspects of the subject innovation , for example . one possible communication between a client 1010 and a server 1030 may be in the form of a data packet transmitted between two or more computer processes . the system 1000 includes a communication framework 1050 that can be employed to facilitate communications between the client ( s ) 1010 and the server ( s ) 1030 . the client ( s ) 1010 are operatively connected to one or more client data store ( s ) 1060 that can be employed to store information local to the client ( s ) 1010 . similarly , the server ( s ) 1030 are operatively connected to one or more server data store ( s ) 1040 that can be employed to store information local to the servers 1030 . for example , programs can be specified with type inference and / or binding options and compiled on a client 1010 . subsequently , the compiled program can be provided to one or more servers 1010 for distribution over communication framework 1050 to multiple clients 1010 . recipient clients can subsequently perform late binding at runtime . similarly , functionality associated with suggesting and / or determining options can be embodied in a plug - in , which can be downloaded from a server 1030 to a client 1010 for installation and use . what has been described above includes examples of aspects of the claimed subject matter . it is , of course , not possible to describe every conceivable combination of components or methodologies for purposes of describing the claimed subject matter , but one of ordinary skill in the art may recognize that many further combinations and permutations of the disclosed subject matter are possible . accordingly , the disclosed subject matter is intended to embrace all such alterations , modifications and variations that fall within the spirit and scope of the appended claims . furthermore , to the extent that the terms “ includes ,” “ has ” or “ having ” or variations in form thereof are used in either the detailed description or the claims , such terms are intended to be inclusive in a manner similar to the term “ comprising ” as “ comprising ” is interpreted when employed as a transitional word in a claim .