This program will make the assumption that you have installed an integrated development environment (IDE) or code editor and that you are familiar with creating a simple C# file. If you do not have an IDE installed and configured, never fear: our article how to install and configure Microsoft Visual Code can walk you through the steps in under five minutes.

One other note: it does not matter which code editor you choose. Again, if you are having trouble choosing, you can read our picks at our article Best IDEs for .Net Developers.

Creating Your First C# Program

As with all programming languages, it is customary to create your first application and call it “Hello, World!” as a way of sort of introducing yourself to the world. It is akin to learning how to play “Smoke on the Water” on guitar – it is a rite of passage. However, we are going to think bigger and introduce ourselves to the universe at large instead. Dream big!

The Hello, World program serves a single purpose: print some text to the user’s screen. It does not get simpler than that. In C#, printing text to a user’s screen is accomplished using what is known as a type to represent the console window. This console type, further, has a method called writeline that actually prints the text we tell it to print to the console.

Here is how to write your first C# program. Type the following code into your .Net IDE and the Run it once finished:

Console.WriteLine("Hello, Universe!");

When you run that C# example code, the following output should appear in the console:

Hello, Universe!

Congrats, you have created your first ever computer program using the console type and the writeline method!

Read: Commenting Best Practices in C#

Introduction to C# Variables

Writing a single line of code to print a single line of text to the console is great and all, but the real power of C# – and any programming language really – is the ability to store and retain information for later use and manipulation. One of the ways C# stores information is through an object known as a variable. The best way to think of a variable is to imagine a box. You can put something in that box, remove the thing from the box, and place it back inside the box. You can also replace the thing in the box with something else if you so choose. You can only, however, hold one thing at a time in this particular box.

Variables have types that determine what sort of information they will hold. One type of data is known as a string and its purpose is to hold text values, which can consist of any type of character you type into it. The caveat here is that if you enter a number or numeric digit into a string variable, it will be treated as a letter and not a number, so you will not be able to perform math on it or use it in the same way you would traditionally use numbers.

One last note: variables are called variables because their data can vary.

Read: C# Data Types Explained

Here is how we can use a few string variables to print multiple lines of text to the console using C#:

string firstName = "James";
string lastName = "Payne";

Console.WriteLine(firstName);
Console.WriteLine(lastName);

Here, we have created two string variables – firstName and lastName – which carry a person’s first and last name, respectively. We then pass – or give – those variables to Console.WriteLine to print the value of the variables to the console. This will result in the following output when you run the program:

James
Payne

At any time, we can choose to add a different value to our variables. Consider if I got a name change. Observe the following code:

string firstName = "James";
string lastName = "Payne";

Console.WriteLine(firstName);
Console.WriteLine(lastName);

firstName = "Maximus");

Console.WriteLine(firstName);
Console.WriteLine(lastName);

A few things to note about this code. First, as before, we created two string variables to store our first and last name values. Then we printed them out to the console. Next, we changed the value of firstName to “Maximus” and reprinted the first and last name values. This would give us the following result:

James
Payne
Maximus
Payne

Since we changed the value in firstName, going forward it will now read “Maximus” versus “James”. One more note about this sample C# sharp code: we did not define the firstName variable when we changed its value to “Maximus” – it is alread assigned – or initialized as a string type, so we no longer need to tell C# what kind of data that variable holds. Indeed, if we did try to create it as a string again, it would result in an error.

We can also mix our variables in with other text to append it to the end of a sentence, as an example. Consider this code:

string firstName = "Maximus";
string lastName = "Payne";

Console.WriteLine("Behold, I am " + firstName + " " + lastName + "!");

Here, we print some text using Console.WriteLine and then append our two variables using the + operator. Note that we also append a space by using ” ” and add an exclamation point (!) by adding “!” to the line as well. Here is the results when we run this sample code:

Behold, I am Maximus Payne!

Truly, a sight to behold.

Read: Working with Strings in C#

Other C# Programming Tips

That is all the time we have for this round. Check back often as we will be continuing our series on C# programming for beginners!

Read more C# programming tutorials and development guides.

The post C# Sharp for Beginners appeared first on CodeGuru.

We will be looking at some of the best code debugging tools for C# in 2021 in today’s article. Options include Integrated Development Environments (IDEs) or code editors, and some are simply code debuggers. However, before we go any further, a quick note: the developer tools listed below are not in any particular order; they are all effective software that can help you fix errors in your applications.

Types of Code Debugging Tools for C# and .Net

There are many tools that can assist a developer in finding bugs and errors in their code. Some typical types of bugs a programmer might encounter include:

• Crashes
• Hangs or lagging
• Memory errors
• Failed server requests
• Logic bugs
• Caching issues
• Network lag
• Performance issues

To fix these types of bugs, whether you are debugging code in development or production, a coder might employ any number of code debugging tools, including:

• Decompilers
• Application Performance monitors
• Event viewers
• Dump files
• Debuggers
• Code refactoring tools
• Memory profilers
• Performance profilers
• Error and bug monitoring tools

Code Debuggers for C# and .Net

Here are our picks for the top code debugging tools for C#, .Net, and other Microsoft-related programming languages.

Microsoft Visual Studio for Code Debugging

When developers think of Visual Studio from Microsoft, it is usually as an integrated development environment or IDE. That is with good reason, as Visual Studio is probably the most popular code editor for developers, regardless of programming language. It is a powerful tool for software development that can become even more powerful thanks to third-party extensions available via places such as the Visual Studio Marketplace. Covering the majority of popular programming languages, including JavaScript, C#, Python, and Java – the IDE also has a robust code debugger built-in, not to mention the many extensions for code debugging that you can install.

Microsoft Visual Studio includes the following features and benefits for debugging C# and .Net code:

• Interactive debugging tools
• Performance profiler
• Cloud debugger via Cloud Explorer
• Memory profiler
• IntelliTrace debugging
• Exception options and tooltips
• Graphic and shaders debugger for video game developers
• Step-through code and set breakpoints
• Debugging tools built into the IDE, giving you a full software development suite of tools in one spot

