Forem: Lucas Fonseca Mundim

Regex 101 - Kill the Monster

Lucas Fonseca Mundim — Thu, 02 Sep 2021 14:14:36 +0000

More frequently than not I see people recommending RegEx (or RegExp) to other people to help solve a problem and the reaction being the same: they don't want to use RegEx because they don't understand or find it very confusing. I myself find that weird, because I never thought of RegEx to be that awful, at least not on reasonable boundaries. So today I'll try to explain the basis of RegEx to try to make it less of a monster to you guys.

Disclaimer: depending on the programming language you are using the syntax may vary slightly. For reference, I will be using the JS/C# syntax. You can try it out on Regex101

The basics

I really would like to split this into more topics but they wouldn't make very much sense on their own, so I'll call them as "the basics". This will include:

Letters and Numbers
Basic Symbols
Groups and Ranges
Counters
Tokens

Letters and Numbers

First of all, let's talk about letters and numbers. They work very much as you would expect: if you write a, the regex will expect the letter a, lower case, and so forth. There's really not much to explain here.

Basic Symbols

Symbols on the other hand can be a little bit confusing. Some symbols are reserved by RegEx to do some special stuff. They all have the possibility of escaping by using a backslash \, which brings us to the first special symbol:

\: escapes any character that would be a special one to mean literally that character
(): group delimiter, we'll dive in deeper on that later
[]: range delimiter, we'll dive in deeper on that later
{}: counter delimiter, we'll dive in deeper on that later
^: when outside delimiters, it means the start of a string. When within delimiters, it means not (the same as the good old ! on programming)
$: end of a string
.: anything. The . means that the character there can be absolutely any single character. Also known as wildcard
|: our good old boolean operator or

Groups and Ranges

Groups, delimited by (), have more or less the same idea as the symbols in maths or any programming: they group operations together to make something valid for the entire group (e.g. a counter)

Ranges, delimited by [], are a little bit more complex, but not so much. They mean that any character within its range is valid. Note that it can be mixed and matched, and even improved:

[abc] means any character from a, b or c
[^abc] means any character except a, b or c
[a-z] means any character from a to z, in the alphabetical order (so [a-c] would be the same as [abc])
[a-zA-Z] means the same as the above, but case insensitive
[0-9] means any digit

Counters

Counters make it easier to delimit how many from a given character (or rule) you expect.

* means any number, or from 0 to ∞, also known as zero or more
+ means from 1 to ∞, aka one or more
? means from 0 to 1, aka zero or one
{3} means exactly 3
{3,} means 3 or more
{3,6} means from 3 to 6

Tokens

Just as we have \n on programming as a token for new line, RegEx has its own tokens as well.

\s means any whitespace character (space, tab, new line)
\S means any non-whitespace character
\d means any digit, the same as [0-9]
\D means any non-digit, the same as [^0-9]
\w means any word, or any letter, digit or underscore
\W means any non-word, or anything besides letters, digits or underscores
\b means word boundary, or the character immediately matched by \w and a character not matched by \w, in either order

Join all that together and...

By joining all those definitions, we can start writing RegExes. Let's see some samples

Match a 🇧🇷BR ZIP Code: Brazilian ZIP Codes are 5 digits, followed by a dash, followed by 3 more digits. Or, in RegEx:
- [0-9]{5}-[0-9]{3}
- \d{5}-\d{3}
- Some people might not type in the -: \d{8}
- Furthermore:
Match a DD/MM/YYYY or DD/MM/YY date:
- \d{2}/\d{2}/(\d{4}|\d{2})
- Note that | evaluation is lazy \d{2}/\d{2}/(\d{4}|\d{2})

Naming groups

Naming groups should be available on most programming languages, but how it works may vary. It is very useful for readability purposes and should always be used in production environments or serious work should RegEx make it that far. The symbol for grouping is ?<> (or ?P<> for Python in the example).

((?P<ZIPCode>\d{5}-?\d{3})|(?P<Date>\d{2}\/\d{2}\/(\d{4}|\d{2})))
- Yes, in Python it is very ugly, but it is language dependent. In C# it is much better

Wrap up

This article was aimed to just "kill the monster" that people consider Regular Expressions to be, and show that it is not that scary for simple work. Of course it gets harder and harder the more complex your matching needs are (e.g. find an email), but there usually are better ways of doing complex tasks.

