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 – 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: HTML5 nears, Rust heads towards 1.0 and Playgrounds examined

developercatchupHTML5 getting closer: Over at the W3C the HTML5 spec has got close with the publication of the Proposed Recommendation of HTML5. By the end of the year, HTML5 will, according to the activity statement and barring madness, be a W3C recommendation. Then it’ll be onto the HTML 5.1 track as it sees a Candidate Recommendation out at in early 2015 and wrapping up in a recommendation at the end of 2016.

Rust 1.0 nears too: Mozilla’s Rust language is about to head into the final straight as plans are laid out for 1.0. Expect a beta 1.0 by year end and a release after that. There’s been a lot of simplification of the language over the last year, but there’s still quite a list of things to integrate before that beta lands, like dynamically sized types, a new closure design, associated types, where clauses and more. Unless you’re a language fan wanting to watch a language evolve, Rust has been interesting by not one for adoption – when 1.0 arrives, we’ll be able to see how it performs and what it finally offers.

Min! Min!: The Min framework is tiny, like 955 bytes of CSS tiny (minified and gzipped), but with lots of HTML5 semantic elements used, no JavaScript needed and a lot of capabilities. With an extra 3.5K plugin, the authors claim full feature parity with Bootstrap, less the Bootstrap look. And all under an MIT licence. Tasty.

Playgrounds examined: Apple’s Xcode Playgrounds are an interesting development for developers in that they are super-interactive environments for trying out code. The folks over at Big Nerd Ranch had a look inside a .playground file (it’s a directory really) to see how the Swift environment is built and looks at how to turn them into a presentation tool for code teaching.

Other Bits: Wayland and Weston updated to 1.6.0, Joyent has some Patterns and other tips for Node.js developers and mess with animated SVG at the SVG Circus,

Developer Catchup: Docker 1.1.0, Rust 0.11.0, Python 2.7.8 and Dropbox Go Libraries

developercatchupDocker 1.1.0: The first post 1.0 update for Docker is in and Docker 1.1.0 now has a .dockerignore mechanism for ignoring file changes, containers that now pause when a commit it happening (rather than messing them up), container log tailing, the ability to feed tar archives to docker build and other changes which should make life a bit easier and more predictable.

Rust 0.11.0: The latest Rust announcement for version 0.11.0 is about smoothing out the type system to allow for dynamically sized types and refactoring the standard libraries to allow for that. It means that language embedded elements like ~ and @ have become library types called Box and Gc that should make the language easier to understand. It all brings Rust 1.0 closer – by the end of the year is the current hope.

Python Updates: The start of July saw a Python update for various security issues – Python 2.7.8 updated the OpenSSL library, fixed mimetypes and UNC paths regressions and blocked an arbitrary code execution hole in CGIHTTPServer. There were also a number of core and library fixes detailed in the release notes. There was no corresponding update for Python 3.x though the CGIHTTPServer issue is scheduled to be fixed in Python 3.4.2 according to the in progress changelog.

Dropbox Go: Dropbox, a big Python user, has also been working with Go and has been moving its infrastructure to Go based code. In the process, they’ve written a lot of libraries to support that work and now they are open sourcing those Go libraries with a 3 clause BSD license. There’s code for caching, an improved error interface, a programmatic SQL statement builder, a memcahce client library, connection management and a space efficient hash library. And they will be doing it the right way – they’ve committed to using the public versions of the libraries inhouse (rather than maintain their own branch). You’ll find the documentation for all the libraries over at

Graduation Snippets – Docker 1.0, RHEL 7.0, Firefox 30.0


Docker 1.0: The Docker container management platform has hit version 1.0 though the major work had been done by version 0.11 – this is the project’s graduation, acknowledging its ready for production. The actual packaging and management software is going to be referred to as Docker Engine now as the announcement is also the signal for Docker (the company) to roll out 1.0 of Docker Cloud, a platform for sharing Docker packaged apps. Actual changes in 1.0 are things like a new COPY command and an improved ADD command for developers and the ability to pause and resume running containers, added XFS support and performance improvements in container removal. Make a note too. Posts 2375 and 2376 are now officially the HTTP and HTTPS ports for Docker. Docker has changes how people think about package and run applications on Linux and all it would need is for major players to adopt Docker and … oh Google’s added App Engine support for Docker to go with its Compute Engine support and then there’s…