How Much Does Visual Studio Cost?

You may be asking how much does Visual Studio costs? There are several different options for purchasing the Visual Studio IDE and code debugger.

• For starters, it is included in some versions of Microsoft Office 365.
• For individuals, the full-featured Visual Studio Community is available for free on PC and Mac.
• For businesses with five or more developers, subscriptions start at $45 per month for Professional and $250 per month for Enterprise.
• For Enterprise, visit Visual Studio Enterprise Pricing. 

Visual Studio Code for Code Debugging in C# and .Net

Not to be confused with Visual Studio, Visual Studio Code is Microsoft’s Open-Source IDE. Just about as popular as its big brother, VS Code is also a powerful code editor with built-in code debugging tools as well. The IDE supports a wide breadth of programming languages and is much beloved amongst the software development community – and with good reason. First of all, it has a great price point (it is free) and, like Visual Studio, VS Code is highly extensible thanks to a large number of add-ons and extensions available in the Visual Marketplace.

Microsoft Visual Studio Code includes the following features and benefits for debugging C# and .Net code:

• Third-party and Microsoft-produced code debugging extensions and add-ons available from the Visual Studio Marketplace. This includes debuggers for Python, C, C++, C#, and Java, to name but a few.
• Built-in debugging for Node.js runtime. This means you can debug JavaScript, TypeScript, and other languages that are transpiled to JavaScript.
• Built-in refactoring tools, straight in the IDE and development environment.
• Breakpoints, Logpoints, and data inspection.
• Built-in Debug Console REPL (Read-Eval-Print-Loop).
• Multi-target debugging and remote debugging support.

Sentry C# Debugger

Created by Functional Software, the Sentry Error and Performance Monitoring tool is used by some of the biggest companies in the world, including names like GitHub, Disney, Reddit, and even Microsoft. Along with their error tracking software for C#, the company’s products also monitor applications created in many other languages, including Python, JavaScript, Go, iOS, Android, and Ruby. Frameworks such as React, Angular, Django, Swift, and Flask are also covered – to name a few.

Sentry includes the following features and benefits for debugging C# and .Net code:

• Overhead view of C# stack traces, including line numbers and filenames.
• Filter and group C# exceptions.
• Monitor errors in production without causing performance issues in throughput.
• Track and surface performance problems in API and surface errors to prevent downtime.
• Exception handling tools, including debug logs, database queries, and network requests.
• Find bugs in different versions of software to track origin points.

How Much Does Sentry C# Code Debugger Cost?

If you are wondering how much the Sentry C# Code debugging tool costs, you can check out Sentry Pricing. A limited version for developers is free. Meanwhile, the Team version is $26 a month and the Business level weighs in at $80 per month. An Enterprise version is also available, but you would have to request a quote to see pricing.

dotPeek and dotTrace from Jet Brains

While these are two different tools for debugging code, dotPeek – which is technically a decompiler – and dotTrace – a performance profiler – we include these two together because they are both made by one of the greatest developer tool creators in the game, JetBrains. You will find JetBrains mentioned in a lot of my articles, and with good reason. They make some of the best software developer tools on the planet. You might recognize their name from products such as ReSharper, Rider, PyCharm, and the Java-replacement language for mobile app development, Kotlin.

dotPeek includes the following features and benefits for debugging C# and .Net code:

• Based on ReSharper’s decompiler, which makes it capable of decompiling any .Net assembly into C# or IL code.
• Supports .dll, .exe, and .winmdfiles.
• Export decompiled code into Visual Studio projects.
• Debug third-party code from local source code based on PDB files or from source servers.
• Debug assembly code thanks to dotPeek’s ability to create symbol servers, which allows Visual Studio to debug third-party code.

dotTrace includes the following features and benefits for debugging C# and .Net code:

• Records and analyzes application performance.
• View the time each call method, HTTP request, and database call takes to better identify performance issues.
• Incorporates with Visual Studio so you can profile apps in the IDE or development environment.
• Profile timelines, SQL, static methods, and any asynchronous code.

How Much Does dotPeek and dotTrace Cost?

If you are wondering how much dotPeek and dotTrace costs, you can visit the JetBrains website for a full breakdown. In essence, dotPeek is free on its own, or you can get it as part of the dotUltimate developer tool kit.

The post Debugging Tools for C# appeared first on CodeGuru.

What is Code Refactoring?

Code refactoring is the practice of taking previously written code and rewriting it to make it more efficient. The idea is simple enough: reduce extraneous code in your software and apps to make the technical cost – the price of fixing errors further down the road – much lower. Reducing the redundant and convoluted code directly affects the performance of your software but also the readability of the code behind it. This makes it easier to add upgraded functionality, fix issues, perform QA tasks, and prevent future issues or bugs.

Another key benefit to code refactoring your C# code is that it helps you avoid code rot. As you may be aware, code rot occurs when you have too much redundant code, spaghetti code, or just sloppy coding practices. Your code can get this way from outdated practices, lack of coding standards in a development team, poorly planned updates or patches, and overtime in general as more and more developers add to the codebase.

Code Refactoring Techniques

Below you can find some of the best code refactoring tips for C# and .Net developers.

Eliminate Redundant Code

One of the best ways to refactor your code is to find redundant lines or blocks of code. Look out for multiple lines of code that do the same exact thing with the exception of a slight difference. If you encounter this a lot, odds are you can approach your code differently. Instead of having a bunch of lines that essentially do the same thing, consider wrapping them all together in a loop or other structure aimed at achieving the same goal.

Refactoring IF Statements in C#

This may be a surprise to some, but there are developers that write their C# If statements without using brackets. This might be (slightly) faster for you to write, but avoid doing it. Remember: you want your code to be clear and readable. Add brackets to your If statements to make it easier, at a glance, to decipher your intent.

Concatenating Strings in C#

