Visual Basic Project Analyzer 5.2 serial key or number

Table of Contents

This is an introduction to R (“GNU S”), a language and environment for statistical computing and graphics. R is similar to the award-winning¹ S system, which was developed at Bell Laboratories by John Chambers et al. It provides a wide variety of statistical and graphical techniques (linear and nonlinear modelling, statistical tests, time series analysis, classification, clustering, ).

This manual provides information on data types, programming elements, statistical modelling and graphics.

This manual is for R, version ().

Copyright © W. N. Venables
Copyright © W. N. Venables & D. M. Smith
Copyright © R. Gentleman & R. Ihaka
Copyright © , M. Maechler
Copyright © – R Core Team

Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies.

Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided that the entire resulting derived work is distributed under the terms of a permission notice identical to this one.

Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, except that this permission notice may be stated in a translation approved by the R Core Team.

Preface

This introduction to R is derived from an original set of notes describing the S and S-PLUS environments written in –2 by Bill Venables and David M. Smith when at the University of Adelaide. We have made a number of small changes to reflect differences between the R and S programs, and expanded some of the material.

We would like to extend warm thanks to Bill Venables (and David Smith) for granting permission to distribute this modified version of the notes in this way, and for being a supporter of R from way back.

Comments and corrections are always welcome. Please address email correspondence to R-help@manicapital.com

Suggestions to the reader

Most R novices will start with the introductory session in Appendix A. This should give some familiarity with the style of R sessions and more importantly some instant feedback on what actually happens.

Many users will come to R mainly for its graphical facilities. See Graphics, which can be read at almost any time and need not wait until all the preceding sections have been digested.

1 Introduction and preliminaries

The R environment

R is an integrated suite of software facilities for data manipulation, calculation and graphical display. Among other things it has

• an effective data handling and storage facility,
• a suite of operators for calculations on arrays, in particular matrices,
• a large, coherent, integrated collection of intermediate tools for data analysis,
• graphical facilities for data analysis and display either directly at the computer or on hardcopy, and
• a well developed, simple and effective programming language (called ‘S’) which includes conditionals, loops, user defined recursive functions and input and output facilities. (Indeed most of the system supplied functions are themselves written in the S language.)

The term “environment” is intended to characterize it as a fully planned and coherent system, rather than an incremental accretion of very specific and inflexible tools, as is frequently the case with other data analysis software.

R is very much a vehicle for newly developing methods of interactive data analysis. It has developed rapidly, and has been extended by a large collection of packages. However, most programs written in R are essentially ephemeral, written for a single piece of data analysis.

Related software and documentation

R can be regarded as an implementation of the S language which was developed at Bell Laboratories by Rick Becker, John Chambers and Allan Wilks, and also forms the basis of the S-PLUS systems.

The evolution of the S language is characterized by four books by John Chambers and coauthors. For R, the basic reference is The New S Language: A Programming Environment for Data Analysis and Graphics by Richard A. Becker, John M. Chambers and Allan R. Wilks. The new features of the release of S are covered in Statistical Models in S edited by John M. Chambers and Trevor J. Hastie. The formal methods and classes of the methods package are based on those described in Programming with Data by John M. Chambers. See References, for precise references.

There are now a number of books which describe how to use R for data analysis and statistics, and documentation for S/S-PLUS can typically be used with R, keeping the differences between the S implementations in mind. See What documentation exists for R? in The R statistical system FAQ.

R and statistics

Our introduction to the R environment did not mention statistics, yet many people use R as a statistics system. We prefer to think of it of an environment within which many classical and modern statistical techniques have been implemented. A few of these are built into the base R environment, but many are supplied as packages. There are about 25 packages supplied with R (called “standard” and “recommended” packages) and many more are available through the family of Internet sites (via manicapital.com) and elsewhere. More details on packages are given later (see Packages).

Most classical statistics and much of the latest methodology is available for use with R, but users may need to be prepared to do a little work to find it.

There is an important difference in philosophy between S (and hence R) and the other main statistical systems. In S a statistical analysis is normally done as a series of steps, with intermediate results being stored in objects. Thus whereas SAS and SPSS will give copious output from a regression or discriminant analysis, R will give minimal output and store the results in a fit object for subsequent interrogation by further R functions.

R and the window system

The most convenient way to use R is at a graphics workstation running a windowing system. This guide is aimed at users who have this facility. In particular we will occasionally refer to the use of R on an X window system although the vast bulk of what is said applies generally to any implementation of the R environment.

Most users will find it necessary to interact directly with the operating system on their computer from time to time. In this guide, we mainly discuss interaction with the operating system on UNIX machines. If you are running R under Windows or macOS you will need to make some small adjustments.

Setting up a workstation to take full advantage of the customizable features of R is a straightforward if somewhat tedious procedure, and will not be considered further here. Users in difficulty should seek local expert help.

Using R interactively

When you use the R program it issues a prompt when it expects input commands. The default prompt is ‘’, which on UNIX might be the same as the shell prompt, and so it may appear that nothing is happening. However, as we shall see, it is easy to change to a different R prompt if you wish. We will assume that the UNIX shell prompt is ‘’.

In using R under UNIX the suggested procedure for the first occasion is as follows:

