If you don’t have much time…

• Learn X in Y Minutes Where X=F#: Scott Wlaschin wrote the F# version of “Learn X in Y Minutes” which exists also for other languages. It’s a F# file with small snippets which demonstrate features of the language.
• Try F#: If you have Silverlight installed, you can try F# in your browser. There are courses about Basic F#, Advanced F#, Data Visualization and Charting, Data Science, Scientific and Numerical Computing, and Financial Computing.
• F# Cheatsheet: F# snippets which show the features of the language. If you follow these you’ll get an overview of the language.

Longer Resources

• F# Programming (Wikibook): This Wikibook contains a complete introduction to the F# programming language.
• F# for Fun and Profit: This is Scott Wlaschin’s awesome site. It contains many resources for F# learners. The article Learning F# contains great advice for beginners.
• F# Workshop: There is the material of an F# workshop by Jorge Fioranelli. It contains the slides and exercises of the workshop.

F# Foundation

• Learning F#: The F# Foundation has a whole section on their website with resources for those who want to learn F#.
• F# Talks, Tutorials and Podcasts: The F# Foundation has also a list of videos of talks, tutorials and podcasts.
• F# Language Specification: If you want to know how the language is supposed to work in detail the F# language specifications are the right documents for you.

F# in the MSDN

• Visual F# (MSDN Library): The F# section in the MSDN Library. It contains the official documentation for F# by Microsoft and contains a language reference and a reference of the F# Core Library.

Bonus Links: Where to Ask Questions?

The F# community is considered very beginner-friendly. So if you have questions you can ask for help on these channels:
– F# Room on Stackoverflow Chat
– Hashtag on Twitter
– F# Discussion on Google Groups
– F# Room on JabbR
– Functional Programming on Slack

Update: Bonus Link #2

• F# Koans: The F# Koans teach you F# by fixing tests. It is a great way to learn F# by doing F#. Try it now!

Open Source Software, Visual Studio Code is built on

• Electron from Github – formerly known as Atom Shell. It is used to write cross platform desktop applications with web technologies.
• Chromium from Google. Electron uses Chromium, the open-source browser project behind Google Chrome.
• io.js, a fork of Node.js which is a JavaScript platform.
• Blink from Google. Blink is the rendering engine used by Chromium.
• OmniSharp provides language services for C#. Visual Studio Code uses for features like code navigation and refactoring. There are plugins for other editors like Emacs, Vim, Sublime Text or Atom which use OmniSharp for the same purpose.
• Roslyn from Microsoft. Roslyn is the .NET compiler platform with C# and VB compilers. OmniSharp uses its C# compiler for its code analysis features.
• TypeScript from Microsoft. Visual Studio Code uses it for JavaScript and TypeScript code analysis to provide features like code navigation and refactoring.
• Node.js, a JavaScript platform
• V8 from Google. V8 is the JavaScript engine used by io.js, Node.js and Chromium.
• Squirrel, an installation and update framework for Windows desktop applications. Used for installing Visual Studio Code on Windows
• DefinitelyTyped, the repository for TypeScript type definitions. Code uses it for getting the type information for third-party JavaScript libraries in JavaScript and TypeScript projects.

Someone on Stackoverflow wrote another list of open source software used in Visual Studio Code.

Microsoft released software which includes open source components, some of them written by Google. This shows that Microsoft today is not the Microsoft we knew in the past. Although Visual Studio Code builds on all those awesome open source projects, Code itself is not open source. There are components like the “Monaco” code editor or the debugging services that are not open source. Microsoft contributes back to the open source projects, at least to some of them. So even if Microsoft won’t open source VSCode they give back to the community.

There is already an issue in Microsoft’s issue tracker about open sourcing VSCode. If you want Code to be open source vote for it.

When you click on the gear icon on the debug pane VSCode opens .settings/launch.json. Just add the following launch settings and adapt it to your Mono project:

{
    "version": "0.1.0",
    // List of configurations.
    // ONLY "node" and "mono" are supported, change "type" to switch.
    "configurations": [
        {
            // Name of configuration
            // Appears in the launch configuration drop down menu.
            "name": "Launch <PROJECT NAME>",
            // Type of configuration. Possible values: "node", "mono".
            "type": "mono",
            // Workspace relative or absolute path to the program.
            "program": "<PATH TO EXECUTABLE FILE>",
            // Automatically stop program after launch.
            "stopOnEntry": true
        }
    ]
}