In my early days of coding, I was very guilty of this C# programming no-no. When I would concatenate strings, the temptation was always to use the + operator to string together, well, strings. On the surface, this might not seem so bad, but if you stop to think about it, you will realize that it isn’t the most efficient way to achieve the joining of multiple strings. The reason why? Because you are creating multiple objects, which, in turn, take up more memory.

To avoid this, you can instead use the String.Concat(“”,””,””) function instead. Unlike the + operator, this method of joining strings only creates a single object.

Eliminate Extra Functions

When writing longer programs, you might tend to create similar functions – or the same exact function – multiple times. Sometimes you may not even realize you are doing this and end up with several functions that are all named differently but that all serve the same purpose. Not only is this a waste of resources and time, but it goes against the very idea of why we create functions in the first place – to have reusable code.

If you find yourself in this situation, remove the duplicate functions and simply call the existing function instead. This is a quick way to reduce the amount of code in your software and improve efficiency.

Limit Comments

While we are a big fan of commenting code, it is important to keep in mind the best practices for commenting in C#. Remember the purpose of comments: to make your code and its intent easier to understand. When you add too many comments, comments that ramble, or comments that explain obvious snippets of code, you actually decrease the readability of your code.

One great way to refactor your code is to go through and remove unnecessary comments or comments that no longer apply (such as from old snippets of code you are no longer using or that applied to previous versions of the program).

Create Functions When Possible

A great way to increase the performance of your applications, as well as the readability of your code, is to put your common tasks into functions. This is particularly true if you find that your app uses certain sections of code over and over again. Taking those repetitive sections and creating a function out of them, then calling them instead will help you eliminate a lot of lines of code potentially. It is also just good coding practice. By calling the function(s) instead of writing the blocks of code over and over, you not only increase readability and performance but also reduce the number of coding mistakes in your applications.

Reevaluate Conditionals

A common mistake for newer developers is to create overly complicated conditional statements. Even veteran programmers can fall into this trap. Always review your conditionals to make sure the logic is sound and that you are not repeating yourself and evaluating a condition multiple times when you could have just done it once. One clue to finding conditionals that can be slimmed down is to search for really long conditionals. Try to see if you can eliminate one of the conditional checks or rewrite the statement entirely to slim these types of statements down.

Refactor Prior to Updating

As we update, patch, and add new features to our programs, our codebase gets more and more convoluted if we are not careful. This is especially true of code that has not be refactored. With this thought in mind, always make sure you refactor code before you add any new features.

When you do add new features, keep refactoring in mind as you write your code to eliminate the need to refactor your new features further down the line.

Plan Your Code Refactoring

Finally, one of the smartest things a developer or software development team can do before trying to make their code more efficient is to actually plan the refactoring process. Budget for time and resources as part of the refactoring plan and make sure you understand the overall end goal. Are you looking just to increase readability? Are you aiming to use less memory or optimize performance? Knowing these goals and having an overall plan will help you decide which approach to take and ensure your team stays on track. The last thing you want is for developers to go into the codebase and start randomly searching for things to “optimize”. Think of it as a road trip with no map.

Test Your Code as You Refactor

As a bonus code refactoring tip, always remember to test your code. Test it often. As you make changes to the codebase, even minimal changes can have disastrous, far-reaching effects if you are not careful. As you refactor one section of your C# code, make sure to test it so you know it performs as it originally did. Remember, the goal is not to change the way the program works; it is to make the code work (and read) better.

What Are Code Smells or Smelly Code?

Code smells are characteristics or signs in your codebase or source code that indicate there is some sort of problem with the code itself or the programming logic behind it. Code smells are not unique to C# or .Net but instead exist in all programming languages. Code smells are not technically a bug but more of an indicator that your program is not running in the best possible method.

Code smells are typically found through code refactoring efforts or code inspection. JetBrains has a tool called ReSharper that is pretty handy in sniffing out that smelly code too. We mention the phrase code smell here because it is a common term you hear associated with code refactoring. Examples of smelly code include using the concatenator or + operator to string together strings inside of loops or explicitly throwing an exception.

When Not to Refactor C# Code

There are some instances where you do not need – or perhaps want – to refactor code. If you are trying to make a deadline for product launch, for example, beginning the code refactoring process might throw a monkey-wrench into things. It is impossible to accurately predict how much code will need to be refactored and structure a timeline around that if you are under pressure of a product release deadline. If anything, always make sure to build time into the software product lifecycle for code refactoring ahead of time if you intend to implement code refactoring as a common practice.

Another time you might want to reconsider refactoring your C# and .Net code is if you are deciding to rewrite a program from scratch. Obviously, in these instances, reworking your code would be a huge waste of time.

The post Code Refactoring Tips for C# appeared first on CodeGuru.

Before we go further, feel free to revisit our previous articles in this series:

• What is Scrum 
• Scrum versus Agile Project Management
• What is a Scrum Team and overview of Scrum Values

What are Scrum Team Roles?

Scrum Teams are small units made up of three types of members. Within these three types, there are no sub-types or sub-teams. Neither is there a hierarchy. Scrum Teams – and the roles that define them – are all created equally. Every member has one purpose: the Product Goal.

Before we discuss the three different types of Scrum Roles, it is important to note that a Scrum Role is different from a job title. Even if you do not have a title that matches exactly with a Scrum Role, it does not mean that you do not fit a particular goal. Odds are you will fit into a role, and your actual job title will be viewed as an added “benefit” or “bonus” to the team.

The three types of Scrum Team Roles are:

• Scrum Master: there can be only one!
• Product Owner: there can be only one of these also!
• Developers: 1-8 members typically.

Most Scrum Teams are ten or few members in size.

What is a Scrum Master?

The Scrum Master’s job is to ensure the Scrum Team understands the practice and philosophy of Scrum. This extends not just to the Scrum Team but the entire organization as well. Their main goal – and the thing they are accountable for – is for the Scrum Team to be as effective as possible in relation to the Product Goal. To achieve this, they rely on the Scrum framework and Scrum tools to help the Scrum Team improve its practices and performance.

