DEV Community: Sean

Learn Clojure Interactively Using eBooks

Sean — Wed, 21 Oct 2020 10:42:52 +0000

I recently decided to learn a bit of Clojure. My first step was to setup my preferred editor with a Clojure plugin. The Clojure tooling allows a developer to write code in a text buffer, then use a keyboard shortcut to execute a section of that code in the REPL. This instant feedback makes for a really great developer experience.

After toying around a bit, I bought a copy of Getting Clojure by Russ Olsen from the Pragmatic Bookshelf. One of their download options is PDF format. I read through the first chapter, typing the code examples into a text buffer and using a keyboard shortcut to execute them in the REPL. Typing these examples got a bit tedious, so I started copying and pasting. That's when I got an idea.

If only I could open this book in my editor, then I could just execute the snippets without having to type them.

So, I converted the PDF to a .clj text file using pdftotext (I used the -layout flag for better formatting). Then, I opened the newly converted text file in my editor and was able to execute the code-snippets with a keyboard shortcut. Since this is just a plain-text file, I am able to modify the existing code and try things out with instant feedback. This is a really interactive and engaging way to learn Clojure.

Generics in C# (Part 3 - Generic Classes)

Sean — Sun, 07 Apr 2019 13:29:50 +0000

Introduction

This is the third part of my series on C# Generics (Part One, Part Two). In this article I will explain how to create Generic classes. To demonstrate this I will create a static class prints all items in a List using the InvariantCulture format.

One place where cultures differ is on DateTime. DotNet has an interface called IFormattable that implements a ToString() method that accepts a formatProvider. Using this interface and a Type constraint I will demonstrate how to print out IFormattables using Invariant culture in the static class InvariantCulturePrinter.

InvariantCulturePrinter

First, let's look at the static class InvariantCulturePrinter.

This is a Generic class which works in much the same way as the generic method in Part Two. The T's are replaced by the argument that is passed into the Type parameter. The main difference is the "where T : IFormattable". This is a Type constraint.

The PrintList() method uses a ToString() method that has two parameters. The first parameter is the stringFormat and the second parameter is the formatProvider. If this is a generic method that accepts any generic List as an argument, how can we be sure the argument will contain a type that supports this ToString(stringFormat, formatProvider) implementation?

That is where the type constraint comes in. IFormattable specifies the ToString(stringFormat, formatProvider) method. So specifying IFormattable as the Type constrain will ensure this ToString implementation is always available.

Generics in C# (Part 2 - Creating Generic Methods)

Sean — Sun, 07 Apr 2019 13:21:14 +0000

Introduction

Part One of this series is a general overview of Generics that explored why they are used in Lists. This article will explain how to create your own Generic methods.

Concatenate Arrays of Any Type

I will demonstrate Generic methods by creating an extension method for System.Array. This extension method will combine two arrays, and since it is Generic it will work on any type of array; int[], string[], etc.

First let's look at how the method is called from Main().

Since this is an extension method on System.Array, I create two arrays, then call Concatenate on the first array; passing the second array as an argument. I then repeat the same steps using a string array to prove the method will work on multiple types. In the second section I did not explicitly specify the Type parameter <string>, but the compiler can work it out, since the result is being assigned to a string[].

Now let's look at the Concatenate extension method.

First, I would like to point out the Type parameter after the method name. <T> signifies this is a generic method. You'll notice the return type and method parameters are also T. All these T's are replaced with whatever argument is passed into the Type parameter.

In the first code block in Main() I explicitly specify the type parameter, passing in <int>, so the compiler knows to replace all occurrences of T with int. In the second section of Main() I am assigning the result of Concatenate to a string[] so the compiler knows to replace all occurrences of T with string.

Continue to Part Three, where I will cover how to create Generic classes.

Generics in C# (Part 1 - Generics in Collections)

Sean — Sun, 07 Apr 2019 13:17:12 +0000

Introduction

Generic types were introduced to C# 2 in 2005. Since 2005, Generics have become a pivotal part of C#, empowering things like Lists and Async/Await. If you started learning or using C# after version 2, you may be using Generics on a daily basis without really knowing what they are. This series (Part Two, Part Three) will try to bring some clarity to Generics in C#.

One common use of Generics is in List<T>. Where <T> specifies a Type Parameter.

Before Generics - C# 1

Before diving into Generics, it would be helpful to think about what kind of problem they solve. The best way to do this is to look back at C# 1. Before Generics, C# had Arrays and ArrayLists.

To declare an array, you must specify the type of the array and the number of elements it will contain. Declaring the type is very beneficial, having strong types is one of the benefits of C#, but declaring the size up front can be problematic. This can lead to a lot of repetitive code to manage the size of the array as you create new bigger arrays and copy the old values into it, and don't forget at the end of your method to shrink the array down to the final size.

ArrayLists are resizable, so they solve that problem, but they accept anything of type Object. Which means to work with the values inside of an ArrayList requires casting or boxing.

Generics Solve the List Problem

Lists in the System.Collections.Generic namespace give us the best of both worlds. Lists are strongly typed and resizable. To declare a List, an argument must be passed into the Type parameter (Type parameters are surrounded by < > symbols). This argument determines the type of the List. Once declared, only objects of that type are allowed to be added to the List.

Once declared as a List<int> we cannot Add() any other type to the list. This strong typing is where the real power of Generics shines through.

Lists also dynamically resize. Simply calling the Add() or AddRange() methods will dynamically resize the list as needed to fit the number of elements.

Continue to Part Two to learn how to write your own Generic methods.