geek97 hosted Angular workshop for girls students

I am very pleased to share that on 16 November 2017, geek97 hosted a free workshop on Angular for Girls Students of Indira Gandhi Delhi technical University for Women, Delhi.

clip_image002

The workshop was attended by around 40 energetic and super talented girls from Computer Science Engineering and MCA department.

clip_image004

Every student were writing codes and there was great synergy all around. We started with installing NodeJS, Visual Studio Code, and Angular CLI. Once all machines were ready, following topics were covered in the workshop,

  • · What is SPA
  • · Difference between AngularJS and Angular
  • · Using Angular CLI
  • · Creating Components
  • · Data Bindings
  • · Creating a Product App

clip_image006

There were happiness on the face of students and satisfaction of writing codes and seeing their application running .

clip_image008

Teaching these young students was very learning experience for me. I learnt how to be more passionate and pledge to help more girls’ students to success in technology landscape.

clip_image010

This workshop was never possible without help of Sakshi Jain and her team. I thank core team for their all help and invitation.

clip_image012

If you want me to geek97 to host similar type of workshops or learning sessions for your college or team feel free to contact me.

Thanks

DJ

How to write Unit Tests for a .NET Core Application

Read full article on the Infragistics blog

Writing unit tests is a good software engineering practice. In this article, we will learn how to create a C# .NET Core application while adhering to the Test Driven Development (TDD) approach. In the TDD approach, before implementing a functionality, you write a unit test for it. For example, if you want to write a function to add two numbers, first you’ll write a failed unit test and then implement the functionality to pass the test.

In this post, we’ll create a Calculator Application. To start, let’s follow the folder structure as outlined below:

· CalculatorApp – Solution

· CalculatorApp.Services – Application project

· CalculatorApp.Services.Tests – Test project

You can use Visual Studio to create projects; however, in this post, I will use .NET Core commands to create my projects, add tests, and run tests. You can also use MSTest or NUnit to write unit tests, but in this example, I’ll use xUnit and dotnet test to write and run my Unit Tests.

Let’s start by opening a command shell and follow along:

 Creating the Application project

To start, you’ll need to create a directory called CalculatorApp. Keep in mind that you can follow any naming convention you’d like for directories, but if you’d like to follow along with this post, I would recommend following the same directory name. So, let’s create the CalculatorApp directory and navigate to it.

Inside the CalculatorApp directory, we are going to create a new solution by running the following command:

dotnet new sln

After successfully running the command, you should get the message “The Template Solution File was created successfully”. Also inside the CalculatorApp directory, you will find a file named calculatorapp.sln.

Next, create a directory called CalculatorApp.Services. This directory will keep the application sources i.e. all classes of the calculator application. Navigate to the Calculatorapp.Services directory and create a class library by running the following command:

dotnet new classlib

After successfully running this command, you should get the message “The Template Class Library was created successfully”. You’ll also find a file named calculatorapp.services.csproj inside the CalculatorApp.Services directory. Next, you need to add this class library project to the calculatorapp solution. To do this, navigate back to the calculatorapp directory, and run the command:

dotnet sln add .\calculatorapp.services\calculatorapp.services.csproj

After successfully running the command, you should get the message “Project added to the solution”.

Inside the CalculatorApp.Services folder, you will find a class Class1 – rename it to Calculator and modify the class as shown in the listing below:

Calculator.cs

You’ll notice in the above listing that the Add and Sub functions are not implemented. First, we will write a unit test and then implement these functionalities.

Creating the Test project

To add test projects, create a directory called CalculatorApp.Services.Tests and navigate to the directory. In this directory, we will create an MS Test project by running the following command:

dotnet new mstest

This command creates the test project which uses MS Test as the test library. Once the test project is created, add the source project library in the test project. To do that, run the command:

dotnet add reference ../CalculatorApp.Services/CalculatorApp.Services.csproj

This command will add a reference of the CalculatorAppService project into the test project. After adding the reference, add the test project to the solution by navigating to the calculatorapp root directory, and run the command:

dotnet sln add .\CalculatorAppServices.tests\CalculatorAppServices.Tests.csproj

This command will add the test project to the solution. After successfully running the command, you should get the message “Project added to the solution”.

Writing Unit Tests

So far, we’ve created the application source project and a test project. In the application source project, there are unimplemented functions. Now let us write tests for these functions.

In the Test project, I have renamed the file UnitTest1.cs to Calculator.Test.cs and the class name to CalculatorTest. In the constructor of CalculatorTest, we need to create an object of the Calculator class. This can be done as shown in the listing below:

Calculator.Test.cs

Unit Test for Add function

In the CalculatorTest class, add a unit test method to test the add functionality as shown in the listing below:

To run the test, navigate to the CalculatorApp.Services.Tests directory and execute the command:

dotnet test

You’ll get a ‘test failed’ output because the Add function is not implemented, as shown in the image below:

image

To pass the test, implement the Add function in the Calculator class as shown in the listing below:

To run the test now, navigate to the CalculatorApp.Services.Tests director and execute the command:

dotnet test

As output, you will get the ‘test passed’ message as shown in the image

Read full articles on the Infragistics blog

Simplifying function expressions and the function statement

Read full article on the Infragistics blog

In JavaScript, a function can be created in three possible ways:

  1. Function as an expression
  2. Function as a statement
  3. Arrow functions

In this post, we will learn about function expressions and the function statement.

Consider the following code:

When you create a function as shown above, it is called a function declaration or statement. You can rewrite the code above to add a function in different ways, as shown below:

The function created above is called a function expression – in this case, an anonymous function expression. A named function expression can be created as below:

The name of the function expression can only be used inside a function body, which is helpful in recursion. A function expression can either be a:

  1. Named function expression
  2. Anonymous function expression

The third method of creating a function is by using the Arrow function, which was introduced in ECMAScript 6. You can learn more about Arrow functions here.

Some important points about naming functions are as follows:

  1. A function statement cannot be created without a name
  2. A function expression can be created without a name, meaning you’re able to create an anonymous function

Read full article on the Infragistics blog

How to Write Your First .NET Core 2.0 Application

Read full article on the Infragistics blog here

Microsoft .NET Core is a cross-platform open source software development framework that can be used to build applications for mobile, Windows, and the web. You can learn more about .NET Core here, but in this blog post, we’ll walk you through how to create and publish a .NET Core application for Windows.

To work with .NET Core, first you need to install it from here . While you can use any IDE to create a .NET Core application, I am going to use the Visual Studio 2017 Enterprise version. If you do not have Visual Studio installed, you may want to try the community edition, which can be found for free here.  Once the environment is set, launch Visual Studio and create a new project by selecting File->New Project-> Visual C#-> .NET Core-> Console App. Besides C#, a .NET Core application can be used in other languages like Visual Basic.

After successfully creating your project, you will see there is already template code in the Program.cs file which looks like listing 1, shown below:

Read full article on the Infragistics blog here