A simple program on how to make a login system in Visual Basic 2010.
What's New in Visual Basic 2010
Auto-Implemented Properties
Auto-implemented properties provide a shortened syntax that enables you to quickly specify a property of a class without having to write code to Get and Set the property.
Collection Initializers
Collection initializers provide a shortened syntax that enables you to create a collection and populate it with an initial set of values. Collection initializers are useful when you are creating a collection from a set of known values, for example, a list of menu options or categories.
Implicit Line Continuation
In many cases, implicit line continuation enables you to continue a statement on the next consecutive line without using the underscore character (_).
Multiline Lambda Expressions and Subroutines
Lambda expression support has been expanded to support subroutines in addition to multiline lambda functions and subroutines.
New Command-Line Option for Specifying a Language Version
The /langversion command-line option causes the compiler to accept only syntax that is valid in the specified version of Visual Basic.
Type Equivalence Support
You can now deploy an application that has embedded type information instead of type information that is imported from a Primary Interop Assembly (PIA). With embedded type information, your application can use types in a runtime without requiring a reference to the runtime assembly. If various versions of the runtime assembly are published, the application that contains the embedded type information can work with the various versions without having to be recompiled.
Dynamic Support
Visual Basic binds to objects from dynamic languages such as IronPython and IronRuby.
Covariance and Contravariance
Covariance enables you to use a more derived type than that specified by the generic parameter, whereas contravariance enables you to use a less derived type. This allows for implicit conversion of classes that implement variant interfaces and provides more flexibility for matching method signatures with variant delegate types. You can create variant interfaces and delegates by using the new In and Out language keywords. The .NET Framework also introduces variance support for several existing generic interfaces and delegates, including the IEnumerable<(Of <(T>)>) interface and the Func<(Of <(TResult>)>) and Action<(Of <(T>)>) delegates.
Integrated Development Environment
The following sections describe enhancements to the Visual Studio integrated development environment (IDE).
Navigate To
You can use the Navigate To feature to search for a symbol or file in source code.
Highlighting References
This enhancement enables you to highlight all instances of a particular symbol in a document by clicking that symbol. To navigate between references, you can use CTRL+SHIFT+DOWN ARROW or CTRL+SHIFT+UP ARROW.
Generate From Usage
The Generate From Usage feature enables you to use classes and members before you define them. You can generate a stub for any class, constructor, method, property, field, or enum that you want to use but have not yet defined. You can generate new types and members without leaving your current location in code. This minimizes interruption to your workflow. Generate From Usage supports programming styles such as test-driven development.
IntelliSense Consume-First Mode
IntelliSense now provides two alternatives for IntelliSense statement completion: standard mode and consume-first mode. Consume-first mode is used when classes and members are used before they are defined.
FORTRAN (Formula Translation) was the first high level programming language (software) invented by John Backus for IBM in 1954, and released commercially in 1957. Fortran is still used today for programming scientific and mathematical applications. Fortran began as a digital code interpreter for the IBM 701 and was originally named Speedcoding. John Backus wanted a programming language that was closer in appearance to human language, which is the definition of a high level language, other high language programs include Ada, Algol, BASIC, COBOL, C, C++, LISP, Pascal, and Prolog.
The Pascal language was named for Blaise Pascal, a French mathematician who was a pioneer in computer development history. In 1641, at the age of eighteen, Pascal constructed the first arithmetical machine, arguably the first computer. He would improve upon the instrument eight years later. In 1650, Pascal left the world of geometry and physics, and shifted his focus towards religious studies, or, as Pascal wrote, to "contemplate the greatness and the misery of man." Pascal died in Paris on August 19, 1662.
The earliest computers were programmed in machine code and assembly. This type of programming is tedious and error prone, as well as extremely difficult to understand and modify. Programming is a time-consuming and expensive process. High level languages were developed to resolve this problem. High level languages provide a set of instructions that read like English, but can be translated by a program called a compiler into machine code. Pascal is one such language.
Other high level languages developed in the early years of the computer were FORTRAN (1957), COBOL (1959), ALGOL (1960), APL (1962), BASIC (1964), C (1972) and Ada (1983), to name a few. One problem with many of the early languages (e.g., FORTRAN and BASIC) was the heavy dependency on the use of "goto" instructions. "Goto" instructions tell the computer to jump from one step to another, enabling the computer to skip steps or to go back to repeat earlier steps. This type of sporadic branching increases the difficulty of debugging code. Additionally, languages like COBOL were designed with over-elaborate definitions, weak data structures support, and a lack of flexibility, making programs tedious to code and difficult to enhance.
Niklaus Wirth completed development of the original Pascal programming language in 1970. He based it upon the block structured style of the Algol programming language. There were two original goals for Pascal. According to the Pascal Standard (ISO 7185), these goals were to a) make available a language suitable for teaching programming as a systematic discipline based on fundamental concepts clearly and naturally reflected by the language, and b) to define a language whose implementations could be both reliable and efficient on then-available computers.
Pascal went far beyond its original design goals, with commercial use of the language often exceeding academic interest. Pascal provides rich data structures, including both the enumerated and record data types, and defined with a pleasing and powerful clarity. It provided an orthogonal and recursive approach to data structures, with arrays of arrays, arrays of records, records containing arrays, files of records, files of arrays, files of records containing arrays of records, and so on. Pascal's popularity exploded in the 1970's, as it was used in writing both system and application software. For this reason, the International Standards committee decided that a formal standard was needed to promote the stability of the Pascal language (the ISO 7185 Pascal Standard was originally published in 1983). By the end of the 1970's, more than 80 computer systems had Pascal implementations in use.
One of the more popular Pascal's of the 1970's and early 1980's was UCSD Pascal on the UCSD P-System operating system. The UCSD P-System was developed at the Institute for Information Studies at the University of California - San Diego, under the direction of Kenneth Bowles. In fact, the P-System operating system itself was written in UCSD Pascal. As Wirth writes in his 1985 Turing Award Lecture, From Programming Language Design To Computer Construction, "But Pascal gained truly widespread recognition only after Ken Bowles in San Diego recognized that the P-system could well be implemented on the novel microcomputers. His efforts to develop a suitable environment with integrated compiler, filer, editor, and debugger caused a breakthrough: Pascal became available to thousands of new computer users who were not burdened with acquired habits or stifled by the urge to stay compatible with software of the past."
In 1978, Richard Gleaves and Mark Allen, working on-campus in San Diego, used UCSD Pascal to develop the 6502 interpreter which became the basis for Apple Pascal. By the 1980's, Pascal was used by most universities to teach programming, while still invading the commercial markets. It became so popular that even FORTRAN began to change, taking advantage of Pascal's innovations.
Due to the strong popularity of the Pascal language in system and application software development, and in response to the many cited drawbacks of the original Pascal implementation, an Extended Pascal evolved to address the needs of commercial development. In 1990, the ISO 10206 Extended Pascal Standard was published to support this new version of the language.
In addition to Extended Pascal, in 1986, Apple Computer released the first Object Pascal implementation, a version of its Apple Pascal that supported object-oriented programming. In 1993, the Pascal Standards Committee published an Object-Oriented Extensions to Pascal technical report which was based upon Apple's Object Pascal implementation.
An assembly language is a low-level way to instruct a computer to carry out a task. Computers do not inherently understand instructions from people. At the most basic level, computers understand instructions in binary language, that is, sequences of zeroes and ones. Binary language or machine language is extremely cumbersome to program in, however. Assembly language was invented as a symbolic representation of the underlying sequences of zeroes and ones.
Suppose we were to program a game which, upon a certain action, awards the player with five points. The computer keeps the score in a certain location; the locations are either a storage place within the CPU, called a "register," or in some space in the memory. The computer understands locations and low-level actions called operations. So if the score is kept at register RA, then it understands the command, 0101 1100 0000 0101, where the first four numbers indicate the operation ADD, the next four indicate the register RA, and the last eight indicate the number 5.
Originally computers had to be coded this way; machine language is slow, error-prone, and it can be very hard for one person to understand what another person is trying to code. So computer programmers created assembly language in which the operations, locations, numbers, etc., can be better understood. Thus the equivalent command for the above example would be ADD RA 5. In this hypothetical example, mnemonics are used for the ADD operation and the register RA, and the number 5 is written in digits.
A program called an assembler converts assembly language code into the underlying machine language. In earlier days, even this conversion used up expensive computing resources, so the operation codes, opcodes in short, such as Subtract were abbreviated as SUB, Copy-Move was abbreviated as MOV and in some cases even ADD was abbreviated to A.
Assembly language is mostly a thin layer above the machine structure. Hence the opcodes, registers, and the whole language is very much dependent on the CPU family. So, the Intel x86 family has opcodes such as MOV, MOVSX, and MOVZX, whereas IBM 360 has opcodes such as MVI, MVC, MVZ. When designing a computer or CPU, the designers specify the machine language including the opcodes.
Programmers soon moved to "high-level" languages such as COBOL, Pascal, C++, and SQL. Compilers convert code written in these languages into machine language. Assembly language code is still used for specialized CPUs, however, or for ensuring speed from game consoles to car systems.