1. Create a separate sub-directory, say , to hold data files on which you will use R for this problem. This will be the working directory whenever you use R for this particular problem.
2. Start the R program with the command
3. At this point R commands may be issued (see later).
4. To quit the R program the command is

   At this point you will be asked whether you want to save the data from your R session. On some systems this will bring up a dialog box, and on others you will receive a text prompt to which you can respond , or (a single letter abbreviation will do) to save the data before quitting, quit without saving, or return to the R session. Data which is saved will be available in future R sessions.

Further R sessions are simple.

1. Make the working directory and start the program as before:
2. Use the R program, terminating with the command at the end of the session.

To use R under Windows the procedure to follow is basically the same. Create a folder as the working directory, and set that in the field in your R shortcut. Then launch R by double clicking on the icon.

An introductory session

Readers wishing to get a feel for R at a computer before proceeding are strongly advised to work through the introductory session given in A sample session.

Getting help with functions and features

R has an inbuilt help facility similar to the facility of UNIX. To get more information on any specific named function, for example , the command is

An alternative is

For a feature specified by special characters, the argument must be enclosed in double or single quotes, making it a “character string”: This is also necessary for a few words with syntactic meaning including , and .

Either form of quote mark may be used to escape the other, as in the string . Our convention is to use double quote marks for preference.

On most R installations help is available in format by running

which will launch a Web browser that allows the help pages to be browsed with hyperlinks. On UNIX, subsequent help requests are sent to the -based help system. The ‘Search Engine and Keywords’ link in the page loaded by is particularly useful as it is contains a high-level concept list which searches though available functions. It can be a great way to get your bearings quickly and to understand the breadth of what R has to offer.

The command (alternatively ) allows searching for help in various ways. For example,

Try for details and more examples.

The examples on a help topic can normally be run by

Windows versions of R have other optional help systems: use

for further details.

R commands, case sensitivity, etc.

Technically R is an expression language with a very simple syntax. It is case sensitive as are most UNIX based packages, so and are different symbols and would refer to different variables. The set of symbols which can be used in R names depends on the operating system and country within which R is being run (technically on the locale in use). Normally all alphanumeric symbols are allowed² (and in some countries this includes accented letters) plus ‘’ and ‘’, with the restriction that a name must start with ‘’ or a letter, and if it starts with ‘’ the second character must not be a digit. Names are effectively unlimited in length.

Elementary commands consist of either expressions or assignments. If an expression is given as a command, it is evaluated, printed (unless specifically made invisible), and the value is lost. An assignment also evaluates an expression and passes the value to a variable but the result is not automatically printed.

Commands are separated either by a semi-colon (‘’), or by a newline. Elementary commands can be grouped together into one compound expression by braces (‘’ and ‘’). Comments can be put almost³ anywhere, starting with a hashmark (‘’), everything to the end of the line is a comment.

If a command is not complete at the end of a line, R will give a different prompt, by default

on second and subsequent lines and continue to read input until the command is syntactically complete. This prompt may be changed by the user. We will generally omit the continuation prompt and indicate continuation by simple indenting.

Command lines entered at the console are limited⁴ to about bytes (not characters).

Recall and correction of previous commands

Under many versions of UNIX and on Windows, R provides a mechanism for recalling and re-executing previous commands. The vertical arrow keys on the keyboard can be used to scroll forward and backward through a command history. Once a command is located in this way, the cursor can be moved within the command using the horizontal arrow keys, and characters can be removed with the key or added with the other keys. More details are provided later: see The command-line editor.

The recall and editing capabilities under UNIX are highly customizable. You can find out how to do this by reading the manual entry for the readline library.

Alternatively, the Emacs text editor provides more general support mechanisms (via , Emacs Speaks Statistics) for working interactively with R. See R and Emacs in The R statistical system FAQ.

Executing commands from or diverting output to a file

If commands⁵ are stored in an external file, say in the working directory , they may be executed at any time in an R session with the command

For Windows Source is also available on the File menu. The function ,

will divert all subsequent output from the console to an external file, . The command

restores it to the console once again.

Data permanency and removing objects

The entities that R creates and manipulates are known as objects. These may be variables, arrays of numbers, character strings, functions, or more general structures built from such components.

During an R session, objects are created and stored by name (we discuss this process in the next section). The R command

(alternatively, ) can be used to display the names of (most of) the objects which are currently stored within R. The collection of objects currently stored is called the workspace.

To remove objects the function is available:

All objects created during an R session can be stored permanently in a file for use in future R sessions. At the end of each R session you are given the opportunity to save all the currently available objects. If you indicate that you want to do this, the objects are written to a file called ⁶ in the current directory, and the command lines used in the session are saved to a file called .

When R is started at later time from the same directory it reloads the workspace from this file. At the same time the associated commands history is reloaded.

It is recommended that you should use separate working directories for analyses conducted with R. It is quite common for objects with names and to be created during an analysis. Names like this are often meaningful in the context of a single analysis, but it can be quite hard to decide what they might be when the several analyses have been conducted in the same directory.

2 Simple manipulations; numbers and vectors

Vectors and assignment

R operates on named data structures. The simplest such structure is the numeric vector, which is a single entity consisting of an ordered collection of numbers. To set up a vector named , say, consisting of five numbers, namely , , , and , use the R command

This is an assignment statement using the function which in this context can take an arbitrary number of vector arguments and whose value is a vector got by concatenating its arguments end to end.⁷

A number occurring by itself in an expression is taken as a vector of length one.

Notice that the assignment operator (‘’), which consists of the two characters ‘’ (“less than”) and ‘’ (“minus”) occurring strictly side-by-side and it ‘points’ to the object receiving the value of the expression. In most contexts the ‘’ operator can be used as an alternative.