After building your Mono application you can set a breakpoint and launch the debugger.

I played around with Visual Studio Code on Mac OS X. This article provides my first impressions with this new tool.

Setup of Visual Studio Code on Mac OS X

The Visual Studio Code documentation contains detailed setup instructions for every platform. For Mac OS X I recommend that you follow all steps including adding the code function to your .bashrc file.

  code () {
      if [[ $# = 0 ]]
      then
          open -a "Visual Studio Code"
      else
          [[ $1 = /* ]] && F="$1" || F="$PWD/${1#./}"
          open -a "Visual Studio Code" --args "$F"
      fi
  }
  

Language Support

Visual Studio Code supports many different programming languages with different set of features:

It looks like the editor targets web developers. I, personally, would like to see better support for F#.

More details about the language support in Visual Studio Code you can find in the official Visual Studio Code documentation.

Command Palette

Do you know the Command Palette in Sublime Text? Visual Studio Code has one, too. It looks like this:

You can invoke commands and navigate to different locations in your project with it. John Papa wrote a blog post series about Visual Studio Code and he provides a detailed introduction to the Command Palette in the second post of the series.

Code Navigation

Visual Studio Code has also some other features for navigating your code. For example, you can find all references of the symbol under the cursor using SHIFT F12. If you work on a C# project you’ll see the “CodeLens” feature which means that you see how many references exist for a symbol.

And if you click on it you’ll see the references in a small popup window:

Intellisense

Visual Studio Code has great Intellisense support even for JavaScript projects. It can distinguish between different types in JavaScript:

You can use TypeScript type definition files for providing more information to Code about different types in third-party libraries. Code can reference those files automatically for you if you use a Code Action (CMD+. on an underlined symbol):

If you choose Add /// reference to 'node/node.d.ts' Code will add a comment line at the beginning of the file which is a reference to the TypeScript type definition.

With this line you added Intellisense support for Node even if you don’t write your code in TypeScript.

Code has Intellisense support even for package.json, bower.json, and project.json.

Debugging

Debugging C# applications on Mac OS X or Linux is not supported at time of writing. But the support for Node applications work perfectly.

The first step is to add a launch.json file by clicking on the gear icon on the Debug pane in the sidebar.

After that you can set breakpoints somewhere in your code, e.g. by clicking with the mouse left to the line number, and start debugging by pressing F5.

Git Integration

Visual Studio Code has Git integration.

After initializing a new Git repository you can commit your changes. You should provide a proper .gitignore file first.

Again, John Papa has a great introduction to Code’s Git integration in a blog post of his series.

Architecture

Visual Studio Code is based on Github’s Electron, the former Atom Shell. Electron allows developers to build cross-platform desktop applications with web technologies. Other applications built with Electron are Atom, Slack, Facebook’s new IDE Nuclide or Kitematic, a GUI application for managing Docker containers.

Code uses a newer and faster version of the same HTML-based editor that was used for the “Monaco” cloud editor, and other projects. And Code uses a tools service architecture that enables it to use Roslyn for .NET, TypeScript, the Visual Studio debugging engine, and more.

Still Missing

Visual Studio Code is still a preview at the time of writing. This means that there are still some features missing. Here is a short list what I’d like to see in the future:

• Extensibility Features – Microsoft plans to add a public extensibility model to Visual Studio Code that let developers build and use plug-ins.
• Source Code – I think that a code editor in 2015 should be open source like Emacs, Vim, Atom, or Brackets.
• Better F# Support – There is syntax highlighting for F# code, but that’s it. I’d like to see more integration with an F# REPL, building F# code, etc.
• Debugging on Mac OS X/Linux – ASP.NET 5/Mono projects still cannot be debugged on Mac OS X or Linux at time of writing.

Conclusion

I liked working with the preview of Visual Studio Code. It’s fast and it has a minimal set of features required for working with code, like code navigation, debugging and intellisense.

If the missing parts, above all the extensibility features, are added, then I think that Code can be a successful code editor.

Update: As Tim van Wassenhove and Isidor wrote in the comments, Mono applications can be debugged on Mac OS X and Linux. I wrote a blog post how you can configure VSCode for debugging Mono applications.

Why should you join F# Vienna? Well, there are some reasons:

1. Connect with other developers who are interested in F#! Get to know each other! Drink beer together! Talk about F#!
2. Present your projects! You did something interesting in F#? Or did you learn something interesting? Present your project or teach us at one of our meetups!
3. Learn from other developers! You don’t know F# yet? Well, profit from the experience and knowledge of more advanced developers and listen to one of the talks at our meetups!
4. Help promote F#! You are excited about F#? Bring your colleagues to one of our meetups so that they can see the advantages!
5. Get hired to work on F#! My hope is that companies will see that there are developers who are interested in F# and start more F# projects in Vienna. Knowing other programming languages can be an advantage for your job search as well.

What’s coming up next for F# Vienna?

The meetup group is set up and you are able to join. What can you expect for the next few weeks?

Meeting in May

There will be a meetup on May 15th. It’s a Friday and Andrea Magnorsky will join us to facilitate a Coding Dojo where you can practice F# on a small coding problem.

Meeting in June

The second meetup will be in June. The date hasn’t been fixed yet. Join F# Vienna at Meetup and get updates on our meetups.

Although I’m a C# developer by day, I like to listen to podcasts about other programming languages and technologies, too. Here are my favourite software development podcasts:

• Software Engineering Radio: I highly recommend this podcast to every software developer. The shows are about every aspect of software development and the guests are first-class. New episodes appear every two to four weeks.
• Donau Tech Radio (in German, actually Upper Austrian dialect): An Austrian podcast by Thomas Einwaller and André Steingreß. They talk about gadgets, software development, and programming. New shows appear usually every one to two weeks. You have to understand German or, actually, the Upper Austrian dialect to follow the show.
• Herding Code: Hosted by K. Scott Allen, Kevin Dente, Scott Koon, and Jon Galloway. This show started as a .NET development podcast, but the episodes were about different technologies recently. The episodes don’t appear on a regular schedule.
• JavaScript Jabber: A very interesting show for JavaScript developers. Every week there is a new episode about JavaScript programming.
• The Web Platform Podcast: A podcast about web technologies. Every week there is a new episode about topics like Flux, React, Polymer, Dart, WebRTC etc.
• Functional Geekery: Hosted by Steven Proctor, a highly recommended podcast about functional programming. New episodes appear about every month.
• Mostly Erlang: As the name suggests this show covers Erlang, but sometimes it’s about other functional programming languages, too. There are about 2 episodes every month.
• The Cognicast: In this Clojure-oriented show Craig Andera talks with developers from different Lisp communities like Clojure, Scheme, or Racket. He publishes about 1-2 episodes every month.
• The Type Theory Podcast: Static type enthusiasts must like this new podcast. It is a podcast about type theory and its interactions with programming, mathematics and philosophy.
• The Scalawags: A podcast for Scala developers with very detailed show notes. About 1-2 episodes appear every month.
• .NET Rocks!: Carl Franklin and Richard Campbell do a very amazing show. The first show appeared on August 30, 2002 and they are already at episode #1042! As the name suggests the main topic is .NET development, but there are often other topics, too. Usually three (!) new episodes appear every week.
• Hanselminutes: Scott Hanselman hosts a show for developers about a broad range of topics. Every week he publishes a new episode.

Did I miss a great podcast? Leave a comment and tell me which software development podcast I should listen to!

Do you listen to podcasts, too? Use the comment form below and let us see your list of software development podcasts!

Important Note: ASP.NET vNext is still work in progress and it may not work as intended. Please do not use it in production!

Required Mono Version and Basics of K Runtime

First I installed Mono from source, because the current stable version (Mono 3.4.0) is not sufficient to run ASP.NET vNext applications. This will change when the next stable version of Mono is released. Then I installed the K Version Manager (KVM). KVM is used to manage different versions of the K Runtime the ASP.NET vNext runs on. Graeme Christie and Simon Timms blogged about how to install Mono from source and the KVM.

How you can use KVM to manage different versions of the K Runtime on your machine? Type kvm to see a list of available commands. The most important commands are:

• kvm upgrade: Installs the latest KRE (K Runtime Environment).
• kvm list: Lists the installed runtime environments.
• kvm use: Switches to a specific kRE version.

A Simple “Hello, World” Program

Type kvm upgrade to install the latest KRE. Then create a file somewhere on your disk with the name “project.json” and the following content:

{
  "dependencies": {
    "System.Console": "4.0.0.0"
  },
  "configurations": {
    "net45": {},
    "k10": {}
  }
}

Create another file in the same directory with the name “Program.cs” and the following C# program as content:

using System;
  
public class Program
{
    public static void Main()
    {
        Console.WriteLine("Hello, World!");
    }
}

The first file is the project file. It contains the dependencies and describes the runtime configurations. The dependencies are NuGet packages. You can use the K Package Manager (KPM) to work with the packages. Type kpm help or kpm to get an overview of the kpm commands. Restore the packages by typing kpm restore now and run the program with k run.

When I was experimenting with ASP.NET vNext I ran into some errors:

• “System.AggregateException: —> System.IO.IOException: Too many open files“. Solution: increase the maxfiles limit of your system:

> launchctl limit maxfiles 16384 32768

• “Could not load type ‘System.Reflection.Internal.MemoryMappedFileBlock’ from assembly ‘System.Reflection.Metadata, Version=1.0.11.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a’.System.Reflection.Internal.Metadata” Solution: Check the Mono version with mono --version and make sure that the correct version of Mono can be found in your PATH variable.

ASP.NET MVC Project Generator for Yeoman

An MVC application consists of controllers, views, model and configuration files and maybe other files needed by the program. A scaffolding tool can create new projects from a template or a generator. One of those tools is Yeoman and Hassakarn C. wrote an ASP.NET MVC Project Generator for Yeoman which can create projects for ASP.NET vNext.

If you want to use Yeoman you’ll have to install Node.js. Follow the instructions on its homepage. It comes with NPM, the Node Package Manager, which you can use to install Yeoman and the ASP.NET MVC Project Generator:

> npm install -g yo
> npm install -g generator-aspnet

You can create a new project for the K Runtime by running:

> yo aspnet

Then you can select the type of application you want to create.

If you create a console application, you can run your program with k run. It is the same application we built before without Yeoman.

k run runs the program by invoking its entry point, a static method called Main. An MVC program doesn’t have such a method. When you open the “project.json” file of the MVC application you’ll find a section called commands:

...
  "commands": {
    "web": "Microsoft.AspNet.Hosting --server Microsoft.AspNet.Server.WebListener --server.urls http://localhost:5001",
    "kestrel": "Microsoft.AspNet.Hosting --server Kestrel"
  },
...

This section defines commands which you can use instead of run when you invoke k. As you can see there are two commands defined: web and kestrel. web invokes a server used for self-hosted ASP.NET programs. It doesn’t work on OS X yet. But you can use the alternative Kestrel server which is a libuv-based HTTP server for .NET.

You can run your MVC application with Kestrel with this command:

> k kestrel

The default port is 5000. If you navigate your browser to http://localhost:5000 you should see the default welcome page of ASP.NET vNext.

If you try to start the application with k run you’ll get an error with the following message: “<appname> does not contain a static ‘Main’ method suitable for an entry point“. So make sure that you type the right command for your type of application.

Creating Nancy Projects with Yeoman

Inspired by the Yeoman generator for ASP.NET MVC Jonathan Channon created a generator for the Nancy framework. Nancy is a lightweight framework for building HTTP based services on .NET and Mono. You can install the generator via npm:

> npm install -g generator-nancy

For creating a Nancy project type the following into your terminal:

> yo nancy

The generated project contains a simple Nancy module which is hosted on Kestrel with the OWIN interface. You can start the Nancy application with the k command:

> k kestrel

Using Sublime Text 3 for Working With ASP.NET vNext Projects

One of my favorite text editors is Sublime Text. It can be extended by plugins and Sourabh Shirhatti started working on an extension for ASP.NET vNext, called “Kulture”. He demonstrates the extension in a YouTube video.

You will need Sublime Text 3 which is still in beta and the Package Manager for Sublime Text 3 if you want to try it. Then press Cmd-Shift-P which opens the Command Palette and select “Package Control: Install Package”. Then select “Kulture” from the package list.

The extension configures the Sublime Text Build System for builds with the K Runtime. When you opened an ASP.NET vNext project from the project directory you can build it by pressing Cmd-B. If there are compilation errors you can cycle through them with F4. And with Cmd-Shift-P you can select “Run K Commands” and start one of the commands defined in the project.json file.

Summary

With ASP.NET vNext Microsoft tries to build ASP.NET on a new platform which can be run on UNIX like operating systems like Linux or Mac OS X. In this article I showed you how you can install it and how you can run a simple “Hello, world!” program. I introduced you to the Yeoman scaffolding tool and two generators, one for creating MVC apps and one for creating Nancy apps. Finally I showed you an extension for the popular Sublime Text editor.

It’s interesting to see new ideas coming from the community. I’m curious how the new tools will evolve and how creating applications on ASP.NET vNext and Mono will look like in a few months.

Elm is a functional programming language. Its main influences are Haskell, OCaml, SML, and F#. Elm is strongly statically typed and it uses type inferencing. You don’t have to specify the type for variables and parameters like in C# or Java. Elm is built on the Haskell platform and has a Haskell-like syntax, though semantics are closer to OCaml.

I want to show you some basic features of Elm in this post. I’ll write some more posts about Elm in the next few weeks.

Hello, world!

You will find an online editor on the Elm homepage where you can try out the programming language. Just click “Try” and you’ll get to the online editor. On the left side you’ll see the editor and on the right side the result when you run the program. You can run the program by clicking on “Compile” (below the editor).

We’re learning a new language and the first program in a new language is usually a “Hello, world” program. It looks like this in Elm:

    main : Element
    main = plainText "Hello, world!"

main defines the entry point of the program. It is of type Element which represents a rectangle on the screen with a known width and height. Elements are combined to define complex widgets and layouts. The type is defined in the library Graphics.Element which is imported automatically when the program starts.

The first line of our program is the type signature. It defines the name and its type separated by a colon. The entry point has the name “main” and Element is its type. The type signature is optional.

The second line is the code. "Hello, world!" is a string. The function plainText converts the string to an element. You can see, that you don’t need braces for calling a function.

Here is another version of the hello world program:

    main = asText "Hello, world!"

Did you notice the difference? The second program prints the string “Hello, world!” with quotes and the first program without quotes. The first version uses the function plainText to convert the string to an element. plainText takes a string and creates the Element from the string value.

The second program uses asText which takes any value and uses its string representation for creating the Element. The string representation of a string includes the quotes and the value does not.

    main = asText (4,5)

This program prints the string representation of the tuple, “(4,5)”. A tuple is an ordered list of elements. The tuple above contains two integer values, 4 and 5. If you change asText to plainText you’ll get a type error. plainText expects a string as parameter, but (4,5) is a tuple.

Elm is reactive

Elm has an interesting type called Signal. A signal is a value which changes over time. Let’s see it in action:

    import Mouse

    main : Signal Element
    main = lift asText Mouse.position

The first line imports a library for working with mouse input called Mouse. The second line is the optional type signature. As you can see the type of the entry point main has changed to Signal Element. This means that output of the program can change over time.

The Mouse module contains a signal called position of type Signal (Int,Int). Every time the mouse is moved its value changes. The value is of type (Int,Int) which is a tuple with two integer numbers. It represents the current mouse position on the screen.

The function lift takes a function as first argument and a signal as second element. Every time the signal is updated the new value is applied to the function and its return value is used as new value for the signal returned by lift. We use asText as function so that lift converts each tuple with the mouse positions to a string when the mouse position changes.

I showed you how a basic hello world program looks like in Elm and I introduced you to Elm’s concept of signals. I will focus on the functional nature of the language in my next post about Elm.

• It will be fully open source.
• ASP.NET MVC, ASP.NET WebAPI and SignalR will be integrated into one framework.
• Multiple versions of the runtime can be installed side-by-side.
• It runs on Mono, on both Linux and Mac OS X.
• No dependency on System.Web.
• Better support for development with text editor and command line tools.

I collected some links for more information and details about this topic.

Blog posts about ASP.NET vNext and the K Runtime

• The announcement of the next generation of ASP.NET: The Next Generation of .NET – ASP.NET vNext
• Introducing ASP.NET vNext and MVC 6
  This article provides an overview of the changes of ASP.NET vNext and MVC 6.
• David Fowler’s blog contains much information about ASP.NET vNext:
  • ASP.NET vNext
    David Fowler provides an overview of the goals of the project like requirements and things the team wanted to fix.
  • ASP.NET vNext Overview
    This post contains an overview of the projects which comprise the next version of ASP.NET.
  • Assembly Neutral Interfaces
    In this post David Fowler explains a new feature of ASP.NET vNext which helps simplifying messy dependency graphs.
  • Assembly Neutral Types Implementation
    This post explains how assembly neutral types were implemented. It depends heavily on Roslyn.
• ASP.NET vNext Project K Basic Sample
• Getting Started with ASP.NET MVC 6
• Back To the Future: Windows Batch Scripting & ASP.NET vNext
  Nicolò Carandini introduces us to the new command line tools and the batch file magic one of them uses.
• Louis DeJardin published three parts in a blog post series called “ASP.NET vNext Moving Parts”:
  • ASP.NET vNext Moving Parts: IConfiguration
    In the next version of ASP.NET you will be able to use INI, JSON or XML files for your configuration settings. You can even merge those settings from
    multiple sources including environment variables and command line arguments. This blog post provides an overview over the new configuration subsystem.
  • ASP.NET vNext Moving Parts: IBuilder
    You can modify the request pipeline with the new IBuilder interface and some extension methods. This blog post explains how it works.
  • ASP.NET vNext Moving Parts: OWIN
    OWIN defines a standard interface between .NET web servers and .NET web applications. The next generation of ASP.NET will support OWIN.
    This blog post explains how it works.
• ASP.NET vNext Routing Overview
  This article explains the new routing system used in ASP.NET vNext.
• There was a little discussion about the plans for dependency injection:
  • Dependency Injection in ASP.NET vNext
    Previous versions of ASP.NET MVC supported DI partially. In the future it will be available throughout the entire stack.
  • Feedback on ASP.NET vNext Dependency Injection
    Mark Seemann welcomes the support of DI in ASP.NET, but he opposes the idea of a Conforming Container. He would rather prefer Abstract Factories for
    creating instances of Controllers, WebForm Pages, etc.
• Final Thoughts on Nuget and Some Initial Impressions on the new KVM
• ASP.NET will run on Linux and Mac OS X, too: ASP.NET vNext on OSX and Linux
• ASP.NET vNext and Visual Studio “14”:
  • Getting Started with ASP.NET vNext and Visual Studio “14”
  • ASP.NET vNext in Visual Studio “14”
• MVC Music Store Sample Application

Videos about ASP.NET vNext and the K Runtime

• TechED North America 2014
  • INTRODUCING: The Future of .NET on the Server
  • DEEP DIVE: The Future of .NET on the Server
  • ASP.NET Developer Q&A with Scott Hunter & Scott Hanselman
• dotnetconf 2014:
  • ASP.NET vNext 101
  • ASP.NET MVC 6 (now with integrated Web API!)

Why did I switch to WordPress again? Jeff Atwood said, a blog without comments is not a blog and not having a decent comments system was one of the biggest disadvantages when I used a static site generator. I didn’t want to save the comments on another system operated by a commercial company like Disqus.

I found a way to write my posts in Markdown on WordPress. Not being able to write in Markdown was the biggest issue I had with WordPress and the number one reason why I migrated my blog away from WordPress.

I wanted to improve the themes of my old blogs, but I didn’t have enough time to work on them. I guess it’s easier to use one of the available WordPress themes instead of creating my own theme.

But there are also some downsides: first I need to run server software which needs more server performance than a static site. There are solutions which can improve the situation.

Second I still don’t like the editor. There are blog editors out there. Maybe I’ll try out some of them.

Of course, I had a look at Ghost, but it wasn’t as mature as WordPress. It didn’t have a comment system, too. It looked very nice and promising, though.