Convert an SVG to a PNG easily:
convert -resize <x>x<y> input.svg output.png
hash -r to rehash an executable that previously was not found and does now exist on your path
nproc tells you number of processing units your Linux instance has available
The JVM will only inline methods if they are less than 36 bytecodes long putting an emphasis on small methods if you want to get the best out of the auto-optimisation at runtime.
Typescript is a typed superset of Javascript that has been released by Microsoft. It is used to write ImmutableJS
LiveScript is a descendant of Coffescript (which I still have a fondness for) but seems to be taking some inspiration from Purescript/Haskell as well.
Got Racket to build in a relatively short amount of time by using the pre-built source package. The default prefix is weird (local to the build location) so remember to set it to be /usr/local if you want it available globally on a machine.
An addition to your bash shell that should make the GOPATH bin directory executables directly available.
export PATH=$PATH:$PATH:${GOPATH//:// bin:}/bin
An addition to your bash shell that should make the GOPATH bin directory executables directly available.
export PATH=$PATH:$PATH:${GOPATH//:// bin:}/bin
It came as a little surprise that Golang is still distributed by Mercurial rather than Git. Had to mentally brush the dust off my hg-fu.
Server-sent events seem really exciting.
There seems to be three ways of doing async web requests in Clojure: ring-async which uses Jetty's async features, Aleph which passes channels to handlers and HttpKit which obtains the channel once the request is in flight.
I have been taking a quick survey of Clojure web frameworks, particularly in terms of their use (or not of asynchronous handlers).
The leading contenders still seem to be Luminus and Caribou. Hoplon seems to be the new Pedestal for completely Clojure development.
I also came across Joodo which seems to be a new framework focussing on middleware features.
So the short summary is that all of these frameworks use Jetty and a lot of their functionality seems bound up with lein ring integration so switching Jetty for HttpKit does not seem trivial.
There seems to be some definite convergence in the Javascript sphere after a period of massive experimentation.
Virtual DOM is a clever idea and here to stay, in fact why not turn it into a proper browser standard?
Two-way databinding doesn't scale and just as with any kind of programming scope and dependencies need to be careful managed. One-way event propagation as per Facebook's Flux pattern may not be the final word on this but it massively clear that simplifying and decoupling change is not optional in complex client-side apps.
I'm doing a talk next week about Mori the library of immutable data structures for Javascript and this week Facebook releases... a library of immutable data structures.
Cue panicked reading... fortunately both libraries have interesting areas of overlap and difference. Essentially both use hashmap tries to create immutable structures without cloning. Both appear to unify collections into sequences and their related operations. Both aim to provide simple memory-reference comparison for changes in support of virtual doms and reactive event streams. Both avoid intermediate forms an allocation during transformations.
Immutable.js is smaller in scope that Mori though with less operations available on sequences. It has also taken an object-orientated interface approach to expose the functionality on the immutable collection types. This seems to be the major point of difference so far and also seems an odd design choice as it limits its opportunity for composition.
Going through the introductions to Angular.JS. On the surface the whole world of factories, controllers and dependency injection seems like a mad trip back to J2EE only this time in Javascript.
Not only that but it's also verbose:
angular.controller('ControllerController', ...)
The issue with Google's Cloud offering is that they can't see themselves accurately in the market. They, despite the infrastructure they've set up for themselves, are actually a fast-follow late entrant into the market.
It's not good enought to point at the engineering superiority they may or may not have. They have to realise that developers are going to compare them to the total AWS experience as it stands today. Not how AWS was when it originally started.
Do programming languages matter?
I think at the very least it is interesting to see that different languages encourage and prevent different behaviours. Depending on the value you put on those behaviours then it is possible to have a value judgement about a programming language that is not purely aesthetic.
I'm interested to see Dropbox's new Python JIT Pyston announced. At first I was sceptic about what the value of yet another JIT was (even backed by Guido).
It is interesting to see the directions they are pursuing and it would be good to maybe seem some consolidation in approaches towards a performant general-use Python interpreter.
Just been playing around with Julia via this quickstart tutorial and wrote a fib function. Win!
Syntax is very Python with optional typing, and blocks denoted by an end keyword.
Disappointed that Mozilla Persona has failed/"transistioned to the community". It was the one federated identity system that felt like it was genuinely dev-friendly.
It is also a shame to see a new entry in the open source, community-support elephant's graveyard.
LightTable's support for Python is not as rich as Clojure's Insta-repl. Things only appear in scope for evaluation if they have been previous evaluated and values only change when they are re-evaluated.
It feels somewhere between Insta-repls and iPython.
After all the praise at Scale Summit (and from other people I respect) I gave the Docker interactive tutorial a bash.
There were a few subtleties that I hadn't grasped like the way that you can "layer" images in the same way you have git commits on a project. Also the container is linked more intimately to the process it runs than I had imagined.
Looks like virtualisation technologies that might actually be usable by the rest of us. Although only running on Linux 3.8 kernels is a bit of blocker at the moment. I would love this on OSX and allow us to get away from the OSX-Linux disconnect.
A few myths about microservices:
I built my own browser for the first time since Gecko back in the late Nineties, I wanted to give the new Servo build a go.
It built pretty quickly and managed to render a test page but with no CSS or Javascript support it seemed to barf on most actual sites.
Starting to play around with React. I found JSX off-putting at first but the reactive paradigm and virtual DOM are pulling me in.
Playing around with the live JSX compiler is also interesting for understand what the value of the syntax sugar is.
Interoperating Java and Akka's expectations of concurrency seems very difficult. I'm not sure that going async by default is a very human-friendly thing to do.
I'm not sure I like the inconsistent assignment operators in Go. := is the initialiser operator but then values in mutable collections are assigned with just =
I gave Rust a quick go on the weekend. It's more interesting than I thought, I like the idea of everything being an expression and the emphasis on immutable data structures was unexpected but makes sense in light of its co-routine lightweight concurrency.
There is a definite kinship with Go but Rust feels more "modern" at the moment.