Assignment can also be made using the function . An equivalent way of making the same assignment as above is with:

The usual operator, , can be thought of as a syntactic short-cut to this.

Assignments can also be made in the other direction, using the obvious change in the assignment operator. So the same assignment could be made using

If an expression is used as a complete command, the value is printed and lost⁸. So now if we were to use the command

the reciprocals of the five values would be printed at the terminal (and the value of , of course, unchanged).

The further assignment

would create a vector with 11 entries consisting of two copies of with a zero in the middle place.

Vector arithmetic

Vectors can be used in arithmetic expressions, in which case the operations are performed element by element. Vectors occurring in the same expression need not all be of the same length. If they are not, the value of the expression is a vector with the same length as the longest vector which occurs in the expression. Shorter vectors in the expression are recycled as often as need be (perhaps fractionally) until they match the length of the longest vector. In particular a constant is simply repeated. So with the above assignments the command

generates a new vector of length 11 constructed by adding together, element by element, repeated times, repeated just once, and repeated 11 times.

The elementary arithmetic operators are the usual , , , and for raising to a power. In addition all of the common arithmetic functions are available. , , , , , , and so on, all have their usual meaning. and select the largest and smallest elements of a vector respectively. is a function whose value is a vector of length two, namely . is the number of elements in , gives the total of the elements in , and their product.

Two statistical functions are which calculates the sample mean, which is the same as , and which gives

or sample variance. If the argument to is an n-by-p matrix the value is a p-by-p sample covariance matrix got by regarding the rows as independent p-variate sample vectors.

returns a vector of the same size as with the elements arranged in increasing order; however there are other more flexible sorting facilities available (see or which produce a permutation to do the sorting).

Note that and select the largest and smallest values in their arguments, even if they are given several vectors. The parallel maximum and minimum functions and return a vector (of length equal to their longest argument) that contains in each element the largest (smallest) element in that position in any of the input vectors.

For most purposes the user will not be concerned if the “numbers” in a numeric vector are integers, reals or even complex. Internally calculations are done as double precision real numbers, or double precision complex numbers if the input data are complex.

To work with complex numbers, supply an explicit complex part. Thus

will give and a warning, but

will do the computations as complex numbers.

Generating regular sequences

R has a number of facilities for generating commonly used sequences of numbers. For example is the vector . The colon operator has high priority within an expression, so, for example is the vector . Put and compare the sequences and .

The construction may be used to generate a sequence backwards.

The function is a more general facility for generating sequences. It has five arguments, only some of which may be specified in any one call. The first two arguments, if given, specify the beginning and end of the sequence, and if these are the only two arguments given the result is the same as the colon operator. That is is the same vector as .

Arguments to , and to many other R functions, can also be given in named form, in which case the order in which they appear is irrelevant. The first two arguments may be named and ; thus , and are all the same as . The next two arguments to may be named and , which specify a step size and a length for the sequence respectively. If neither of these is given, the default is assumed.

For example

generates in the vector . Similarly

generates the same vector in .

The fifth argument may be named , which is normally used as the only argument to create the sequence , or the empty sequence if the vector is empty (as it can be).

A related function is which can be used for replicating an object in various complicated ways. The simplest form is

which will put five copies of end-to-end in . Another useful version is

which repeats each element of five times before moving on to the next.

Logical vectors

As well as numerical vectors, R allows manipulation of logical quantities. The elements of a logical vector can have the values , , and (for “not available”, see below). The first two are often abbreviated as and , respectively. Note however that and are just variables which are set to and by default, but are not reserved words and hence can be overwritten by the user. Hence, you should always use and .

Logical vectors are generated by conditions. For example

sets as a vector of the same length as with values corresponding to elements of where the condition is not met and where it is.

The logical operators are , , , , for exact equality and for inequality. In addition if and are logical expressions, then is their intersection (“and”), is their union (“or”), and is the negation of .

Logical vectors may be used in ordinary arithmetic, in which case they are coerced into numeric vectors, becoming and becoming . However there are situations where logical vectors and their coerced numeric counterparts are not equivalent, for example see the next subsection.

Missing values

In some cases the components of a vector may not be completely known. When an element or value is “not available” or a “missing value” in the statistical sense, a place within a vector may be reserved for it by assigning it the special value . In general any operation on an becomes an . The motivation for this rule is simply that if the specification of an operation is incomplete, the result cannot be known and hence is not available.

The function gives a logical vector of the same size as with value if and only if the corresponding element in is .

Notice that the logical expression is quite different from since is not really a value but a marker for a quantity that is not available. Thus is a vector of the same length as all of whose values are as the logical expression itself is incomplete and hence undecidable.

Note that there is a second kind of “missing” values which are produced by numerical computation, the so-called Not a Number, , values. Examples are

or

which both give since the result cannot be defined sensibly.

In summary, is both for and values. To differentiate these, is only for s.

Missing values are sometimes printed as when character vectors are printed without quotes.

Character vectors

Character quantities and character vectors are used frequently in R, for example as plot labels. Where needed they are denoted by a sequence of characters delimited by the double quote character, e.g., , .

Character strings are entered using either matching double () or single () quotes, but are printed using double quotes (or sometimes without quotes). They use C-style escape sequences, using as the escape character, so is entered and printed as , and inside double quotes is entered as . Other useful escape sequences are , newline, , tab and , backspace—see for a full list.