• Scrum Masters increase the Scrum Team’s effectiveness in the following ways:
• Removing – or helping to remove – roadblocks that impede the Scrum Team’s progress.
• Coaching the Scrum Team and enabling self-management.
• Making sure the Scrum Team focuses on high-value increments of their Sprints.
• Making sure that Scrum Events are productive and in the proper timeframe.
• Ensuring the Scrum Team produces Product Backlog items that are clear and well-defined.

Further, the Scrum Master helps another role – the Product Owner – by:

• Helping to define Product Goal and manage Product Backlog.
• Create empirical product planning.
• Enables stakeholder collaboration where applicable.

The Scrum Master also has responsibilities to the organization as well. The Scrum Master must train and coach the organization in the ways of Scrum. This includes the planning, leading, and advisement of Scrum implementations throughout the organization itself. That means that all employees and stakeholders need to understand – and act upon – the philosophies of the empirical approach to work. Finally, perhaps one of the most important roles of a Scrum Master is the removal of any barriers that might stand between stakeholders and Scrum Teams.

What is a Scrum Product Owner?

The next role we will look at in the Scrum Team is the Product Owner. Their primary function is to maximize the value of the Product that the Scrum Team is working on. They are also accountable for Product Backlog management. To do this effectively, they must:

• Develop the Product Goal
• Communicate to the Scrum Team and organization what the Product Goal is.
• Create Product Backlog items.
• Communicate Product Backlog items to the Scrum Team.
• Make certain that the Product Backlog is clearly understood, visible to all team members, and is transparent.

What is a Scrum Developer?

Developers are the workhorses of the Scrum Team. Their job is to create portions of usable increments every Sprint. This includes creating the initial plan for the Sprint and the Sprint Backlog. They must also adhere to the vaunted Definition of Done. Each day, Scrum Developers are also accountable for adapting their plan toward the Sprint Goal and holding every other member of the Sprint Team accountable as professionals.

Scrum Considerations

We are just getting started in our understanding of Scrum, Scrum Teams, and Scrum methodologies as they relate to software development and project management. To better understand the articles in this series thus far – and to prep for future articles on the topic of Scrum, we recommend you check out Scrum.org’s Glossary of Scrum Terms.

The post What Are Scrum Roles appeared first on CodeGuru.

What is a Data Type in C#?

Data types describe the type of information – or data – that a developer is inputting into a computer. These data types, in turn, get fed to the compiler or interpreter so that they can better understand how a programmer intends to use the data. Imagine, for a moment, that someone is speaking to you in gibberish. You have never heard the language they are speaking in and you have no reference point to tell if they are telling you letters, numbers, or words, much less what type of numbers – if any. Further complicate that scenario by imagining that you cannot even tell if they are using the most basic form of communication: yes or no questions and answers.

Working backwards, if you did know, at the very least, whether they were trying to tell you a word, a number, or a simple yes/no question, you would be better equipped to try and understand what that person was trying to tell you. You would know, for instance, if you needed a calculator and a set of equations or if you needed a dictionary or language interpreter to input the data into to understand it.

This is a simplified way to understand data types, but it serves the purpose for this article. After all, knowing how data types work is not as important as know what data types are and what they represent.

Editor’s Note: We covered best commenting practices in C# in a previous article.

C# Data Types

Data types in C# are categorized into two types. The first is value types, which contain an instance of a type. Value types include the simpler types of data types, such as integers, floats, Booleans, and cha. Don’t worry about what those mean at the moment – those terms will make sense shortly. Other value types are enums, structs, and Nullable.

Reference types, meanwhile, contain a reference to an instance of the type. This is an important distinction: value types essentially contain an actual instance of a type while reference types simply hold a reference point to the instance of the type. Think of it like two bags: one holds actual gold, while the other bag holds a map to the gold.

C# has 16 pre-defined data types, the main five of which include integral, floating-point, char, strings, and Boolean.

Of the numeric data types, there are two main groups:

Integers: Integer data types represent whole numbers. They can be positive or negative, but must not contain a decimal. Integer data types are known as int and long. Floating points: Floating-point types are essentially numbers that contain decimals. In C#, floating-point types include float and double data types.

Read: Working with Strings in C#

int Data Types in C#

int data types are used to store whole numbers that range from 2147483647 to -2147483648. The majority of the time when you work with numeric values in C#, you will be using the int data type.

To create an int is pretty simple. You can >i>declare your int in the following manner:

using System;

namespace IntExample
{
  class IntApplication
  {
	static void Main(string[] args)
	{
  	int myAge = 44;
      Console.WriteLine(myAge);
	}
  }
}

The portion of the code above where you declare your variable is:

int myAge = 44;

Long Data Types in C#

A long is another numeric data type C# has to offer. As the name implies, it is used to store whole number like an int, only it stores a larger range of values. Namely, you can store values from 9223372036854775807 to -9223372036854775808. You only use this type of data type when the number is too large for an int. Here is an example of how you declare and use a long value in C#:

using System;

namespace LongApp
{
  class ExampleApplication
  {
	static void Main(string[] args)
	{
  	long myLotto = 85000000000L;
      Console.WriteLine(myLotto);
	}
  }
}

In this example, the long is assigned a value in the line:

  	long myLotto = 85000000000L;

Note the use of the L at the end of the numeric value; you must always include the L when making a long.

Read: Working with Math Operators in C#

float Data Types in C#

float data types are used to store decimal point or floating point numbers. They can store fractional numbers up to 7 decimal points long ranging from 3.4e−038 to 3.4e+038. Note that the numbers you store in a float must end with the letter F. Here is how you create a float in C#:

using System;

namespace FloatApp
{
  class ExampleApp
  {
	static void Main(string[] args)
	{
  	float mySalary = 150.50F;
      Console.WriteLine("My salary per hour is: " + mySalary);
	}
  }
}

This code would result in the output:

My salary per hour is 150.5

double Data Types in C#

double data types in C# are used to store floating point numbers that are too large for a float. You can store values ranging from 1.7e−308 to 1.7e+308 in a double. Best practices dictate that a double end in the letter D. Here is an example of how to create a double in C#:

using System;

namespace DoubleApp
{
  class ExampleApp
  {
	static void Main(string[] args)
	{
  	double mySalary = 150.50D;
      Console.WriteLine("My salary per hour is: " + mySalary);
	}
  }
}

Read: Tips for Writing Clean Code in C#

char Data Types in C#

There are data types in C# that handle text as well as numbers. The first of these is the char data type, which is used to store a single character. To create one, make sure you character is encased by a pair of single quotes, such as ‘A’. You can store any letter, number, or special character as a char value, so long as it is surrounded by single quotes.

Here is an example of how to create a char in C#:

using System;

namespace CharApp
{
  class CharExample
  {
	static void Main(string[] args)
	{
  	char myInitial = 'J';
  	char mySecondInitial = 'P';
      Console.WriteLine("My initials are: " + myInitial + mySecondInitial);
	}
  }
}

This code results in the following output:

My initials are: JP

string Data Types in C#

The other text data type in C# is known as a string. strings are used to store longer sequences of characters than a char. Instead of using single quotes to define them, strings are created using double-quotes. Here is some sample code showing how to create a string in C#:

using System;

namespace StringApp
{
  class StringExample
  {
	static void Main(string[] args)
	{
  	string firstApp = "Hello, World!";
      Console.WriteLine(firstApp);
	}
  }
}

The above code results in the output:

Hello, World!

The post C# Data Types Explained appeared first on CodeGuru.

This C# programming guide looks at not only how to write comments in C#, but also discusses the best practices for leaving comments in your code.

Read: Tips for Writing Clean C# Code

How to Write Comments in C#

Below we discuss the different types of comments C# has to offer and how to write them to better document your C# code. We start off with the most common type: single-line comments.

Single Line Comments in C#

Writing single-line comments in C# is fairly simple. You start your comments by using double forward-slashes or //. When C# sees // on a line, it ignores everything after those double-slashes until the end of the line. This is an important distinction, as any text you write on the following line that is not preceded by double-slashes will be treated as code and – if it isn’t – will cause errors in your application.

The following code shows how to write single-line comments in C#:

// This is a single line comment
// powerLevel represents the super hero's power level and ranking
powerLevel = 90;

Console.WriteLine("The Hero has the following power level:");
Console.WriteLine(powerLevel);

Another type of single-line comment you can create is known as an inline comment. Inline comments are sometimes called trailing comments as well. This is because this type of comment follows – or trails – a portion of code and resides on the same line. Here is an example of how to write inline comments in C#:

powerLevel = 90;   // Represents a hero's powerlevel

As you can see in the above example, the inline comment comes after the code but does not carry over to the next line. A quick note about inline or trailing comments – it is always best to avoid using this type of comment unless it is absolutely necessary, as they can make your code difficult to read and affect code readability.

Read: Working with Strings in C#

Multi-Line Comments in C#

Technically, you can write multi-line comments – that is comments that span more than one line – in C# by just using a bunch of single-line comments, like so:

//This is a comment
//This is a comment on another line
//Here is another comment!

powerLevel = 90;

While that is perfectly valid, true multi-line comments are written in C# by starting them with /* and ending with */ on the same or a different line. The text between the /* and */ is your comment and is ignored by C#. Here is how to write a multi-line comment in C#:

/* This is the start of our multi line comment
powerLevel represents the super hero's power level and ranking
We will use it to calculate how strong a hero is
This is the end of our multi line comment */

powerLevel = 90;

Console.WriteLine("The Hero has the following power level:");
Console.WriteLine(powerLevel);

Read: Working with Mathematical Operators in C#

Best Practices for C# Commenting

Below are some of the best practices for writing comments in C#:

• Only use comments for code snippets that are hard to understand or need clarification.
• Keep comments simple: remember their purpose. They should precisely describe what a portion of code does.
• Don’t be rude or mean in your comments. Be professional.
• If you change a portion of code, be certain to change the comments to!
• If you have multiline comments or multiple inline comments, make sure they are aligned for easier readability.
• Keep comment lines short. Use multiple lines if necessary versus cramming them all on one line.
• Use the same style of comments as the rest of your development team or that you use in your entire application.
• Avoid W.E.T. comments or comments that waste everyone’s time. Don’t explain something that is obvious.
• Avoid smelly comments. Smelly comments are comments that attempt to justify or explain bad code. Rewrite your code instead. One final note about C# comments – they are not only used to tell yourself – or other developers – what your code was intended to do.

Comments can also be used to troubleshoot code and find errors. You can use comments to comment out lines of code so that you can make sure those parts of code are not the culprit causing problems. Just remember to remove the comment from the code once you are satisfied that particular line or block of code is causing the issues in your application.

Read more C# programming tutorials and C# developer tool reviews.

The post Commenting Best Practices in C# appeared first on CodeGuru.

These apps and extensions come in a variety of categories, all housed on Microsoft’s Visual Studio Code Marketplace. All told, there are 17 total categories on Visual Code Marketplace, covering topics such Azure, Debuggers, Formatters, Machine Learning, Visualization, and Programming Languages – to name but a few. There are a total of 28,000 extensions listed on the Marketplace, with new ones getting added every day. To help you weed out the most important ones, we will be listing the best web development extensions for Visual Studio Code in 2021 for this article.

Best VS Code for Web Developers in 2021

Below you can find a list of the best web development extensions for web developers that use Visual Studio Code in 2021. These extensions are not listed in any particular order. Nor, as you might imagine given the amount of extensions on the Marketplace, is this list exhaustive. Instead, it contains what we consider to be some of the top extensions that will make you a better web developer.

Editor’s Note: We also have a list of Top Visual Studio Code Extensions for Developers in 2021 for other types of developers.

Debugger for Chrome

One of the best extensions for VS Code web devs has to be Debugger for Chrome. As the name implies, this handy extension can be used to help debug JavaScript code right in the Google Chrome Internet browser. Unlike Chrome console, this extension lets you debug web pages in the Visual Studio code development environment. This is a real time saver and very convenient.

