Forem: Andreas Rein

The ClojureScript experience from a beginners perspective

Andreas Rein — Tue, 27 Feb 2018 14:41:27 +0000

A quick look into the ClojureScript ecosystem and a starting guide for developers interested in ClojureScript.

Learning

There are many online resources to learn Clojure and ClojureScript. I think the best one is clojureacademy. This is very much like codeacademy. A highly interactive learning environment. The downside is that it only contains courses on Clojure and not particular ClojureScript.

A thing I noticed reading through the official documentation and third party packages documentation is that the language is more flamboyant than I’m used to. Are there anyone else that has noticed that?

Tutorials

ClojureAcademy Great courses. Interactive and nicely written.
Modern ClojureScript Extensive tutorial on ClojureScript.
ClojureScript Unraveled
PurelyFunctional.tv

Documentation

Workflow

The workflow is not as fluent if you are coming straight from the web world of webpack and NPM. ClojureScript runs on the JVM and the startup is rather slow. When it’s up and running there are however no problems. It still feels sluggish and kinda weird to work on the JVM while building an SPA for the web for me. Figwheel (ClojureScript’s live reloader) is really a must and it works flawlessly as well.

Where ClojureScript really shines is the REPL capabilities. This is a powerful feature and invites you to try, test and learn.

Third-party packages

It seems like in the ClojureScript's community there are a lot of highly skilled developers. There are not a whole lot of packages but most of them are of quite good quality. As a beginner, I found the documentation on some of them rather lacking.

You can also use third-party javascript libraries, either through CLJSJS or including it in your build process.

Tooling

Atom
- Can be quite good with plugins (Parinfer, atom-parinfer, lisp-paredit)
- Not a good out of the box experience
Cursive
- Cost $199 for a commercial license
- Great code completion, REPL, and debugger
- IntelliJ plugin
VSCode
- Can be acceptable with plugins (Vs-code-parinfer, vscode-clojure-debug)
- The plugins is still immature
Light Table
- First class support for ClojureScript (Light Table is built into it)
- Many plugins
- Sluggish performance and not completely bug-free
- Development seems to have stagnated
Emacs
- The most popular choice
- Many plugins
- Steep learning curve
- Keyboard based workflow
Nightlight
- Runs inside your project
- Basic editor functionality
- REPL, code completion, and instaREPL
Nightcode
- Simple IDE for Clojure(Script)
- Easy to get started
- Web-based version is also available
Vim
- Quite a popular choice
- Keyboard based workflow

ClojureScript's tooling is weak compared to other languages. The best ones after my short period of testing are undoubtedly Emacs, Cursive, and Atom. There are other good ones like nightlight and nightcode but they are quite simple in terms of functionality.

Conclusion

I believe ClojureScript still have some work to do so it will be more inviting to learn for web developers that usually work with React, Vue or Angular. The tooling support is a must since most programmers have a favorite editor and it takes time to get comfortable with an editor. The documentation is quite good but still not there yet.

The pics is taken from the State of Clojure 2016 survey

Nifty and useful features in C# 7

Andreas Rein — Fri, 04 Aug 2017 11:11:47 +0000

This article was first published on Steemit.

The seventh version of the enjoyable programming language C# is not a big release, but it comes with some nifty features and some really sweet syntax lollies. This post will be an overview of the most useful features in my opinion.

Tuples

Tuples have been around for quite some time, but it has not been integrated into the language before now. A tuple is a data structure that has a specific number and sequence of elements. You can now declare methods that have multiple return values.

If you think you have to pass in sum and count into GetFoo, you're not alone. The syntax is sure a little strange in first sight.

Example:

public (int sum, int count) GetFoo()
{
    return (1, 2);
}

Deconstructing

You can deconstruct a tuple into separate parts. There is various way to achieve the same though.

Example:

// Explicit
(int sum, int count) = GetFoo();

// var
(var s, var c) = GetFoo();

// var shorthand
var (s, c) = GetFoo();

// Existing variables
int sum, count;
(sum, count) = GetFoo();

// Deconstructing objects also works
class Student
{
    public string Name { get; set; }
    public int Age { get; set; }

    public void Deconstruct(out string name, out int age)
    {
        name = Name;
        age = Age;
    }
}

var student = new Student { FirstName = "Peter", Age = 22 };
var (name, age) = person;

Tuple initialization

var student = ("Peter", 22);
Console.WriteLine($"Name: {student.Item1}, Age: {student.Item2}");

// Assign item names
var student = (name: "Peter", age: 22);
Console.WriteLine($"Name: {student.name}, Age: {student.age}");

Local functions

Local functions are functions that are defined inside a method and have access to all local variables in that method. Before C#7 you could declare a Func to achieve this, but that is unnecessarily expensive and it looks quite ugly. The nice thing about local functions is that the compiler transforms it to a regular private static method, so there will be literally no overhead.

Example:

static void Main(string[] args)
{
    int Sum(int x, int y)
    {
        return x + y;
    }

    Console.WriteLine(Sum(10, 20));
    Console.ReadKey();
}

It's worth knowing that local functions support delightful lambda syntax and you can also declare a local function with the same name as an existing private method.

Out variables

The out var declaration is syntax sugar to improve readability when using TryParse.

Example:

Before:

int value;
if (int.TryParse(input, out value)) 
{
    Foo(value);
} 
else 
{
    Foo(value);
}
Foo(value);

Now:

if (int.TryParse(input, out var value)) 
{
    Foo(value);
}
else 
{
    Foo(value);
}
Foo(value); // Value is still in scope

Digit separators

In C#7 we have the underscore _ as digit separators. This is purely syntax sugar but it does improve readability in large numbers.

Example:

int bin = 0b1001_1010_0001_0100;
int num = 1_2__2_3_4_5_6_3; // Separators is simply ignored

Pattern Matching

In C#7 we get pattern matching. No doubt C# is getting a little more functional with every new release.

is

The is operator is used to checking if an object is compatible with a specific type, e.g. if a specified interface is implemented. In C#7 you can use is to check for patterns.

Example:

Before:

string s = o as string;
if(s != null)
{
    // Do something with s
}

Now:

if(o is string s)
{
    // Do something with s
};

switch

The switch statement has been enhanced as well. Using case, you can check for a const pattern (this was possible before), a type pattern to immediately declare a variable of the specified type, and the var pattern.

You could also use the when keyword to enhance the pattern filter to only apply when a specific condition is fulfilled. This is the same keyword already used with exception filters in C#6.

Example:

public static void SwitchPattern(object o)
{
    switch (o)
    {
        case null:
            Console.WriteLine("It's a constant pattern");
            break;
        case int i:
            Console.WriteLine("It's an int");
            break;
        case Person p when p.FirstName.StartsWith("An"):
            Console.WriteLine($"a An person {p.FirstName}");
            break;
        case Person p:
            Console.WriteLine($"Any other person {p.FirstName}");
            break;
        case var x:
            Console.WriteLine($"it's a var pattern with the type {x?.GetType().Name}");
            break;
        default:
            break;
    }
}

Learn more

If you want to dig deeper into the neat new features in C#7, there are quite some material you can read.

Hi, I'm Andreas Rein

Andreas Rein — Tue, 11 Jul 2017 20:21:39 +0000

I have been coding for 5 years.

You can find me on GitHub as kleinrein

I live in Trondheim, Norway.

I work for BDO.

I mostly program in these languages: C#, JavaScript, Java, CSS, Kotlin, Lua, HTML.

I am currently learning more about everything.

Nice to meet you.