Character vectors may be concatenated into a vector by the function; examples of their use will emerge frequently.

The function takes an arbitrary number of arguments and concatenates them one by one into character strings. Any numbers given among the arguments are coerced into character strings in the evident way, that is, in the same way they would be if they were printed. The arguments are by default separated in the result by a single blank character, but this can be changed by the named argument, , which changes it to , possibly empty.

For example

makes into the character vector

Note particularly that recycling of short lists takes place here too; thus is repeated 5 times to match the sequence . ⁹

Index vectors; selecting and modifying subsets of a data set

Subsets of the elements of a vector may be selected by appending to the name of the vector an index vector in square brackets. More generally any expression that evaluates to a vector may have subsets of its elements similarly selected by appending an index vector in square brackets immediately after the expression.

Such index vectors can be any of four distinct types.

1. A logical vector. In this case the index vector is recycled to the same length as the vector from which elements are to be selected. Values corresponding to in the index vector are selected and those corresponding to are omitted. For example
   > y <- x[!manicapital.com(x)]

   creates (or re-creates) an object which will contain the non-missing values of , in the same order. Note that if has missing values, will be shorter than . Also

   > (x+1)[(!manicapital.com(x)) & x>0] -> z

   creates an object and places in it the values of the vector for which the corresponding value in was both non-missing and positive.

2. A vector of positive integral quantities. In this case the values in the index vector must lie in the set {1, 2, …, }. The corresponding elements of the vector are selected and concatenated, in that order, in the result. The index vector can be of any length and the result is of the same length as the index vector. For example is the sixth component of and

   selects the first 10 elements of (assuming is not less than 10). Also

   > c("x","y")[rep(c(1,2,2,1), times=4)]

   (an admittedly unlikely thing to do) produces a character vector of length 16 consisting of repeated four times.

3. A vector of negative integral quantities. Such an index vector specifies the values to be excluded rather than included. Thus

   gives all but the first five elements of .

4. A vector of character strings. This possibility only applies where an object has a attribute to identify its components. In this case a sub-vector of the names vector may be used in the same way as the positive integral labels in item 2 further above.
   > fruit <- c(5, 10, 1, 20) > names(fruit) <- c("orange", "banana", "apple", "peach") > lunch <- fruit[c("apple","orange")]

   The advantage is that alphanumeric names are often easier to remember than numeric indices. This option is particularly useful in connection with data frames, as we shall see later.

An indexed expression can also appear on the receiving end of an assignment, in which case the assignment operation is performed only on those elements of the vector. The expression must be of the form as having an arbitrary expression in place of the vector name does not make much sense here.

For example

replaces any missing values in by zeros and

has the same effect as

Other types of objects

Vectors are the most important type of object in R, but there are several others which we will meet more formally in later sections.

• matrices or more generally arrays are multi-dimensional generalizations of vectors. In fact, they are vectors that can be indexed by two or more indices and will be printed in special ways. See Arrays and matrices.
• factors provide compact ways to handle categorical data. See Factors.
• lists are a general form of vector in which the various elements need not be of the same type, and are often themselves vectors or lists. Lists provide a convenient way to return the results of a statistical computation. See Lists.
• data frames are matrix-like structures, in which the columns can be of different types. Think of data frames as ‘data matrices’ with one row per observational unit but with (possibly) both numerical and categorical variables. Many experiments are best described by data frames: the treatments are categorical but the response is numeric. See Data frames.
• functions are themselves objects in R which can be stored in the project’s workspace. This provides a simple and convenient way to extend R. See Writing your own functions.

3 Objects, their modes and attributes

Intrinsic attributes: mode and length

The entities R operates on are technically known as objects. Examples are vectors of numeric (real) or complex values, vectors of logical values and vectors of character strings. These are known as “atomic” structures since their components are all of the same type, or mode, namely numeric¹⁰, complex, logical, character and raw.

Vectors must have their values all of the same mode. Thus any given vector must be unambiguously either logical, numeric, complex, character or raw. (The only apparent exception to this rule is the special “value” listed as for quantities not available, but in fact there are several types of ). Note that a vector can be empty and still have a mode. For example the empty character string vector is listed as and the empty numeric vector as .

R also operates on objects called lists, which are of mode list. These are ordered sequences of objects which individually can be of any mode. lists are known as “recursive” rather than atomic structures since their components can themselves be lists in their own right.

The other recursive structures are those of mode function and expression. Functions are the objects that form part of the R system along with similar user written functions, which we discuss in some detail later. Expressions as objects form an advanced part of R which will not be discussed in this guide, except indirectly when we discuss formulae used with modeling in R.

By the mode of an object we mean the basic type of its fundamental constituents. This is a special case of a “property” of an object. Another property of every object is its length. The functions and can be used to find out the mode and length of any defined structure ¹¹.

Further properties of an object are usually provided by , see Getting and setting attributes. Because of this, mode and length are also called “intrinsic attributes” of an object.

For example, if is a complex vector of length , then in an expression is the character string and is .

R caters for changes of mode almost anywhere it could be considered sensible to do so, (and a few where it might not be). For example with

we could put

after which is the character vector . A further coercion, or change of mode, reconstructs the numerical vector again:

Now and are the same.¹² There is a large collection of functions of the form for either coercion from one mode to another, or for investing an object with some other attribute it may not already possess. The reader should consult the different help files to become familiar with them.

Changing the length of an object

An “empty” object may still have a mode. For example