If you want or need to dive deeper into Regular Expressions, consider studying the theory behind it (from Formal Languages and read/play around Regex101, but beware: it gets really deep, but it's very interesting!

Writing your F.I.R.S.T. Unit Tests

Lucas Fonseca Mundim — Fri, 27 Aug 2021 11:53:43 +0000

What are Unit Tests?

By design, Unit Tests are automated tests of small units of code that are tested in an isolated fashion. Essentially, an unit test is a program that calls the (public) methods of a class and checks if the results are as expected

Benefits to Unit Testing

If you wrote your unit tests correctly, there are several benefits they will bring to your maintenance process:

Unit Tests will find bugs while you're still developing: if you are refactoring a section of code, or even including a new one, and your past tests start to fail, it means that you changed the behaviour of that method and that might imply on a bug!
Any correction cost regarding the newly found bugs is considerably lower than if they were found while in production
In other words, Unit Tests protect your code against Regression: system changes that create bugs
After changing your code, you must run the test suite! That way you'll find if there was any regression (if any test fails)

F.I.R.S.T. Principles

Just as we have our S.O.L.I.D. principles for programming in general, there are a couple of principles for general good practice in unit testing: the F.I.R.S.T. principles. Let's go over them.

[F]ast

The developer should not hesitate on running the test suite at any point of the development cycle, even if there are thousands of unit tests. They should run in a matter of seconds. If a test takes too long to run, it probably is doing more than it should — and, therefore, is not an unit test!

[I]ndependent/[I]solated

For any given unit test, it should be independent of everything else so that its results are not influenced by any other factor. With that definition, they should usually follow the “3 A’s of testing”: Arrange, Act, Assert (also known as “Given-When-Then”).

Arrange: All needed data should be provided to the test when you are about to run, and it should not depend on your environment.
Act: The actual method you are testing should be run.
Assert: Unit Tests should only test one outcome, meaning each test should assert that one state of an object should be tested. Note that this does not mean that you should only check one variable of a class response, but that all variables tested should be related to the method you ran

[R]epeatable

Tests should be repeatable and deterministic: every single time you run a test their values cannot change, no matter the environment.

[S]elf-Validating

The test itself should tell you if it passed. There should not be any need of manually checking the values. Most assertion libraries (such as Shouldly) work in favour of that principle.

[T]horough

Your test should cover all “happy paths” of a method (xUnit makes that possible with Theory tests), all edge cases (where you think the test might fail), illegal arguments, security flaws, large values… in sum, every possible use case scenario should be tested, not only enough to have (near) 100% Code Coverage

The extra T: Timely

Following TDD, Unit Tests should be written before the production code that will be tested. This can be done by writing the abstraction (Interface) and then the test based on the method signature and spec alone. After the test is written, your code can be produced and tested.

A few tools

For C#/.NET development, a few tools/frameworks are available by default, and a lot more available as NuGet packages. Here are some highly recommended options

Base Framework: xUnit is a powerful and complete testing framework for .NET that is usually bundled with VisualStudio alongside NUnit. Overall both are good frameworks, but xUnit is more readable and intuitive
Assertion Tool: Shouldly is a much more intuitive way of asserting your test results than the native Assert class. The github repo gives plenty of examples but just one very simple sample should be enough to show how readable and simple Shouldly is:

// using Assert
Assert.IsTrue(booleanVariable);
// using Shouldly
booleanVariable.ShouldBeTrue();

Mocking Tool: NSubstitute is a powerful tool that allows you to create mocks for any given class or interface so that you can easily test any method that would, in a regular case, use external environment such as 3rd Party APIs or DataBases. It has a simple learning curve and is well documented

References

This article is a compilation made from different source materials cited below:

General “Software Maintenance and Evolution” and “Software Testing” theory
https://dzone.com/articles/writing-your-first-unit-tests
https://github.com/ghsukumar/SFDC_Best_Practices/wiki/F.I.R.S.T-Principles-of-Unit-Testing
https://medium.com/@tasdikrahman/f-i-r-s-t-principles-of-testing-1a497acda8d6

Basic Productivity Software Setup

Lucas Fonseca Mundim — Tue, 24 Aug 2021 19:35:15 +0000

With the pandemic, the most fortunate of us were moved to working from home, and that often meant using our personal computers to do our jobs (often due to choice), but that meant installing "work stuff" into our machines. How can you keep stuff separated and get a more productive environment, while also maintaining stuff clean for your free time?

Small disclaimer: some of these tips only apply to MacOS users, but most of them are perfectly compatible with any Unix environment 🐧

1. Use different browsers 🕸

Keeping a browser for your personal, free time and a separate one for your job is crucial: more often than not I find myself having dozens of tabs related to some code I'm working on open, and if I had to juggle that with my personal tabs it would be an immense memory hog, while also a terrible chore. Keeping a different browser just for your work eliminates that problem.

You can even double down on that and use browsers that sync to make it possible to work on multiple machines! For example, I use Safari as my personal browser so it syncs with my iPhone and iPad, and to work I use Google Chrome, which in turn syncs up with my Windows' Chrome should I ever need to use it, or even my Ubuntu VM! It's always helpful 👹

2. Use a browser manager 🤵‍♀️🤵‍♂️

Good, you've decided to keep a separate browser for each environment. But that means you're logged off of your, say, Atlassian account on your personal browser, which is set as your primary browser. Now you have to copy every Jira ticket or BitBucket Pull Request link sent on slack and paste it on your work browser. That works... but that's not that efficient is it?

Some more eager people have already had this issue and decided to make it easier on themselves, and they were kind enough to share it with the world! Enter Finicky, a free, open source, browser manager.

What Finicky does in essence is really simple: it allows you to code rules for every URL you click to open up on a given browser. You can set URL's that contain a certain substring to open on Firefox, URL's from Slack on Chrome and everything else on Safari, for example! It is really handy, the installation is very straightforward using brew and there are many possibilities to configure at your heart's content!

Here's my very small and simple configuration:

module.exports = {
  defaultBrowser: "Safari",
  options: {
    // Hide the finicky icon from the top bar
    hideIcon: false
  },
  handlers: [
    {
      // Open any link clicked in Slack in Chrome
      match: ({ opener }) =>
        opener.bundleId === "com.tinyspeck.slackmacgap",
      browser: "Google Chrome"
    }
  ]
};

Should you want anything with a GUI, the folks at Finicky themselves recommend Browserosaurus so go ahead and take a look!

3. Have a single messenger app for your personal stuff 💬

Many of us use more than one messaging app, after all there are tons of them nowadays: Facebook Messenger, Telegram, WhatsApp, Discord... and having to juggle all that open along with the job's ones like Slack and Teams is a hassle.

Some might already be familiar with Franz, a very popular program that unifies all those messaging apps into a single one. Franz is a very capable and very practical solution and if you have an Intel Mac or any other x86_64 machine it should be plenty! But looks like it does not play well with M1 Macs yet. For that then I decided to look elsewhere and found it's "offspring" Ferdi, which has most (if not all) of it's features -- it is actually based off of Franz -- and works very well on Apple Silicon, so be sure to give it a shot!

4. Try out the new Focus mode on MacOS Monterey 🖥

This is still on Beta at the time of writing the article, but the new Focus Mode introduced in WWDC2021 for MacOS Monterey looks like a very handy tool to not only tell your pesky iMessage contacts (and maybe, in the future, any app that feeds off of it's API?) that you're focused working but also hides any notification you do not want in that profile -- and it also syncs up through your apple devices! Be sure to take a look!

5. Use a better Terminal emulator 💻

Yes, MacOS' good ol' terminal gets the job done alright, but it only does an 'OK Job' at that, just like Ubuntu's base terminal emulator or WSL's standard emulator. But what if you want more?

But what could be more? Well, for starters, opening more than one tab. While you wait your pesky make command run for a couple minutes, why should you need an entire new window to keep working on your terminal? That's where iTerm2 comes to the rescue.

It is very easy to install, has a ton of features and, to those who care (like me), it is Apple Silicon ready!

6. Get SiliconInfo if you're on Apple Silicon 

Many of us are currently running on the new (at the time of writing) M1 Macs and we often need (or want) to know if our current application is running on old x86 architecture or the current arm64v8 one. Well, Silicon Info is a pretty straightforward Mac app that adds an icon to your menu bar that can tell you with a glance if you opened the right version of an app! It is pretty handy, yet pretty simple.

7. Have `x86` versions of compatible apps available ⚙️

For some reason, you might need to run the x86 version of an app on your Apple Silicon Mac (compatibility check?), but by default your app opens up on Apple Silicon mode. Well, you can force it to run under the new Rosetta2 environment with a few clicks!

Open Finder and go to your Applications folder. Duplicate the app you want, for example the previously mentioned iTerm2, and rename it to something like Rosetta-iTerm2. Open up it's info panel and select Open using Rosetta, and that is it!

Now whenever you open that copy of the app, it will be running on x86 architecture!

8. Get a better `shell` 🐚

Yes, the good ol' bash shell is fine, but from Catalina onwards Apple replaced it with zsh with no further explanation, but one would assume its because bash is aging and zsh is the new hot thing. Well, along with it you can install oh-my-zsh and customize even further your terminal, not only to make it cooler and more interesting but also more informative, enhancing your productivity. All of that with some minor tweaks.

With a glance I can see what folder I'm in (as usual), what git branch I'm on, and if that branch is dirty or not! Pretty handy right?

9. Start using `alias`-es! 🕵️‍♀️🕵️‍♂️

Let's face it, there are probably at least a few commands you use very regularly that are long and boring or easy to mistype. Why should you type it all the time?

Most (maybe all?) shells allow you to create aliases for those commands, so take advantage of that! Open your .zshrc or .bashrc file and add a new one with a simple line!

alias shortcut='long command'

And then boom! You're all set!

For now, that is it! A very brief productivity setup to help you in your work from home life. Whenever I add something to my own setup I'll be sure to add it here as well!

🛠Refactoring: Replacing Conditional with Polymorphism

Lucas Fonseca Mundim — Mon, 26 Jul 2021 14:18:23 +0000

`Switch` statements are often considered code smells and should be avoided

The Problem

Suppose you have a class with various subtypes defined by a property such as Bird:



public class Bird
{
    // whatever properties do birds have
    public BirdType Type { get; set; }
}

public enum BirdType
{
    African,
    American,
    European
}

And then you need to retrieve, lets say, the speed of a given bird. Thing is: the speed of the bird depends of it's type. Some logic is required, but it sounds easy enough right? You create a class method:



public class Bird
{
    // whatever properties do birds have
    public BirdType Type { get; set; }

    public double GetSpeed()
    {
        switch(Type)
        {
            case African:
                // logic for African birds
            case American:
                // logic for American birds
            case European:
                // logic for European birds
            default:
                // default logic
        }
    }
}

A little bit ugly, but it gets the job done right? But here's the catch: after some time in production, you need to add a new type of bird, lets say Asian



public enum BirdType
{
    African,
    American,
    European,
    Asian // new type
}

And now you have to calculate it's speed as well. "Just add another case to the switch statement" you might say. You could do that, yes, but bear in mind that this will violate SOLID's Open-Closed Principle! And we don't want that, do we?

The Solution: Polymorphism

With Object-Oriented Programming we have the concept of inheritance and, with that, we can implement polymorphism.

To the uninitiated, polymorphism is the ability to process objects differently depending on their class. Sounds familiar?

How do we approach the above problem with polymorphism in mind? We start very much the same: defining the Bird class, but with one change:



public abstract class Bird
{
    public abstract double GetSpeed();
}

Now we have added the abstract modifier to the GetSpeed method and the Bird class itself. What that means is that the Bird class itself has no implementation for that method, nor can it be directly instantiated, and any subclasses might implement it themselves. Now all we gotta do is implement the subclasses!



public class AfricanBird : Bird
{
    public override double GetSpeed()
    {
        // logic for African birds
    }
}

public class AmericanBird : Bird
{
    public override double GetSpeed()
    {
        // logic for American birds
    }
}

public class EuropeanBird : Bird
{
    public override double GetSpeed()
    {
        // logic for European birds
    }
}

Let's see how that plays on a running code:



// Ran on C# Interactive via VisualStudio
> public abstract class Bird
. {
.     public abstract double GetSpeed();
. }
> public class AfricanBird : Bird
. {
.     public override double GetSpeed()
.     {
.         return 1;
.     }
. }
> public class AmericanBird : Bird
. {
.     public override double GetSpeed()
.     {
.         return 0.7;
.     }
. }
> Bird africanBird = new AfricanBird();
> Bird americanBird = new AmericanBird();
> africanBird.GetSpeed()
1
> americanBird.GetSpeed()
0.7

Note that as the method we used is declared by Bird, we could define the variables as the base class and still use it, and we got our desired result 😉

And what if we need to add a new type of bird? We just add a new subclass! No need to modify any existing class! We have respected the Open-Closed Principle!

Note: This refactor that was done is called Replace conditional with Polymorphism (pretty easy to remember the name huh?)

Benefits

The forementioned compliance with the Open-Closed Principle
Gets rid of duplicate code, as you can get rid of many conditionals and/or switch statements
Adheres to the Tell, Don't Ask principle: the object itself is telling you what you want to know, instead of you having to "ask" (via conditionals) for the information