Learn more about the VS Code Debugger for Chrome extension.

JavaScript Code Snippets

This is a simple extension for Visual Studio Code that packs a lot of punch for web developers. JavaScript (ES6) Snippets is an add-on that lets you use code snippets in the ES6 syntax for both JavaScript and TypeScript. It saves developers time by presenting them with popular pieces of JavaScript code in the form of snippets so that you do not have to type common pieces of code over and over again. Not only does this save developers time, but it also helps reduce errors.

Learn more about the Visual Studio Code JavaScript Code Snippet extension. 

Live Server

Some web development tasks are tedious. One of the most inane things a web dev has to do is pop open a web browser and refresh it to check a web page or app after they make changes in code. Wouldn’t it be easier if the browser would just refresh automatically when changes are made? Live Server not only adds this feature; it also runs your apps on a localhost server with live browser reloading.

Learn more about the VS Code Live Server extension. 

ESLint

ESLint is another VS Code extension for JavaScript. It lets you analyze your JavaScript code for any errors and fix them. The extension points out errors, making them easy to find. It also helps you spot warnings as well. In addition, ESLint can auto format your JavaScript code too, so you have consistency across the development team.

Learn more about the Visual Studio Code ESlint extension. 

C# Extension

Programming language extensions are powerful tools available on the Visual Studio Code Marketplace. Every developer, no matter what you are programming, should check this section out. Being the fifth most-used language in the world, it is no surprise that C# has its own extension to enhance VS Code. If you create web apps with C#, this is a great addition. It lets you access features such as IntelliSense, Go to Definition, and others normally found in Visual Studio. It also adds support for debugging, syntax highlighting, and project.json.

Learn more about the Visual Studio Code C# extension. 

GitLens

GitLens takes the Git features that already exist inside of Visual Studio Code and amplifies them to a whole new level. The GitLens extension is perfect for visualizing code authorship, navigating or exploring Git repositories, view the who/what/why/when of code changes, view codebase history, and tons more. You can also use GitLens to navigate revisions, view on-demand file annotations within the editor, and find common Git commands via the Git Command Palette. These are just a few of the many features of GitLens.

Learn more about the VS Code GitLens extension. 

Auto Close Tag

Auto Close Tag is a no-brainer extension for those that want to reduce code errors due to forgetting to close tags and also people that want to code as efficiently as possible. The Auto Close Tag extension for Visual Studio Code automatically adds closing tags for both HTML and XML, similar to how Visual Studio IDE works. This is a pretty simple feature to be sure, and some web developers may opt not to use auto-complete features like this, but it is definitely a good addition to your Visual Studio Code install if you want to save time and avoid close-tag errors.

Learn more about the Visual Studio Code Auto Close Tag extension. 

Polacode

Polacode is a neat extension for Visual Studio Code that web developers might find useful. In essence, you use the add-on to take code “screenshots” that you can use for documenting, collaboration, or for articles and social media if you are a writer or write about code. Explaining what this lightweight extension does does not do it justice. Check out the link below and watch the demo of it in use to understand why you need this feature.

Learn more about the VS Code Polacode extension. 

Path Intellisense

There are times when you need to reference a filename in your code. Depending upon the size of your projects or how long you have been working on the project, remembering every filename that is part of your project can quickly become a nightmare. Fortunately Path Intellisense exists and can help you solve this issue. The extension is essentially an autocomplete for filenames. Simply start to type in a path in quotations and Path Intellisense will autocomplete directories and filenames for you. This is a much better option than use the file explorer.

Learn more about the Visual Studio Code Path Intellisense extension. 

Quokka.js

Despite its quirky name, Quokka.js is actually a pretty great extension for Visual Studio Code. It lets you test out your JavaScript code right in the editor versus having to open up Chrome console. Its a real convenient time saver. Bonus points for TypeScript users that need a sandbox for their code without needing to leave VS Code. It updates and displays Runtime values as you code. Very helpful for JavaScript coders.

Learn more about the VS Code Quokka.js extension. 

Language Packs

Maybe not the first thing that pops into your mind, but did you know that you can extend Visual Studio Code to work in other languages? If you look under the Language Packs category, you will see extensions for Simplified and Traditional Chinese, Japanese, Spanish, Russian, Korean, French, Portuguese, and more. Useful if you speak another language.

Learn more about Visual Code Language Pack extensions. 

Web Dev

Web Dev is another no-brainer extension for VS Code, particularly for web developers and web app programmers. The extension is really a conglomeration of multiple other extensions, all of which are dedicated to web development. It includes some of the VS Code extensions we have already discussed, including Live Server, ESLint, and JavaScript Code Snippets. It contains 24 extensions in total. You can see a full list by checking out the extensions page on Marketplace below.

Learn more about the VS Code Web Dev extension. 

CSS Intellisense for HTML

Another Intellisense extension for Visual Studio Code. This one offer Intellisense HTML id and class attribute completion. Works for local and remote files. Template inheritance and additional stylesheets are supported as well.

Learn more about the Visual Studio Code CSS Intellisense for HTML extension. 

Better Comments

Better Comments lets web developers create comments that are easier to read by adding the functionality to categorize your annotations into different categories. These comment “categories” include: alerts, queries, ToDos, and highlights. In addition, you can highlight commented-out code, which is pretty useful for testing and debugging purposes or if you are trying out new features in your code. A huge amount of languages are supported, so odds are, if you program in a given language, it will be covered.

Learn more about the VS Code Better Comments extension. 

Summary of VS Code Extensions for Web Developers

We covered a lot of ground in this article and showcased some of the best web developer extensions for Visual Studio Code. There are plenty more available at the VS Code Marketplace, so make sure you browse the different categories and find some more developer tools to help you in your development endeavors.

The post Visual Code Extensions for Web Developers appeared first on CodeGuru.

For instance, a relational database might look like the following:

Name                	Social Security   Invoice Number
Jared Buyman	       666-66-6666    	  8675309
Max Purchaser          777-77-7777    	  0123456