makes an empty vector structure of mode numeric. Similarly is a empty character vector, and so on. Once an object of any size has been created, new components may be added to it simply by giving it an index value outside its previous range. Thus

now makes a vector of length 3, (the first two components of which are at this point both ). This applies to any structure at all, provided the mode of the additional component(s) agrees with the mode of the object in the first place.

This automatic adjustment of lengths of an object is used often, for example in the function for input. (see The scan() function.)

Conversely to truncate the size of an object requires only an assignment to do so. Hence if is an object of length 10, then

makes it an object of length 5 consisting of just the former components with even index. (The old indices are not retained, of course.) We can then retain just the first three values by

and vectors can be extended (by missing values) in the same way.

Getting and setting attributes

The function returns a list of all the non-intrinsic attributes currently defined for that object. The function can be used to select a specific attribute. These functions are rarely used, except in rather special circumstances when some new attribute is being created for some particular purpose, for example to associate a creation date or an operator with an R object. The concept, however, is very important.

Some care should be exercised when assigning or deleting attributes since they are an integral part of the object system used in R.

When it is used on the left hand side of an assignment it can be used either to associate a new attribute with or to change an existing one. For example

allows R to treat as if it were a by matrix.

The class of an object

All objects in R have a class, reported by the function . For simple vectors this is just the mode, for example , , or , but , , and are other possible values.

A special attribute known as the class of the object is used to allow for an object-oriented style¹³ of programming in R. For example if an object has class , it will be printed in a certain way, the function will display it graphically in a certain way, and other so-called generic functions such as will react to it as an argument in a way sensitive to its class.

To remove temporarily the effects of class, use the function . For example if has the class then

will print it in data frame form, which is rather like a matrix, whereas

will print it as an ordinary list. Only in rather special situations do you need to use this facility, but one is when you are learning to come to terms with the idea of class and generic functions.

Generic functions and classes will be discussed further in Object orientation, but only briefly.

4 Ordered and unordered factors

A factor is a vector object used to specify a discrete classification (grouping) of the components of other vectors of the same length. R provides both ordered and unordered factors. While the “real” application of factors is with model formulae (see Contrasts), we here look at a specific example.

A specific example

Suppose, for example, we have a sample of 30 tax accountants from all the states and territories of Australia¹⁴ and their individual state of origin is specified by a character vector of state mnemonics as

Notice that in the case of a character vector, “sorted” means sorted in alphabetical order.

A factor is similarly created using the function:

The function handles factors slightly differently from other objects:

To find out the levels of a factor the function can be used.

The function and ragged arrays

To continue the previous example, suppose we have the incomes of the same tax accountants in another vector (in suitably large units of money)

To calculate the sample mean income for each state we can now use the special function :

giving a means vector with the components labelled by the levels

The function is used to apply a function, here , to each group of components of the first argument, here , defined by the levels of the second component, here ¹⁵, as if they were separate vector structures. The result is a structure of the same length as the levels attribute of the factor containing the results. The reader should consult the help document for more details.

Suppose further we needed to calculate the standard errors of the state income means. To do this we need to write an R function to calculate the standard error for any given vector. Since there is an builtin function to calculate the sample variance, such a function is a very simple one liner, specified by the assignment:

(Writing functions will be considered later in Writing your own functions. Note that R’s a builtin function is something different.) After this assignment, the standard errors are calculated by

and the values calculated are then

As an exercise you may care to find the usual 95% confidence limits for the state mean incomes. To do this you could use once more with the function to find the sample sizes, and the function to find the percentage points of the appropriate t-distributions. (You could also investigate R’s facilities for t-tests.)

The function

• 20 minutes to read

Developer Community | System Requirements | Compatibility | Distributable Code | License Terms | Blogs | Latest Release Known Issues

What's New in Visual Studio

Visual Studio Preview Releases

Visual Studio Blog

The Visual Studio Blog is the official source of product insight from the Visual Studio Engineering Team. You can find in-depth information about the Visual Studio releases in the following posts:

Visual Studio version Preview

released September 22,

In This Release of Visual Studio version Preview

Visual Studio version Preview 3

released September 14,

In This Release of Visual Studio version Preview 3

Visual Studio IDE

• Add your GitHub account using the familiar Visual Studio account management experience. The version control, integrated terminal and other features will then be able to leverage your account credentials to satisfy their GitHub authentication needs.

Git Productivity

• Create a new branch from an Azure DevOps work item

• Open a Git repository from a list of your local repositories in the Git menu

• The default source control provider is now Git instead of TFVC, which you can change from Tools - Options - Source Control

C++

