HTML5 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.
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,
Node.js synchronously: Node.js is sweet if you can adapt to the asynchronous model of start thing, say what you want to do when its done, do everything else anyway. Good for web request handling but bleh for trying to emulate a shellscript. Turns out that in Node.js 0.12 (coming soon? anyone? Bueller?) we get synchronous child processes to now you can run that curl or find or whatever and just wait till its returned with its results. The folks at Strongloop have written about these synchronous child process methods and how they make writing command line utilities in Node easier. Check it out Noders.
Serviced Polyfills: Polyfills fill gaps in browser functionality and standards compliance. The older the browser, the more Polyfill you need to fill the gaps and the newer, the less. But it gets hard working out how much Polyfill you are going to need. Fear not, as Samuel Giles at FT Labs has an answer, “Polyfills as a Service“. Add a simple script tag pointing at a source from the polyfill.io content delivery network to your pages and whatever browser views your page, it gets the polyfill it needs. This is because the system sniffs the browser agent and works out the best set of polyfill based on that. Neat idea, potentially very handy – and you can run your own private version if you need to.
Spark sparks: Apache Spark just got a 1.1 release. Spark is Hadoop data processing engine which can run on YARN-based Hadoop clusters or in standalone mode. Spark 1.1 improves the performance (and they already say they are up to 100 times faster than Hadoop MapReduce) and has SQL layer enhancements. 1.1 also adds more statistical functions, can take steaming data fromAmazon Kinesis and pull data from Apache Flume and more. If your into clusters and data crunching and haven’t looked at Spark, you might want to look into it.
Tangram Mapping: Do you want to render cool 2D and 3D maps? Check out Tangram, a Mapping Library then as it is building out from a WebGL implementation to other OpenGL platforms to make oodly cool dynamic map renders. Very slick.
SHAaaaaaa!: We mention the Google sunsetting of SHA-1 the other week. If you were unsure why this was important, can we send you off to Why Google is Hurrying the Web to Kill SHA-1 which explains why it all and includes a brief history of collision attacks in the wild.
ECMAScript 6: It’s coming, for mid 2015, and its full of features. In this (https://www.youtube.com/watch?v=G21rdWfa_as), Alex Rauschmayer talks about all those features. If you prefer slides they are available too. It covers most of the language features (skipping promises and proxies), outlines the timetable for standardisation and how you can use ES6 features now. Bonus link, do checkout his blog.
Policy and Scala: Scala has been forked, and forked by one of its most active contributors. The fork, called Policy, is one of those forks which hopes to be folded back into the original because “The leadership of scala has shown itself unfit stewards of the core technologies and the total price paid by scala programmers (actual and potential) is too high. I failed for half a decade to change that from the inside. Now I’ll try from the outside”. The initial reception seems positive and the Hacker News thread is full of background. One to watch.
More JSON in Postgresql: Postgresql has some neat JSON support built into the database, but one developer wanted it somewhere else – in the logs. Michael Paquier shows how to make Postgresql emit JSON logs hooking in a JSON log function at runtime. The code can be found on GitHub in a repo of other plugins. Why JSON logs? Well, it does make it easy for a JSON aware system like Elasticsearch to analyse and search those logs.
SHA-1 Sunset Now: Back in 2005, SHA-1 was tagged as “weaker than it should be” as a crypto algorithm and its only got worse since them. So people are slowly stopping its use. Google has just announced its SHA-1 sunset which begins this month with Chrome 39 flagging sites with SHA-1 signatures that expire in 2017 and beyond as ‘secure with minor errors’. By end of 2014 that window will expand into 2016 and in 2015 those sites will come up with an straight error. Of course, thats just the Chrome and Chromium browsers… Google will have plenty of engineering to do to completely remove SHA-1 from their systems. Next time your doing crypto work, remember to have un-SHA1-ing on your todo list.
Let’s go fly a Kitematic: There’s plenty of command line tools for Docker and command line driven ways to run it on Mac OS X. The latter’s harder because you need to run a VM and load it with an image and… well there’s boot2docker to help but… Enter Kitematic which takes the previous tools and rolls them with a neat UI and some extra neat tricks to make it a lot easier to start playing with the idea. Among those tricks are things like automatically creating an [appname].dev DNS entry so you can quickly connect to your new apps when they are up and running. If you like to run GUI tools alongside terminal sessions on your Mac, you might want to give Kitematic a go.
Versioning wars: Yes, people are arguing on the Internet and this time its over versioning. Some years back, Semantic Versioning appeared and set out some rules for when to bump the major, minor and patch numbers in a version number to embue it with some meaning. While this works for libraries where the consumer is often another program, it works less well with code to be consumed by people. The argument starts on Underscore’s Github where breaking changes as fixes were causing friction over what the version should actually be. This spilled out onto Hacker News which lead to the suggestion that “Semantic Versioning Isn’t” and back to HN where people continued to disagree. But it did get Fear-Driver Versioning (ferver) and the idea of romantic versioning a moment in the sun. From what I see, SemVer works but it does require discipline and transparency from the developers and the consumers of that code. Still… Developers eh?… because those bike sheds won’t pick what colour they are going to be by themselves.
Old School on a Pi: Want to run old school stylee? We’re talking Unix V5 here. Matt Hoskins has updated his 2005 presentation on how to do this (think PDP emulation and similar) so you can now do it all on a Raspberry Pi. Read on to learn the true old ways of Unix.
ChainDuino: An interesting Arduino varient now gathering funds on Kickstarter is the ChainDuino project. Simply put it allows a number of Arduino-style microcontrollers to be chained together over CAT5 cable with that cable delivering power, using a passive Power over Ethernet mechanism, and communications, using RS-485.
This could be incredibly useful in creating a large area sensor net (current max, 32 boards) as it can stretch for up to quarter of a mile and there’s no need for power sockets along the entire length apart from where you inject the power. The ChainDuinos have two RJ45 ports on them for chaining or an IDC connector for cutting into a long uncut run of cable. That does mean there’s no space for USB on these boards so they’ll need programming over an FTDI(serial) connection… there’s no programming over the wire yet but its on the todo list. There’s also a Mega version of the board for more I/O and plans for a shield. An intruiging way of getting Arduino controllers connected.
HackADay bits: HackADay always has interesting stuff. Things that caught my attention this week are:
* the 68008 bootstrapped by an Uno – check out that breadboarding. It’s not a new technique a friend noted pointing out the Amstrad PCW8256’s Z80 was also bootstrapped from a microcontroller, the keyboard controller to be exact.
* a touch screen that balances balls – the ball rolls on the resistive touchscreen and an Arduino then rebalances it according to where it senses the ball.
Hats for Pis: Arduino’s have shields, BeagleBone’s have caps and Raspberry Pi’s have those-thingys-that-plug-onto-the-IO-pins. Well, thats how it was, but it seems the Pi folks have set out to change that with HATs – Hardware Attached on Top specifically for the Pi B+ with it’s 40 pin IO. The B+, unlike its stable mates, has mounting locations for screws with these add on boards and a specification for the board. So we get stability, physical and electrical. And now Adafruit are going all out prototyping HATs. Here’s a proto-board HAT, a GPS HAT, a TFT HAT, an Arcade HAT and a servo HAT… they aren’t available yet, but there’s going to be plenty of HATs to choose from in the future.
ODROID-W: Hardkernel are more known for their Exynos based single board computers which pack quite a punch in a small space – enough that a meaty heatsink is needed. But their latest product eschews the Exynos chippery for a Broadcom chip, the same chip as the Raspberry Pi. The ODROID-W is apparently the result of a wearable research project which saw Hardkernel minimise the Pi design down to a wearable module. This module loses Ethernet, switches to a MicroSD slot and micro-HDMI then adds an eMMC socket, real time clock and battery booster and packs it into a tiny board. It’s rather neat and if you want more ports, there’s docking modules with or without touch TFT LCD screens. It’s one of the more interesting additions to the Pi ecosystem and I’ll have more to say about it when they arrive at Codescaling.
ODROID-VU: While looking at the Odroid-W, I noticed the Odroid-VU. This is a 1280×800 9″ multitouch display with USB and HDMI connections which seems to be joining the race for who can make the all-purpose hacker-maker portable screen.
BeagleBone Black GPIO: BeagleBone Black’s have a lot of IO capabilities and it can be a bit daunting taking it all in. So Kilobaser’s BBB GPIO tutorial is a great place to get a handle on all these pins and how to control them from Linux.
BeagleBone Black Tutorials: Another useful resource is Logicsupply’s Inspire blog where various handy articles have been appearing like this one on how to drive OLED displays fromC/C++ or making Xbee work or this one on web controlling LEDs using a smartphone.
Two Gameboy-a-likes: There seems to have been a little resurgence in the idea of emulating the classic Gameboy.At the start of the month, Adafruit introduced the PiGrrl which used a 3D printed case, a hacked up SNES style controller, a Pi and an Adafruit TFT display as the screen. It’s a fine project and on my “may do” list but it was the second Pi project which really impressed me. The Super Pi Boy eschews hip niceties of 3D printing and crams the electronics in an original Gameboy case for that authentic feel. The screen is an interesting hack too, taking a vehicle reversing screen (they are cheap) and converting it from 12V to 5V to wire into the Pi’s composite. It’s a tale of roughly hewn modifications but a good read.
Routing for freedom: The EFF are campaigning for safer networking and as part of that they’ve announce the alpha developer release of Open Wireless Firmware which should eventually offer something better than the bag of holes your typical router firmware is. Currently it only runs on the Netgear WNDR3800 so you’ll want one of them if you want to hack on it, unless you want to port it to something else.
Sparkfun with data: Sparkfun, makers of many fine hackable gadgets has announced a data service at data.sparkfun.com which can hold 50MB of data (rate limited to coming in at 100 update per 15 minutes). Posting data to it is as simple as composing a URL with a string appended. It looks great for experimenting with IoT concepts without diving in to full message queues and protocols. Behind the service is Phant.io, an open source platform you can set up yourself if you want.
Roboceratops rocks: Hackaday points to a project, in early development but looking fine, Roboceratops that is creating a robotic dinosaur. I can’t wait to see how the beast looks when it’s fully autonomous and fleshed out.