Relational Database Management Systems (RDBMS) are used by development teams, DevOps teams, and database admins to build, manage, and deploy applications on local systems and in the cloud. When looking for a relational database system, important features include:

Important features of Relational Database Software:

• Support for Developer APIs ·
• Scalability
• Security enhancements
• Speed
• Data integrity
• Vendor support
• Parallel computing and distribution
• Data capacity and storage

Top Relational Database Software for 2021

Below is a list of the best relational database software for 2021. The databases that made this list are not in any particular order. Nor is this list complete. The RDBMS are all chosen with a developer or development team in mind.

SQL Server Relational Database

SQL Server is Microsoft’s answer to relational database management systems. Developers may also know it as Microsoft SQL Server, MSSQL, and MS SQL as well. Microsoft SQL Server is compatible with many query languages, including ANSO-SQL and T-SQL. However, its main function – as is the case with all database applications, is for the storage – and retrieval – of data and information. It is used by many top organizations in the world, including Blue Cross/Blue Shield, BMW, and Samsung – to name but a few.

Benefits of SQL Server for Developers

SQL Server offers the following benefits for developers and database admins:

• Easy installation and configuration – no specific toolkit required.
• Increased data security – updates are fully automated. In addition, administration service provides added security features.
• Built-in data recovery and restoration features that include caching, scheduled backups, and log files.
• Better performance due to built-in data compression and encryption; developers do not need to tackle encryption tasks.
• Low cost of ownership thanks to data management, data mining, and disk partitioning tools.
• Cross-platform options. Run SQL Server on Azure SQL in the cloud, extend it to IoT devices or deploy on-premise.

Learn more about Microsoft SQL Server.

Oracle Database

Oracle Database is a multi-model relational database management system known for its use in Enterprise environments. It is known for its advantages to developers and database admins engaged in grid computing and data warehousing activities. It supports the use of SQL for querying. Oracle has one of the longest histories in the database management software field. With that longevity comes a level of vendor support and reliability database admins might not find in newer database offerings.

Benefits of Oracle Database for Developers

Below are just a few of the benefits of Oracle relational database software for developers:

• Multiple database support – Oracle offers the ability to create and manage multiple database instances on a single database server using instance caging for the management of CPU allocations.
• Real Application Clusters (RAC) databases ensure high data availability by taking advantage of tools like database scaling, load balancing, and data redundancy.
• Built-in failure recovery via the Oracle Recovery Manager (RMAN), which offers the ability to recover and restore database files in the event of an outage or other downtime. Continuous archiving, user-managed recovery, and online backups all help ensure data integrity.

Learn more about the benefits of Oracle Database for developers and DBAs.

Amazon RDS

Part of Amazon Web Services, Amazon Relational Database Service (RDS) is a cloud database solution that lets developers and DBAs deploy, set up, scale, and run databases in a cost-efficient, scalable environment. It is perfect for development teams that want to off-load tasks by automating common administrative duties such as hardware provisioning, patching, updating, and backups. Amazon RDS comes in a variety of flavors and database engines, featuring support for Amazon Aurora, Oracle Database, PostgreSQL, MySQL, and MSSQL Server, among others.

Benefits of Amazon RDS for Developers and DBAs

Below are some of the most important benefits of Amazon RDS for developers and DBAs:

• Availability – Amazon RDS is incredibly reliable, in part because it shares the same infrastructure as Amazon Web Services. It has the ability to create redundant data from multiple databases instances across different availability zones, ensuring availability. Amazon Relational Database services also come with frequent backups, database snapshots, and perfunctory host replacement as built-in features.
• Scalability – Amazon RDS is highly scalable. Developer teams and DB admins can scale both compute and storage resources for databases with a few simple steps and without worrying about downtime.
• Speed – Amazon RDS service is pretty fast, thanks to the usage of SSD storage. You can opt for normal storage or a high-acting OLTP app-friendly version.
• Security – Amazon RDS is incredibly secure. They allow you to keep instances of your relational databases separate while also staying connected with an encrypted IPsec VPN. In addition, admins get to run DB instances in Amazon’s virtual private cloud (or VPC) so that they can control who can access a particular database and how they access it.

Learn more about Amazon Relational Database Services (RDS). 

Google Cloud Platform

Not to be left out of the fray, Google offers its own suite of cloud services for relational databases via its Google Cloud Platform. For relational databases, Google’s Cloud SQL is a great choice, as it provides a fully managed relational database service for MySQL, PostgreSQL, and SQL Server. Like others in the space, it has a bevy of features dedicated to helping database admins secure data and ensure data integrity.

Benefits of Google Cloud for Developers and DBAs

Below are some benefits of Google Cloud SQL for developers and DBAs:

• Easily integrate with BigQuery, Compute Engine, and Kubernetes.
• Live migration of virtual machines
• Google Cloud is net carbon-neutral; all electricity used to run Google Cloud is matched with 100% renewable energy.
• Advanced security features backed by the same framework and security services that Google uses.
• Low learning curve and competitive pricing.
• Improved performance thanks to SSD persistent disks with IOPS performance

Learn more about Google Cloud services for relational databases.

Microsoft Azure SQL Database

Another cloud option – and another option from Microsoft – Azure SQL Database is a scalable, AI-powered relational database service that offers serverless compute and Hyperscale storage options that you can scale on demand. Like other options in its class, Azure SQL also has automated backups, updates, and provisioning. It also has continuous updates so that your databases always run on the latest version of SQL.

Benefits of Microsoft Azure SQL for Developers and DBAs

Below are some of the benefits of Microsoft Azure SQL for developers and database admins:

• Built-in Artificial Intelligence (AI) and High Availability to provide peal durability and a 99.9 percent uptime.
• AI-powered intelligent threat detection for advanced security.
• Highly scalable with a flexible, responsive serverless compute and Hyperscale storage solution. Compute scales automatically to optimize costs based on usage.
• Support for all popular platforms and languages, including .Net, Java, Python, Node.JS, Ruby, and PHP.
• Integrates with Azure DevOps and GitHub.