RHEL 7.0: Red Hat has rolled out version 7.0 of its enterprise Linux and 7.0 is looking like a cracking release. Top of their highlights, containers and Docker support, XFS as default file system and new caching file systems (Btrfs is still experimental), systemd and new management components and more capabilities to work with Windows domains. The release notes as with all Red Hat releases are comprehensive and cover things like the switch to GNOME 3 on the desktop (while retaining a classic shell). RHEL 7 is the commercially supported upstream for other distributions, most notably the CentOS distribution which is working on its CentOS 7 release – no dates on that yet but it is the first test of the new relationship between Red Hat and CentOS.

Firefox 30.0: Thirty… As Firefox versioning heads out of the twenties, the [release of Firefox 30.0] has brought sidebar button for toolbar, support for GStreamer 1.0, command-E find selected, various developer changes and five critical and two high security fixes. Now it is thirty, Firefox is well on its way to settling down to a boring life where change is mostly about moving the furniture about and keeping an eye on the neighbours. The place to look for excitement is Mozilla’s Servo browser, being developed in Mozilla’s Rust language and is developing steadily.

TypeScript 1.0, IPython 2.0.0 and Rust 0.10 – Snippets


TypeScript hits 1.0: Microsoft’s take on reworking JavaScript, TypeScript, has hit version 1.0 and is now accepting pull requests on the open source compiler (though it’s bug fixes only for now.). Meanwhile, Microsoft have embarked on an open source fest with the creation of the dotNet Foundation, now home to a .NET compiler, micro frameworks, Couchbase for .Net, various SDKs, ASP.NET modules and other stuff. And to top it all off there’s WinJS, a set of UI controls and scaffolding for making Windows applications. Microsoft may be changing, but how effective that change will be is the big question. In the meantime, TypeScript gets to fight it out in the crowded playground that is JavaScript complements/replacements with Dart, CoffeeScript and, lets not forget the next generation of JavaScript, ES6.

IPython 2.0.0: The interactive Python environment IPython, has been updated to version 2.0 and adds interactive widgets, directory naviagation, persistent URLs, a modal UI and security model to its idea of Notebooks as a container for projects. Under the hood, the codebase is now native for Python 2.7 and 3.3 which are also the minimum required versions. There’s lots more changes listed in the release notes or you can just go install it and get into the tutorial which gets you going with the rather clever world of Python powered notebooks.

Rust 0.10 oxidises: Away from the controversies at Mozilla, the Rust developers have rolled out a new Rust release, version 0.10, which continues the steady development of the systems programming language. Changes include the libextra package being broken down (‘misc’/’extras’ libraries are always a bad sign so good to see it go), cross package (crates in Rust terminology) syntax extensions, better smart pointers and I/O handling. As things kick up a notch towards a final version, there’s now a RFC process for changes and nightly releases of binary installers. It’s all still alpha but progress is good – it was recently reported that Servo, the web engine being built on Rust, has passed the Acid 2 test.

Memory and Rust, Byte memories, Self awareness and Ghost moving – Snippets


  • Rust memory explained: Nikolas Matsakis’s talk from on the Rust language and memory offers some insight on the motivations of the Rust developers and how the Rust’s idea of ownership and borrowing balances up the worlds of malloced and garbage collected memory.

  • Classic Byte: has preserved copies of many magazines including this influential edition of Byte from 1981 which introduced the world to Smalltalk 80 and the worlds of object orientation. Read the articles, then look at the advertising to put the whole thing into context. Then have a look at the Circuit Cellar section where you can see how to build a Z8 based tiny Basic computer.

  • Self aware: Talking of Smalltalk 80, there was a language and environment derived from it called Self. That’s still being developed and maintained and version 4.5 was recently released for Linux and OS X. You’ll want to read the Self Handbook if you want to venture on.

  • Ghost progresses: Worth keeping an eye one, the Ghost blogging platform has jsut been updated to version 0.4, now with static pages, SSL support, new loading bars and featured posts. Ghost was Kickstarted last year, is open source (MIT license), built around Node.js and Express and lets you blog using Markdown.