Node.js and Docker realigned

sporkIt’s not really a surprise, but after just over six months since the “forking” of both Node.js and Docker, the two different projects have ended up back in some sort of alignment. For Node.js, it was the reunification with io.js under the Node.js Foundation, which was officially launched under the Linux Foundation’s umbrella. The Node.js and io.js technical development is now driven by a technical committee and hopefully this will all work out well for all.

The Docker situation is a little more complex. There’s no big group hug like with Node.js. Instead, there’s an official middle ground, the Open Container Project. The announcement of a vendor-neutral (how can it be vendor neutral when it’s founded by vendors?) project to come up with containerisation technology basically sees Docker throw its specs and CoreOS throw its specs for containers into the same ring and see what comes out.

OCP says it’ll try and come up with a future spec independent of what’s layered on top of it, not associated with any project or vendor and be portable. So no, there won’t be a standard command set or management layer, there shouldn’t be any lock-ins and there probably will emerge as standard with a scope so small that it’ll end up as a tiny checkbox on a requirements list.

On the plus side, with that out of the way, there’s room for people to get innovating with the rest of the containerisation stack, which is where all the vendors are heading right now. That list is long too – Amazon, Cisco, EMC, Fujitsu, Google, IBM, Red Hat, VMWare and more. With the essential core in neutral hands, the game always moves on. As for the spec itself? Keep your eyes on the OCP’s Github Repository where they say they’ll have something by end of July.

Let’s hope that OCP keeps to its goals better than that other OCP, you know, the one that was building Delta City in the soon-to-be ruins of Old Detroit. That just didn’t work out well at all.

Node.js and Docker realigned

Developer Catchup: Rust 1.0 and Node reunification

Rust wakes updevelopercatchup

First up, Rust has reached version 1.0, though this is an announcement that was hardly unexpected. It has a lot to live up to given the Rust web site goes for such unloaded language as “blazingly fast, prevents nearly all segfaults, and guarantees thread safety”. The real test for Rust, at least for me, is how well Servo, Mozilla’s browser written in Rust and the application Rust was created with in mind. It seems this is the best possible test case, so…

There’s already a minimised ARM port which looks to bring Rust’s safety features to RTOS/embedded environments and I’ve come across some systems programmers who are interested in Rust, but not noted much momentum. Rust is living in the higher 50 (51-100) of the Tiobe index which is a very approximate guesstimate at momentum, but better than nothing. What this says to me is that despite arriving at 1.0 complete with packaging system and more, Rust is going to have a long journey ahead of it.

Node reunifies

Back in December, when Node.js and io.js forked, I expressed the hope that it would be a positive fork. Well, now that fork is coming to an end with the reunification, under the umbrella of the Node Foundation. Except there won’t be any merging of code and the io.js repository is being turned into the node.js repository.

Io.js folks will join the Node Foundations technical committee and, going forward, the next Node.js will be based on Io.js code. It’s well done to Io.js for taking action and making good practical and solid engineering steps that made it practically a no-brainer to take Node.js forward. We don’t seem to be completely done yet. The structure for future releases and development still needs nailing down.

So here’s looking forward to the next two releases of Node.js… the one which brings us all Io.js’s improvements like an up-to-date V8 JavaScript engines, and the one after which will probably come with more detail on how the desire for a faster development cycle and the need for stable long lived versions will be sorted out.

If you are looking to get your head around ES6, the next and arriving generation of JavaScript, try out Understanding ECMAScript 6, which is a CC-NC book via LeanPub – currently 30% complete and already full of useful details.

Developer Catchup: Rust 1.0 and Node reunification

Arduino IDE now boarding for all

ArduinoZeroThe Arduino IDE is heading into a rather neat consolidation of the numerous Arduino inspired boards out there. The introduction of a mechanism, in version 1.6.2, to allow people to plug their boards into the IDE easily is starting to snowball. To understand why this is important, before 1.6.2’s release if you had a custom board and the tools to make it work with the IDE, then to install them involved copying files into directories, editing files and crossing fingers (and being disappointed often). Anyone who used a lot of boards would find themselves with multiple copies of various versions of the IDE just to keep life simple.

It didn’t really register with me though that when the board manager arrived in the 1.6 version of the IDE how important this would be. Firstly, official board support can be diconnected from releases of the IDE. One of the most recent changes in the Arduino world is the adoption of the Adafruit Gemma as an Arduino board. The Gemma’s a tiny board ideal for wearables, but setting up the IDE was the same nonsense as described above. And then Arduino IDE 1.6.4 arrived with official support through the board manager.

