How to blink a light in 10 different programming languages

You may "How to blink a light extremely inefficiently 10 different ways." ;-)

Seriously, not even one Asm example? If you have a PC that has a parallel port and can boot to DOS, you can stick a LED in series with a 100-ohm resistor across pins 2(+) and 18(-) and do this:

        mov dx, 378h
        xor ax, ax
    blinkloop:
        out dx, al
        mov cx, 36
        call delay
        not ax
        jmp blinkloop

    delay:
        hlt
        loop delay
        ret

I find it somewhat amazing that this program, in Assembly, is actually shorter than the 10 HLL programs in the article.

C#

https://dotnetfiddle.net/afyTvh

    using System;
    using System.IO;
    using System.Threading;
					
    public class Blink
    {
    	const string FilePath = @"/sys/class/leds/beaglebone\:green\:usr0/brightness";
    	const int BlinkDelay = 2000;
    	
    	public static void Main()
    	{		
    	    using (var writer = new StreamWriter(FilePath))
    	    {
    	 	for (var state = true; true; state = !state)
    		{
		    writer.Write((state ? 1 : 0).ToString("00"));
                    Thread.Sleep(2000);	
    		}
    	    }
    	}
    }

Reactive Extensions (C#)

https://dotnetfiddle.net/bpOF5e

    Observable
	.Repeat(Observable.Unit)
	.Select((index, _) => index % 2)
        .Select(string.Format({0:00})
	.Delay(TimeSpan.FromSeconds(2))
	.Aggregate(
	    new StreamWriter(@"/sys/class/leds/beaglebone\:green\:usr0/brightness"), 
	    writer => (writer, state) => writer.Write(state)
	)
	.Subscribe(writer => writer.Close());

I am disappointed. I opened this article expecting a myriad of MOVs and JMPs, PEEKS and POKEs, &s and *s, <s and +s, DOs and GO TOs. These are all languages that borrow a lot from each other, and as such look mostly the same. We need some variety in here, some zing. Give some FORTRAN IV, some COBOL, some BASIC even, and it could be interesting, especially if you add in how to do it with raw io; sysfs is ugly and boring.

The bash example should have set -e or #!/bin/bash -e so that it will exit on error. That or the rest of the languages also shouldn't bother to check for errors. Also rather than invoking another shell use let and do let STATE=1-$STATE just like all the other programs. And why does bash need to have comments. Maybe it was a subtle joke that C doesn't get comments, but bash does :D in which case well played.

  #!/bin/bash -e
  STATE=1
  while : do
   echo $STATE > /sys/class/leds/beaglebone\:green\:usr0/brightness
   let STATE=1-$STATE
   sleep 2
  done

While all of the programs can be made smaller in size the bash script is probably the default way that the script would be tossed together. Bash has a ton of problems, but sadly between it and the standard unix commands you can get the job done too quickly and easily.

With JavaScript (nodejs)

  var lightsOn = true;

  setInterval(blink, 2000);

  function blink() {
    var fs = require("fs");
	
    fs.writeFile("/sys/class/leds/beaglebone:green:usr0/brightness", lightsOn, function (err) {
      if (err) throw err;
    });
	
    lightsOn = lightsOn ? false : true;

  }

And in Haskell (feel free to include this):

    import Control.Concurrent (threadDelay)                                         
    import System.IO

    main :: IO ()                                                                   
    main = withFile "/sys/class/leds/beaglebone:green:usr0/brightness" AppendMode go
      where put h s = hPutStrLn h s >> threadDelay 2000000                          
            go  h   = let m = put h "0" >> put h "1" >> m in m

Ruby example is not very idiomatic. Give File.open a block and it'll handle closing it. Instead of flushing the file every time, you could just set file.sync = true once.

Also, if one was going to use the ensure block, use nil? not '== nil'

Dart:

  import 'dart:async';
  import 'dart:io';
  main() {
    var file = new File('/sys/class/leds/beaglebone:green:usr0/brightness');
    var state = 0;
    new Timer.periodic(new Duration(seconds: 2), (_) {
      state = 1 - state;
      file.writeAsStringSync('0$state', flush: true);
    });
  }

While it's not the most concise version, it's certainly very readable. Everyone can clearly see that the duration is 2 seconds and that that boolean flag is for flushing, because that's exactly what the code says.

A bit more compact go-version:

    package main

    import (
    	"log"
    	"os"
    	"strconv"
    	"time"
    )

    func main() {
    	f, err := os.OpenFile("/sys/class/leds/beaglebone:green:usr0/brightness", os.O_RDWR, 0666)
    	if err != nil {
    		log.Fatal(err)
    	}
    	defer f.Close()

    	state := 1
    	for i := 0; i < 3*2; i++ {
    		_, err = f.WriteString(strconv.Itoa(state))
    		if err != nil {
    			log.Fatal(err)
    		}
    		time.Sleep(2 * time.Second)
    		state = 1 - state
    	}
    }

The Ruby example doesn't handle exceptions with the same granularity as Java example and is therefore much shorter. Please do not compare the examples.

Bonescript is pretty simple as well:

    // npm install bonescript
    var b = require('bonescript');
    b.pinMode('P8_13', b.OUTPUT);
    b.digitalWrite('P8_13', 1);

Pretty sure Bonescript is just doing the filesystem stuff under the hood, though doing memory mapping would be way nicer.

Alternatively one could use the Arduino API on the beaglebone with https://github.com/prpplague/Userspace-Arduino

It would make the whole thing less scary for beginners and there are tons of examples and documentation out there.

I find using name-spaces in imports makes the code a hundred times easier to reason about.

First example seems like it would want >, not <

How to open a file in 10 different programming languages.