Posts

  • Nereo Material

    I just released this modest library with the intent to provide components that are considered in Material Design guidelines, but not implemented (at least, as of today) in Angular Material.

  • Selenium Page Object Model & PageFactory

    Good practices and patterns are not only reserved for developers. Automation code can get huge too, and therefore, should be maintainable.

    So far we did everything inside test methods, but most likely, you don’t want to do that in real life. Every application has a domain, and therefore, objects that represent it. The Page Object Model pursues the idea of creating objects that can be representative of one part of your domain, or of one page, allowing us to easily map our Model’s properties with elements on the correponding page.

  • Selenium XPath

    XPath is a way to go down the webpage hierarchy to find a specific element. Let’s see the basics of XPath to understand it, and also some tools to help us getting it right. Here is the most basic XPath syntax:

    //tagname[@attribute='value']
    
    • //: selects current node
    • tagname: tagname of the node (input, div, etc)
    • @: selects the attribute
    • attribute: attribute to locate the element by
    • value: value of the attribute we look for
  • Selenium - Interacting with Web Elements

    The WebElement object in Selenium represents a Web Element in the web page (a paragraph, a button… whatever), and gives us different properties and methods that we can use. We will review these methods and properties, as well as how to retrieve the elements we are interested in with different strategies.

  • Selenium WebDriver and Navigation

    The IWebDriver can have several implementations. As you might have guessed already, ChromeDriver is its implementation to work with Google Chrome.

    This interface defines methods and attributes that will help us interact with the browser by sending orders and getting information back.

  • Selenium Introduction

    Selenium automates browsers. This means that we can make browsers do things from code. Selenium offers a lot of different tools. In our case, we will focus on it’s web driver, which supports different languages. To be able to use it with C# we need to add the needed packages to our project as it is shown in the next section.

  • Automation Intro Series

    Welcome back!

    This is an Automation Intro Series that will guide you step by step on how to do Automation with Selenium in C#.

  • C# TDD

    Test Driven Development is, shortly said, a technique that consists in writing the tests before the actual code. Wait, what?? How am I supposed to call a method that does not exist to test it? Well, the method will exist, but will not have the new functionality we want to add, therefore, the test will fail. Then, we will write the new small code to make it pass.

  • C# Unit Testing With Dependencies

    Oftentimes we will find ourselves in a situation where something we want to Unit Test has a dependency on another object. In the previos session’s exercises we instantiated real dependency objects and passed them in, but that’s not the idea of Unit Testing. How should we do it then?

    We will use Test Doubles. These are objects that pretend to be a real object for testing purposes. There are several types, here we will discuss Stubs and Mocks.

  • C# Unit Tests Structure

    We already saw an intro to Unit Testing. Now, we will focus on the structure a Unit Test itself will have and how to Setup a set of tests and Cleanup our Test Class. Theory will be short in order to focus on practicing.

  • C# Unit Testing Intro

    There are multiple quality gates that we can add to our software. Having developers and QAs (Quality Assurance engineers) in one team often leads to think that quality is the responsibility of the latest group, which is not true.

    Developers can add quality gates to the software too, for instance, through Unit Testing. It consists on writing code that will test the code the developer is working on.

  • C# Unit Test Series

    Welcome back!

    This is a Unit Test Series that will guide you step by step on how to do Unit Test in C#. It can be considered part of the C# Introduction Series.

  • C# First App (Part III)

    In the previous iteration of our Car Rental Agency software management we added new services that allowed us to store and get data using the File System. Now, we will work on implementing Interfaces and adding Dependency Injection (the concept itself, but we will not set up and use any Dependency Injection Container).

  • C# Dependency Injection

    When we write our code, we usually find ourselves getting dependencies between objects. For example, if we have a class that handles some logic (let’s refer to it as Business Logic class), but relays on another one who is responsible for getting data from the data source (let’s call it Service class), then, we can say that the Business Logic class depends on the Service class.

  • C# Async Programming

    Whenever you perform operations that might have a process that could make the user wait or leave the application blocked until the operation ends, such as network calls, database access and so on, you might want to use async programming.

  • C# First App (Part II)

    We will update the Car Rental Agency software management we started few sessions ago by making the services work with data coming from File Storage.

  • C# File System

    There are several classes that come with the Framework that allow us to work with the File System:

    • System.IO.FileInfo
    • System.IO.DirectoryInfo
    • System.IO.DriveInfo
    • System.IO.Directory
    • System.IO.File
  • C# Interfaces

    An interface is like a class in the sense that allows us to define properties, methods and events, BUT (and is a big but), unlike a class, it does not contain any implementation. Then, who implements an interface? Classes implement Interfaces. We can think of an interface as a contract; when a class implements it, it has to contain every aspect of the interface.

    Do you remember that multiple inheritance is not supported in C#? Well, luckily it is possible to implement more than one interface in a class, in that way, we can add to it functionality from different sources.

  • C# Polymorphism

    Polymorphism means that you can have multiple classes that can be used interchangeably, even though each class implements the same properties or methods in different ways.

  • C# First App (Part I)

    We will add a new project to our solution where we will create an app to put into practice all that we’ve learnt so far. Our application will be a Car Rental Agency Software Management.

  • C# Inheritance

    Same way as you are smart, or good-looking, or good at sports, or good at music, have a nationality, a culture (and so on) in part because of you, and in part because you inherited those capabilities and attributes from your parents, the same can be applied in Object Oriented Programming. We saw one of the properties of OOP (encapsulation), and now we will learn about inheritance.

    With inheritance we can create new classes that reuse, extend or even modify the behavior defined in another class.

  • C# Encapsulation

    We already saw what a Class is, what its Members are and the Access Modifiers. Now let’s combine the three of them to talk about Encapsulation.

  • C# Classes

    A class allows us to create our own custom Type by grouping together fields, methods and events. It is like creating a blueprint of an object where we can define its data and behavior.

    class User{
    }
    
  • C# LINQ

    What is it? It stands for Language INtegrated Query. Its name is pretty descriptive, so, as you migh have guessed already, it gives us the capacity to use Queries within the language itself, in this case, C#.

    There are three parts for a LINQ operation:

    1. Obtaining the Data Source.
    2. Creating the Query.
    3. Executing the Query.
  • C# Collections

    Let’s think of Collections as a group of related objects. So far we’ve seen arrays, which are useful to work with a fixed number of strongly-typed objects.

    Collections’ size is dynamic, meaning that collections can grow or shrink at any time. Some kind of collections even allows us to assign a key to an object for easier retrieval.

    Keep in mind that a Collection is a Class, which means that it has to be instantiated using the new keyword. But we will see more on classes later .

  • C# Methods

    A method is a block of code that containes one or more statements. Every executed instruction in C# is run within the context of a method. Methods can be declared in a class or a struct.

  • C# Exception Handling

    So far we’ve only tested the “happy path”. We always trusted that the user’s input was going to be correct. We always trasted that casting would give no errors, but, that’s not the way to go.

    An Exception is an error that happens at runtime and is propagated through the program. If nobody (no part of our code) handles that exception, then the execution of the program breaks. It is a class inside the System namespace.

  • C# Arrays

    What is an array? An array is a collection or group of things of the same kind. For instance, the winning numbers of the lottery. They are all of the same type and have a relationship between them.

    Arrays in C# follow the principles below:

    • They can be single-dimensional, multidimensional or jagged.
    • Array dimentions are set in the creation and cannot be modified later.
    • The default value of numeric elements are defaulted to 0, and reference elements are defaulted to null.
    • Arrays’ index start on 0.
  • C# Control Flow

    You might have already noticed that, given an entry point for our application (the Main method in the Program class in our sample Console Application) we write lines of code that the computer runs one after the other, or, in other words, sequentially.

    Sequential Flow.PNG

    But, sometimes, we might want to execute things in a different order based on what is going on dynamically in our application.

  • C# Variables and Types

    Before beginning, let’s see what Types are and which ones we can find built-in in .Net.

    Programming, information is classified as in real life. When you ask someone her phone number, you don’t assume it is text, or that it is a date; in your mind, you see numbers. In the same way, when they ask you your name when you arrive to a hotel, the employee registering the check-in automatically places her hands on the keyboard side where letters are placed, and not in the numeric pad. Same applies for programming, when we want to work with some data or information, we distinguish of which Type it is.

  • C# Intro Series

  • Bot Framework Quick Start

    Instead of having you reading all the official documentation, I hope this gives you a good starting point.

  • Scrum Paper Airplane Game

    This is a well-known scrum game that’s been around for a while already. But is one of the games that everytime it is played, it is played differently.

  • Business Value Game

    The goal of this game is to help to understand that there is a whole world of considarations to take when it comes to balance customers and projects.

  • Scrum Lego City Workshop

    This is the first post I’ll be making about Workshops. In this case, this was the well known Scrum Lego game. The idea behind is about teaching Scrum basics while having some fun building a “city” with Lego.

  • Visual Studio Project Templates for Ionic

    [UPDATE] This extension was removed from Visual Studio Gallery in favor of Ionic’s official one.

    On my previous post I wrote about how to start a project in Ionic Creator and export it to continue with development within Visual Studio.

    Today, I would like to introduce the Ionic Project Template Visual Studio Extension that I created to simplify the process and be able to have a project already setup with the basic Ionic templates from Visual Studio

  • Ionic Creator and Visual Studio

    This time I would like to share how to easily start from scratch an Hybrid App using Ionic Framework, AngularJS and Apache Cordova. We will have two main tools for this guide: Ionic Creator and Visual Studio with Apache Cordova Tools installed.

  • Scrum Introspective (I mean, Retrospective)

    Restrospective is one of the official meetings that Scrum considers. It is a timeboxed meeting where the Scrum Team gathers together at the end of every Sprint to look back and think about how things went.

    Though the meeting is official, there is not an official “template” for it. It is on the Scrum Master to host it and define which format the meeting will have.

subscribe via RSS