Learn more about the benefits and features of Azure SQL Database. 

The post Best Relational Database Software appeared first on CodeGuru.

In previous articles, we discussed What is Scrum and the differences between Scrum and Agile project management. You can read those articles before you continue if you choose or skip ahead to the good stuff below.

What Are Scrum Teams

Scrum Frameworks dictate that any work performed is done by the Scrum Team. In order to do so, Scrum Teams must work towards a common goal, follow the same norms and rules, and show each other the same respect – regardless of position within the Scrum Team or job title.

All Scrum development teams share common characteristics which are part of the Scrum methodology or philosophy. The Scrum characteristics for development teams, as described in the Scrum Guide, are as follows:

Scrum development teams are self-organizing. This means that the team decides how to turn Product Backlog items into working solutions. Scrum development teams are cross-functional; they should have all of the skills required to create the product or increment of the product. Scrum development team members have no titles. Instead, they are all simply a “Developer.” Scrum development teams have no sub-teams and are small in size. Scrum teams are committed to two things: achieving the Sprint Goal and delivering an increment that is high in quality.

When we speak about “increments” above, we mean that Scrum teams work with the goal of delivering a releasable – or possibly releasable – increment of a finished product by the end of every Sprint.

Elements of a Great Scrum Team

According to Barry Overeem’s Whitepaper on the Characteristics of a Great Scrum Team the following are some of the things that make a Scrum development team great. Note: this is a partial summation of the whitepaper. For a full detailed list, view the document from the link above.

Pursuit of Technical Excellence

Barry Overeem’s famed whitepaper suggests that great development teams are inspired by Extreme Programming; they use the rules and practices that center around the coding, designing, planning, and testing of software. This can include code refactoring, continuous integration, unit testing, and more.

Team Swarming

Team swarming means that the team works on a few items or tasks at a time. In some instances, this can even be a singular item. By having as many people work on the item at a time as possible, items are finished quicker than they normally would be.

Spike Solutions and Refining Product Backlog

One way that development teams can solve problems is by using spikes, which are precise, time-boxed activities that are aimed at figuring out what work need to be done to finish a large, albeit ambiguous, task. They also refine Product Backlogs as a team versus individually.

Respect of the Boy Scout Rule

Respect of the Boy Scout Rule revolves around an actual Boy Scout rule, which states: “Always leave the campground cleaner than you found it.” From a software development team, this means that you always want to leave the codebase better than you found it. Find messy code? Straighten it up.

Criticize Ideas

The idea of criticizing ideas and not people should be a no-brainer. Still, it makes the list as part of what makes a great Scrum development team.

Other Elements of a Great Scrum Team

The full list of BLANK is beyond the scope of this article. However, we urge you to view the full details by visiting Barry Overeem’s Whitepaper on the Characteristics of a Great Scrum Team for a complete breakdown.

Scrum development teams are only one role of the three parts of a Scrum team. In the next part in this series, we will look at the other two parts of the Scrum team – product owners and Scrum masters.

The post What is a Scrum Team appeared first on CodeGuru.

In this article, we will tackle one specific challenge for a project manager: which software development methodology to employ for their development team. In particular, we will be look at two philosophies – for lack of a better phrase. As you may have guessed from the title of this article, we will be comparing scrum to agile project management. We will learn about each style, the elements that comprise each and try to figure out which is best for your software projects.

What is Agile Project Management?

Agile project management is a mix of various software development styles and methodologies focused on incremental and iterative software creation. You could argue that agile project management borrows heavily from extreme programming, the rational unified process, Kanban, and even scrum – to name but a few.

At its core, agile development is all about the continuous iteration of the development and testing of software. The idea is to break down parts of software – or the product – into small pieces or builds. It is unique from other development methodologies because it encourages development teams to develop and test portions of code concurrently or at the same time.

In the agile development process, clients, stakeholders, developers, and the project manager all communicate frequently and work as a team to make sure the product is delivered on time and to completion. Agile development is all about flexibility and being able to adapt to a client’s – or the markets – evolving needs. During the development process, agile developers code iterations of a project, which, in turn, gets organized and prioritized before being added to a backlog based off of end-user feedback.

What Is Scrum Project Management

As you might imagine, just as agile development methodologies contain elements of scrum, scrum, in turn, contains features of agile. In fact, the two are very often confused, despite the fact that they differ in many fundamental ways.

Scrum is a framework for a collaborative approach to software development. Scrum projects consist of sprints, which are, in turn, broken down into product backlogs, sprint backlogs, and spring goals. Each sprint has a specific function or software feature that gets defined, programmed, and tested. Sprints have small time windows, usually consisting of two-week time periods. This process makes development much more streamlined and efficient because if issues occur or changes are added, they can be addressed in-between sprints versus at the end of the software development lifecycle – basically the opposite of the Waterfall software development process.

Read our article What Is Scrum? to learn more about scrum software development and scrum project management. We also discuss Scrum Teams and Scrum Roles in separate articles.

What are the Differences Between Scrum and Agile?

One of the main differences between Agile software development and scrum software development has to do with the time frame in which deliverables are completed. In scrum, everything is broken down into smaller parts, known as sprints, and each function of a piece of software is due at the end of a sprint. In Agile, everything gets delivered continuously for feedback and then, finally, when the project is at its end.

Another difference between scrum and Agile is how teams function and what they consist of. In Agile development teams, the actual team consists of the client, programmers, project managers, marketing, DevOps, and various other members of an organization. Scrum software teams, meanwhile, are very specific with a set number of members and very defined roles. Scrum roles include the Scrum Master, who helps ensure sprints and teams are properly managed. Scrum masters, product owners (another team role), and developers work and meet on a daily basis.

Another key difference between Agile and scrum is the way the design process and execution are handled. Agile seeks simplicity. Scrum, meanwhile, looks more for innovation, experimentation, and flexibility.

The post Scrum versus Agile Project Management appeared first on CodeGuru.