But that wasn’t all. The officially supported boards can now be joined by unofficial board support – just enter a URL and boom – you are downloading the appropriate code for your new board. But what URLs are available you wonder. The Arduino folks give a link to unofficial board support URLs and there’s some interesting boards on there. Adafruit’s boards like the HUZZAH ESP8266*, the Ariadne bootloader for ethernet connected boards, a whole set of ATtiny boards…

And barebones Atmel controllers which means you can make and program devices for the close to the price of the chip, like the Shrimp. Oh, its an exciting time for Arduino…

*More on the HUZZAH when I get to pick some up in the US soon.
**Apologies for the low number of posts… trying to fix that.

Arduino IDE now boarding for all

Making Catchup: Node 0.10.6, Pi Power, Arduino IDE and adapting ESP8266s

makingcatchupNode-RED 0.10.6:  Nick O’Leary has announced Node-RED 0.10.6 with various changes to the editor, nodes and API. If you don’t know Node-RED, it’s a rather graphically splendid way of wiring the internet of stuff and stuff in general together – I did a few bits with it on here. With this release, there’s also a new command line administration tool for Node-RED so you can control nodes without having to restart the entire process…. and that uses an Admin API which is now stable and documented. There’s also been a switch in versioning to an easier to track odd/even (development/released) scheme. I’ll be getting back into Node-RED soon myself, ideally when it supports Node 0.12 – currently you’ll need a Node 0.10 to hand to run it.

MOAR PI POWAH: The Raspberry Pi 2 has a lot more power than the older version in terms of CPU, but those USB ports are still pretty power anaemic. By default the total power draw can be 600mA, tweakable in software to 1.2A. That tweakability led to this fine Hackaday hack which involves swapping some components on the board to get a full 2.1A to the USB ports, 500mA a port. The reason the USB is so weedy is good; the Pi is designed to be powered by a Micro-USB connector, so available power is that minus the CPU. Not a lot. And now you have a reason to buy a decent PSU for your Raspberry Pi. The official PSU pushes out 2A into the microUSB.

Arduino IDE gets its groove back: After ages spinning its wheels, the Arduino IDE 1.6 came out and surprised many people. Even more surprising is that its getting new features and quickly. In the March 28th release Arduino IDE 1.6.2, the latest features as a Library Manager which can install from Github repos and a board manager which should make adding new boards much easier. These have been two real pain points in the IDE so to see them addressed is great news. The really great news though was that by April 2nd, the team had released Arduino IDE 1.6.3 which addressed various bugs and responded positively to feedback making it even easier to adopt and use.

ESP8266 adapting: A breadboard adaptor design for an ESP8266 in Makezine since the little ****ers don’t like going into breadboards. Is anyone making these for sale in the UK? Let me know!

Making Catchup: Node 0.10.6, Pi Power, Arduino IDE and adapting ESP8266s

Developer Catchup – Redis 3.0.0, ES5to6, Atom Pairs, Rust and Coherent

developercatchupRedis 3.0.0: Antirez (Salvatore Sanfillippo) brought us Redis 3.0.0 on April 1st (and I salute him for ignoring the worst day on the Internet by doing real things). The big thing with 3.0 is clustering, better smarter clustering that is, out of the box and good enough scalability and fault tolerance for many use cases. It’s a big jump, and it may take some iterations to nail it down but its worth it for the usefulness that Redis represents to a system architect.

ES5 to 6: There’s lots of transpilers which turn your ES6 JavaScript into ES5 JavaScript so it can be run anywhere, but a new project on Github, xto6 wants to turn that around and take your ES5 JavaScript code and turn it into shiny ES6 style code with all its shiny classes and accessors and more. No idea yet how this would work in the field, but it may help when you’re getting your head around ES6…. it’s the future you know.

Atomic Pairing: If you use the Atom editor (I do) and you like to pair, you may be interested in AtomPair which uses HipChat or Slack and Pusher to let developers pair (or more) inside the editor.

Rust 1.0 nears: Rust 1.0 hit beta – We’ll talk more about that at 1.0 time…

And Finally… Coherent: Long ago there was a Unix (cough) like OS for 286 and 386 PCs called Coherent. It worked in a wonderfully limited way (apparently using the CPU’s 64K paging tricks) and it disappeared into history. But now the Coherent source and other software from Mark Williams Company have been released under an open source license. Don’t expect to dash out and use them, but its a fine historical artifact to be able to now look inside.

Developer Catchup – Redis 3.0.0, ES5to6, Atom Pairs, Rust and Coherent

Disque, Tiny JavaScript, ESP8266 Notes, Tails, GCC5 and Go: Developer Catchup