• C++20 Coroutines are now supported under /std:c++latest and the
• IntelliSense now provides support for C++20
• Our STL now has support for the majority of C++20 Ranges. You can track our progress on our ranges GitHub issue.
• Conditionally trivial special member functions are now supported in MSVC.
• C11 and C17 are now supported under the /std:c11 and /std:c17 switches.
• Additional STL improvements include full support for std::atomic_ref, std::midpoint and std::lerp and std::execution::unseq, optimizations for std::reverse_copy, and more. You can find all the updates in our Changelog.
• We have upgraded the version of CMake shipped with Visual Studio to CMake
• Our code analysis tools now support the SARIF standard: the industry standard static analysis log format. You can read more about the format SARIF format in the official specification.
• Missing build tools in Linux projects will now issue a warning in the toolbar and a clear description of the missing tools in the error list.
• You can now debug Linux core dumps on a remote Linux system or WSL directly from Visual Studio.
• For C++ Doxygen comment generation, we added additional comment style options (/*! and //!).
• Additional vcpkg announcements
• As-you-type linter and fixups are now available in Visual Studio. Configure using Tools->Options->Text Editor->C/C++->CodeStyle->Linter + Fixups.

.NET Productivity

• .NET compiler platform (Roslyn) analyzers inspect your C# or Visual Basic code for security, performance, design, and other issues. Starting in .NET , these analyzers are included with the .NET SDK. Code analysis is enabled, by default, for projects that target .NET or later. You can enable code analysis on projects that target earlier .NET versions by setting the EnableNETAnalyzers property to true. You can disable code analysis for your project by setting EnableNETAnalyzers to false. You can also use the Project Properties window to enable/disable .NET analyzers. To access the Project Properties window right-click on a project within Solution Explorer and select Properties. Next, select the Code Analysis tab where you can either select or clear the checkbox to Enable .NET analyzers.

• There is now a refactoring that introduces the new C# 9 pattern matching syntax when a suppression operator is present. Place your cursor on the suppression operator. Press (Ctrl+.) to trigger the Quick Actions and Refactorings menu. Select Use pattern matching.

• There is now an inline method refactoring that helps you replace usages of a static, instance, and extension method within a single statement body with an option to remove the original method declaration. Place your cursor on the usage of the method. Press (Ctrl+.) to trigger the Quick Actions and Refactorings menu. Next select from one of the following options:

Select Inline to remove the inline method declaration:

Select Inline and keep to preserve the original method declaration:

• Creating a new C# or Visual Basic file from a template respects EditorConfig code style settings. The following code styles will automatically get applied when creating new files: file headers, sort using directives, and place using directives inside/outside namespaces.

Debugger

.NET Core Linux core dump debugging support

Debugging managed Linux core dumps on Windows has been difficult realize until now, it would usually mean setting up another Linux environment that exactly mirrored production and then installing a set of tools for the analysis. Thankfully with Visual Studio preview 3 you can simply drag and drop a managed Linux core dump directly into your IDE and immediately start debugging.

.NET and .NET Core Auto Analysis

Asynchronous (async) programming has been around for several years on the .NET platform but has historically been difficult to do well. We have introduced and managed memory dump analyzer that helps identify the follwoing ant-patterns:

• Sync-over-Async
• Async Void

.NET and .NET Core memory hot path auto analysis

This allows customers to intuitively view the dominating object types in their memory heap by using flame annotations in the Diagnositcs Memory Tool window.

XAML Tools (WPF, UWP & manicapital.com)

XAML Hot Reload Settings moved to "Debugging > Hot Reload": In this release we have completed the XAML Hot Reload settings migration for manicapital.com to the new location under “Debugging > Hot Reload”. This means customers who previously found the manicapital.com XAML Hot Reload settings under “Xamarin > Hot Reload” will now find them in the new dialog as shown below. All settings have been migrated so all of your existing selections should still match what they were in the previous location.

Toolbox population from unreferenced NuGet packages: In this release we have added support for TargetFrameworkMoniker-specific manicapital.com files when populating Toolbox with controls from unreferenced NuGet packages. So, for example, your package could expose different sets of controls to .NET Core and .NET projects.

Improving MVVM Support: When authoring a XAML document, you can set d:DataContext to get accurate binding IntelliSense for the XAML document. In the past, manually specifying the data-context type was cumbersome; you had to leave the XAML document, find the desired view-model type, copy and paste its namespace and name into the d:DataContext declaration. In this release we’re introducing a new feature that allows you to quickly declare a d:DataContext via a lightbulb that suggests possible view-model candidates.

Experimental Razor editor updates

The new experimental Razor editor now supports the following Razor editing features:

• Rename Razor components in markup from .razor files.

To enable the experimental Razor editor, go to Tools > Options > Environment > Preview Features, select Enable experimental Razor editor, and then restart Visual Studio.

From Developer Community

Visual Studio version Preview

released August 31,

In This Release of Visual Studio version Preview

• Fixed a bug causing Visual Studio to crash or stop responding when closing or navigating away from manicapital.com Core solutions.

Visual Studio version Preview 2

released August 25,

In This Release of Visual Studio version Preview 2

Git Productivity

• Single click to switch between branch histories in the Git Repository window
• Access the new Git windows in read-only mode as a guest in a Live Share session
• View and select from a list of solutions in your repo in Solution Explorer after opening a repository

Experimental Razor editor updates

The new experimental Razor editor now supports the following Razor editing features:

• Go-to-definition on Blazor component tag names
• C# formatting when typing in pure C# blocks
• C# hover colorization
• C# completion toolitip colorization

To enable the experimental Razor editor, go to Tools > Options > Environment > Preview Features, select Enable experimental Razor editor, and then restart Visual Studio.

.NET Productivity

• There is now C# and Visual Basic support for inline parameter name hints that inserts adornments for literals, casted literals, and object instantiations prior to each argument in function calls. You will first need to turn this option on in Tools > Options > Text Editor > C# or Basic > Advanced and select Display inline parameter name hints (experimental). The inline parameter name hints will then appear in C# or Visual Basic file.

• You can now extract members from a selected class to a new base class with the new Extract Base Class refactoring. Place your cursor on either the class name or a highlighted member. Press (Ctrl+.) to trigger the Quick Actions and Refactorings menu. Select Pull member(s) up to new base class. The new Extract Base Class dialog will open where you can specify the name for the base class and location of where it should be placed. You can select the members that you want to transfer to the new base class and choose to make the members abstract by selecting the checkbox in the Make Abstract column.

Once you select Ok you will see the new base class added along with its members.

For C#, select Convert to :

For Visual Basic, select Convert to :

• Code cleanup has new configuration options that can apply formatting and file header preferences set in your EditorConfig file across a single file or an entire solution.

XAML Tools (WPF, UWP & manicapital.com)

• XAML Hot Reload Settings moved to “Debugging > Hot Reload” – as part of a bigger effort that will be completed across multiple Preview release, we’re starting to consolidate the XAML Hot Reload settings across WPF, UWP and eventually manicapital.com into a unified settings location. In this release we’ve started this process by moving the existing desktop settings out of the “Debugging > General > Enable UI Debugging Tools for XAML” and into a new location under “Debugging > Hot Reload”. No settings will be changed during this migration so all your existing choices will continue to stay in effect. Also, for the first time ever we’re enabling the ability to disable/enable XAML Hot Reload support per-platform, meaning you can disable these experiences for WPF, UWP or both.

• manicapital.com “changes only” XAML Hot Reload now supports UWP – in this release we begin to rollout support for a highly requested feature that enables the new changes only XAML Hot Reload support in manicapital.com Projects when targeting UWP. Please note this feature is still in development, and while editing XAML will now trigger updates in the running app other features such as in-app toolbar (element selection, etc.) are not yet fully implemented and can have unpredictable behavior.

Top Issues Fixed in Visual Studio version Preview 2

From Developer Community

Visual Studio version Preview 1

released August 05,

In This Release of Visual Studio version Preview 1

Git Productivity

• Open the Git Repository and Git Changes windows through the View menu
• Modify the history view and search for commits through a tool bar in the Git Repository window
• Fetch, pull, and push from the incoming and outgoing commits sections in the history graph of a branch
• Get prompted to create a pull request after pushing a branch to your remote
• View branch names in the merge and rebase commands in the branch list context menu
• Access Git commands through the context menu in Solution Explorer and the Editor
• Observe clone progress through a new modal dialog with the option to move the process to the background

C++

Razor

• Go-to-definition/implementation for Razor, including closed files
• Find All References in closed Razor files
• Improved Razor editing preformance and stability for large projects and solutions

.NET Productivity

• There is now a code fix to remove the keyword where the argument should not be passed by reference. Place your cursor on the error. Press (Ctrl+.) to trigger the Quick Actions and Refactorings menu. Select Remove ‘in’ keyword.

• There is now a refactoring that introduces the new C#9 pattern combinators. Along with the pattern matching suggestions such as converting to use where applicable, this code fix also suggests the pattern combinators , and when matching multiple different patterns and negating. Place your cursor inside the statement. Press (Ctrl+.) to trigger the Quick Actions and Refactorings menu. Select Use pattern matching.

• There is now a code fix to make a class abstract when you are trying to write an abstract method in a class that is not abstract. Place your cursor on the method error. Press (Ctrl+.) to trigger the Quick Actions and Refactorings menu. Select Make class ‘abstract’.

• In Preview1 we added IntelliSense completion in DateTime and TimeSpan string literals. In this release, this completion list automatically appears when the first quote is typed. In the past, it was required to type (Ctrl+space) to view this completion list. Place your cursor inside the DateTime or TimeSpan string literal and type the first double quote. You will then see completion options and an explanation as to what each character means. Both the date time format and an example will be provided.

• There is now a code fix to remove unnecessary pragma suppressions and unnecessary . Place your cursor on the pragma warning or the . Press (Ctrl+.) to trigger the Quick Actions and Refactorings menu. Select Remove unnecessary suppression.

• Rename and Find All References now understands references to symbols within the target string of global suppressions.

• Visual Basic had multiple ways of passing parameters, ByVal and ByRef, and for a long time ByVal has been optional. We now fade ByVal to say it's not necessary along with a code fix to remove the unnecessary ByVal. Place your cursor on the ByVal keyword. Press (Ctrl+.) to trigger the Quick Actions and Refactorings menu. Select ‘ByVal’ keyword is unnecessary and can be removed.

• There is now interactive window support for multiple runtimes, such as .NET Framework and .NET Core.

• There is a new RegisterAdditionalFileAction API that allows analyzer authors to create an analyzer for additional files.

XAML Tools (WPF, UWP & manicapital.com)

XAML Designer Suggested Actions enables easy access to common properties when a control is selected within the XAML Designer. To use this feature first enable it through Options > Preview Features > XAML Suggested Actions. Once enabled click on a supported control and use the lightbulb to expand and interact with the Suggestion Actions UI. In this release supported controls include:

• For UWP: Border, Button, Canvas, CheckBox, ComboBox, Grid, HyperlinkButton, Image, ListBox, ListView, NavigationView, RadioButton, Slider, StackPanel, TextBlock
• For WPF: Border, Button, Canvas, CheckBox, ComboBox, Grid, Image, Label, ListBox, ListView, StackPanel, TextBlock, TextBox.

This feature is available for UWP, WPF .NET Core and WPF .NET Framework (with enabled “New WPF XAML Designer for .NET Framework” feature flag) applications and doesn’t support extensibility, nor is it feature complete.

• XAML Suggested Actions - Extensibility: We've also recently introduced extensibility for 'Suggested Actions'. Now you will be able to customize and build your own suggestion dialog for your controls. For more details see our documentation in GitHub

The New WPF XAML Designer for .NET Framework Projects is now available for early preview. This brings the same designer and extensibility support available for WPF .NET Core developers to WPF .NET Framework. Benefits of this improved XAML designer includes faster load performance, bit configuration support (custom controls would load normally just like they do in x86 configuration), improved stability and new features such as Suggested Actions.

To get started, go to Options > Preview Features, select “New WPF XAML Designer for .NET Framework” and restart Visual Studio. This feature is only available in the Preview channel for early testing; its final release details have not yet been determined. We encourage all WPF .NET Framework customers to give this designer a try and report any issues you encounter through the VS Feedback Hub.

XAML Binding Failures diagnostic improvements

In this release we continue to test a new features that makes becoming aware of and seeing the details of XAML binding failures easier, these improvements include:

• New XAML Binding failure indicator icon in the in-app toolbar experience for WPF and UWP developers. This icon will change red if at least one binding fails and highlighting it will show you the total number of failed bindings in the tooltip. Clicking the icon will take you to the new XAML Binding Failures panel
• New XAML Binding Failures panel that takes the binding failures that were previously only available in the Output window and makes them easy to review in the new dedicated experience with features such as sorting, searching and grouping of similar errors. This panel works for WPF, UWP and manicapital.com projects (note: requires Xamarin version pre3 or higher)

This feature is still in development and is only available if enabled by customers. To enable this experience, go to Options > Environment > Preview Features and enable “XAML Binding Failure Window”.

Known Limitations: Clicking on binding failures in the panel does not yet navigate to code. Also attaching to a running process will not work, you must F5 into the debug experience for this experience.

Editor

• In this release, the legacy Find in Files experience has been deprecated and all users are being moved to the new experience. The Editor team is working with folks who leave feedback in Developer Community who are experiencing issues with the modern Find in Files experience.

Top Issues Fixed in Visual Studio version Preview 1

From Developer Community

Known Issues

See all open issues and available workarounds in Visual Studio by following the below link.

Feedback and suggestions

We would love to hear from you! For issues, let us know through the Report a Problem option in the upper right-hand corner of either the installer or the Visual Studio IDE itself. The icon is located in the upper right-hand corner. You can make a product suggestion or track your issues in the Visual Studio Developer Community, where you can ask questions, find answers, and propose new features. You can also get free installation help through our Live Chat support.

Blogs

Take advantage of the insights and recommendations available in the Developer Tools Blogs site to keep you up-to-date on all new releases and include deep dive posts on a broad range of features.

Visual Studio Release Notes History

For more information relating to past versions of Visual Studio , see the Visual Studio Release Notes History page.

To use Unity, you need an activated licence. To see what type of licences are available, go to the Unity Store.

If you already have the Unity Editor installed, you can activate your new license by following the instructions in the managing your license documentation page.

If you’ve purchased a license and haven’t used Unity yet, you can activate your licence through the Unity Hub, which you can download from the Download Unity web page.

Note: To activate a Unity Plus or Pro license, the Hub asks you for your license and serial number information. If you purchased a single license, Unity emails the license information and serial number to the purchaser.

If you don’t know your Unity license information, speak to the Owner of your license. Owners can assign a seat to you via the Organization, or you can contact Unity Customer Service.

Activate your licence

Open the Unity Hub and sign into your Unity ID via the account icon in the top right of the window. If you don’t have an existing Unity account, you can create one by visiting the Unity ID website. Once you have logged in, click the cog icon in the top right hand corner and navigate to the License Management tab.

Click Activate New License and the option to choose the type of license to activate (Unity Personal, Unity Plus or Pro) appears.

To activate a Unity Personal licence, select the Unity Personal option and select either of the options which best describes your current situation and click Done.

To activate a Unity Plus or Pro licence, select the Unity Plus or Pro option and enter your serial key.

The serial key is sent to the email address attached to your Unity ID. You need to enter the key in the exact format that it appears in the email. It will look something like this:

Note: To activate an educational license select the Unity Plus or Pro option.

When your license activates successfully, Unity displays a “Your license was activated successfully” message. Click Start Using Unity to continue, then click Preferences to create a new Project or load an existing Project.

Troubleshooting

If you encounter any error codes or other problems during the activation process, they might be caused by the following issues:

• Your machine might not have internet access. In this case, you might need to manually activate your licence. You can find instructions on how to do this in the Manual Activation documentation.
• Your firewall/proxy or internet security settings might be blocking Unity from sending and receiving data about your license file.
• You might not have the correct read/write privileges on your machine to save the license file. To solve this you might need to give these permissions to the user account your are using to attempt the licence activation. This is a particularly common problem in workplaces and schools; contact your IT administrator to find out whether there are restrictions in place that might prevent the activation process from working correctly.
• Major operating system changes or updates might affect your machine’s ID, which causes your licence to stop recognizing your machine. See the Unity Knowledge Base article I Have Just Updated/Installed A New Operating System. Why Is My License Failing To Activate?
• Unity’s license servers might be down. See the Unity Cloud System Status Page for status updates on the all Unity servers.

For information on all potential errors and how to resolve them, see the Unity Support Knowledge Base. If you can’t find a solution, contact Unity Customer Services for more assistance.

Note: If you leave feedback on this page, it does not notify our Support Team. If you encounter any problems during this process, send a support ticket to Unity Customer Services.