developercatchup
Disque: Antirez ,the man behind the splendid Redis in-memory key/value store has been working away on a new message broker called Disque. He’s not released it as yet, but he is giving status updates on his progress and thinking. Redis gets used a lot as a message queue and Disque, developed by gutting then rebuilding a Redis fork, is designed with a focus on that use case. There’s plenty of message queue platforms out there, but Antirez has a good record on delivering so this is very much one to keep tabs on.

Tiny JavaScript: There’s lots of ways to run JavaScript inside your own applications, but they do rely on some pretty industrial scale wedges of code to be grafted into your code. So, what’s your options. Well, you could always use Duktape, an MIT licensed library written in C/C++. I came across that while looking at MuJS, an interpreter for JavaScript, written in C with a simple binding API. MuJS’s is a little more limited in its deployability being under a AGPL licence but it’s good there’s two different JavaScript in C implementations out there. It’s at this point someone mentions Lua and then the fighting begins.

ESP8266 guidance: I’ve been playing with the ESP8266 and its variants. Crazy powerful WiFi chip with versions packed with GPIO. The documentation and tools are something else though so it’s alway good to find a good blog article covering the toolchain like the one on WhatIMade.today. It goes from powering up to loading Lua code and onwards to using the ESP8266 with a graphic equalizer to then feed a strip of RGB LEDs.

Tails 1.3.1: There was an unscheduled Firefox release to deal with a PWN2OWN bug and that’s meant an unscheduled release of Tails 1.3.1, the amnesiac Linux for anonymous working.

GCC5’s final lap: Seems that the venerable GCC compiler collection is heading into the final lap towards version 5 as its down to 7 P1 bugs and a planned release candidate in April.

GoGo: Spending more time with Go here so here’s some Go snippets…

  • Want to build your own Go-based Torrent applications? Then Anacrolix’s Torrent should be where you want to look.
  • Want a cross-platform GUI for Go? Seems some Googlers started experimenting with making one called gxui and have the code up on Github for folks to work with.
  • Want to work on a JVM in Go? Then zxh0’s jvm.go may be up your street – although “far from complete” it’s already interesting. It implements Java’s GC using Go’s GC but there’s still plenty to do.
  • And finally there’s gosrc.org which sets out to be a better godoc.org with fully linked source code and cross referencing.
Disque, Tiny JavaScript, ESP8266 Notes, Tails, GCC5 and Go: Developer Catchup

Snippets: gRPC, iPython, LLVM, Pi Trees and Juice,

snippets03gRPC: Google, doing it’s whomp-here’s-a-“standard” thing, has just announced an open sourced remote procedure call framework called gRPC. With libraries for seven languages (C, C++, Java, Node.js, Python and Ruby are done – ObjC, PHP and C# coming), gRPC gets you to use Protocol Buffers to define the end points and serialisation and the libraries then use HTTP/2 to communicate exploiting the bidirectional streaming and multiplexing. There’s an new alpha of a version 3.0 of Protocol Buffers to go with it too. They may be going evil but they do produce some great engineering so this is one to watch.

iPython 3.0: Interactive shells and books are wonderful things – beyond REPLs, they let people work different with languages and data, moving from a scripted . So it’s good to see the iPython project release a iPython 3.0 and lay down the foundation for language-agnostic notebooks. This is the last monolithic release of iPython, which pulls in a host of different language kernels into the project, including Bash, Haskell, Go and even Redis. But the next stage will be to split the project into a pure Python related stuff called iPython which will also produce a kernel to plug into Jupyter, an interactive notebook environment for multiple languages. Thats a journey that starts with iPython 3.0. If you like the idea of a shell/notebook environment, start following this project as it evolves.

LLVM 3.6 Lands: The new compiler juggernaut that is LLVM rolls through another release as version 3.6 is released. According to the release notes there’s lots of tidying up and updating and quiet adoptions like the Go bindings from gollvm being introduced.

Pi Device Trees: The Raspberry Pi’s Raspbian release that arrived the the Pi 2 also came with the added bonus of switching to Device Trees which is a way of modelling and talking to the bazillion different hardware combos out there in a unified way. The Beaglebone Black’s Debian has had it for ages and now it’s the Pi’s turn. There’s a whole load of things to get your head around but this posting on the Pi forums will get you through enabling I2C, I2S, SPI and more using DT.

PiJuice: Talking Pi, there’s a nifty Hat-sized Kickstarter for a device called a PiJuice currently running which lashes a standard phone battery, real time clock and UPS and other handy things into a £24 hat so you can take out Pi walkies. It’s also pinned so you can pop another Hat on top. Looks very clean as a design.

Snippets: gRPC, iPython, LLVM, Pi Trees and Juice,