Most interesting links of July '13

July 31, 2013
This month focuses on languages and approaches (reactive programming, F#, Erlang, FP talks etc.), agile (need for speed, recommended books), Clojure/Linux/cloud tools and libs.

Recommended Readings

Development, agile
  • The Need For Speed - the top 10 reasons for fast development flow (with time to market being one of the less important) - more learning, focus on the MVP, focus on the puprose/goal, happier customers/leadership, better quality (sic!), higher morale (I concur!), push for cotninuous improvement, "one of the only sustainable differentiators"; => "sense of urgency and motivation"; "[..] I continue to meet people and teams that not only move very slow, they don't understand the relationship between speed and innovation, or speed and quality."
  • agile42 Summer Reading List 2013 - books recommanded by experienced people/agile experts - lot of interesting stuff! Topics: Communication and Coaching (f.ex. Practicing Nonviolent Communication), Business (How Great Companies Get Their Mojo from Maslow ,..),  Learning From the Military, Agile and Technology (e.g. The Art of Action: How Leaders Close the Gaps between Plans, Actions and Results), Agile and Technology (f.ex. The people’s Scrum)
  • Dan North: Are we nearly there yet? - optimize for time to business impact; SW dev as mountaineering (impossible to estimate correctly, many unknown details, dead ends, ...); go fast - but sustainable; the tyranny of backglog (there are multiple paths to the top yet backlog defines only one; have you ever considerably changed it?) "Instead we could embrace the fact that today we always know more than we did yesterday, and that tomorrow we will know even more. We can take a fresh look up the mountain every time we pause to regroup, to plan." => we ask 1) what gives us the shortest lead time to business impact? 2) what can help us to learn/invalidate more? 3) how to assure our stakeholders we are approaching the goal?
  • Joel on Software: Software Inventory (7/2012) - a classical article about the evilness of software inventory (backlogs, issue trackers, undeployed features, ...) 'When I hear about product teams that regularly have “backlog grooming” sessions, in which they carefully waste a tiny amount of time and mental energy every day or every week thinking about every single feature which will never be implemented, I want to poke my eyes out.'
  • Job satisfaction self-test: Twelve questions that define a great place to work - check yourself how satisfied you are with your job (example questions: How well do I know what is expected of me? How often in the past seven days have I received recognition or feedback on my work? How much does the mission/purpose of the company make me feel like my work is important?)
  • Coaching Anti-Patterns: Prescriptive Agile - a prescriptive coach "knows" what is "right" and forces it onto the client, without listening to her; instead, we should "Meet them where they are and leave them in a better place" => "[..] my first responsibility is to understand how and why they came to this practice. How did they come to this decision? What challenges does this approach address? What benefits are they optimizing for?" Worth remembering AND practicing :)
Languages, paradigms, approaches
  • Bacon.js Makes Functional Reactive Programming Sizzle - a nice introduction into Bacon.js that brings Functional Reactive Programming (FRP) to JavaScript and helps thus escape the callback hell. Reactive programming has been made popular by Microsoft's Rx and recently ported to Java as RxJava by Netflix. FRP is a subtype of RP with functional concepts (map, filter, immutability, ...). It provides a much cleaner way to handle multiple independent sources of events and reaction to those events, the main concepts are composable Streams of events and Properties, whose values are automatically updated based on a stream. Bacon.js Tutorial Part I : Hacking With jQuery provides a nice example of the complexity and ugly code you can run into without (F)RP even for a simple interactive web form, the Tutorial Part II: Get Started then shows the nicer Bacon.js solution.
  • The Trouble with Erlang (or Erlang is a ghetto) - an objective criticism of Erlang by somebody who seems to be quite experienced with it; as I know very little about Erlang, it was interesting to learn about its weaknesses (no map/dict data structure, slow memory management, poor "JIT," not usable for shared-state concurrency (contrary to e.g. Clojure), immutable state is not necessary and makes some things bad, inconsistent and ugly standard lib, ...)
  • Adventures in Multi Paradigm Programming - different programming paradigms/approaches re-implemented in Emacs Lisp - interesting 1) to see and compare these different approaches and 2) the flexibility of Lisp. Including iteration - Ruby's map, Python's list comprehension ([an_expression for x in list]), Scala's default argument (_); search - Java's for; arguments: direct, variadic (i.e. any number of args), named args; destructuring and pattern matching in CoffeScript/OCaml style; Haskell-like monads; objects with mixins;  namespaces.
  • Why bugs don't like F# - no nulls, immutable data, strong type system, composition of small functions, asynchronous programming abstractions, higher-order functions over collections (no off-by-one), units of measure
Other
  • IBM high-fives Netflix open-source tools - it is interesting to see the spreading of Netflix's open source tools for better cloud infrastructures; f.ex. "Karyon, is what Netflix calls the base container for applications and services built using the NetflixOSS ecosystem; Eureka is mid-tier load balancing; Hystrix controls interactions between myriad distributed services to nip cascading failures in the bud;  and Ribbon is a Remote Procedure Call library."
  • ZeroMQ instead of HTTP, for internal services (with implementation in Clojure) - an interesting idea of using ZeroMQ - the sockets on steroids library - instead of HTTP in a way compatible with existing HTTP routing libs; advantages of ZeroMQ: automatic retrial (=> can restart the target service withou noticing), speed, reuse of a connection. The trick is to send a http-like structure (i.e. with method, uri, body) and pass that to Compojure or similar (update: there are now Clojure/core.async bindings for ZeroMQ)
  • Joel on Software: Victory Lap for Ask Patents - killing a bad Microsoft patent request in 15 minutes - Ask Patents is a new StackExchange site that enables experts to look at SW patent requests and point to previous existing works that invalidate them; as Joel describes in his successful patent kill story, it is not difficult at all. Hopefully this will manage to really help the patent office and hit woul-be patent trolls hard! #victory
  • The Dangers Of “Gamification” In Education by Kathy Sierra (a former game designer, a trainer of trainers at Sun, author of the Head First book series) - gamification is often regarded as something very desirable that will improve our lives; however, as Kathy discusses, it has also dark sides and, applied unappropriately, can actually decrease our intrinsic motivation (therefore it should be nearly never used in e.g. education)
  • Choosing an OSS license doesn’t need to be scary (by GitHub) - a human-readable overview of OSS licenses; you should always assign a license to your GitHub account (Add A License can help with that; otherwise it is considered to be "all rights reserved" and you are not giving back to the community (I use the same as Clojure, Eclipse Public License)

Talks

  • FunctionalTalks.org - "Brilliant people giving brilliant talks on functional programming" - f.ex. Wilkes Joiner: Functional Reactive Programming, Alexander Gounares: All your cores are belong to us, Katie Miller: Superhero monads, Bryan O’Sullivan: Running A Startup On Haskell, Rich Hickey: Introduction To Clojure, John A. De Goes: Building a Data Science Platform in Scala and many more.
  • Types vs. Tests: An Epic Battle? - "Amanda Laucher and Paul Snively debate solving problems through types and tests using different approaches." - can type system replace tests or vice versa? Interesting intro into the discussion for me. Using F#, Scala & more. Same claims: types don't pay out so much for "small" codebases but scale better than tests. Types - Tests is a spectrum, not two single extremes. When a property should hold "for all," a type would be a good match. Inductive types (Scala, Haskell?) can become quite complex, dependant types (as in Coq) would be much nicer [if I got that right].
  • Paul Irish on Web Application Development Workflow (via M. Noddeland) - if you need to do some web development but are not up to date on the state of art, this might be useful - an overview of tools, utilities, services by a Googler and the person behind Modernizr, HTML5 Boilerplate, Yeoman etc. Including effective shell & dotfiles.GH, better ssh via .ssh/config and authorized_hosts, the all-in-one dev/build tool Yeoman with live reload, BrowserStack for testing, LocalTunnel to easily share anything running locally, Chrome Dev Tools support for SASS and testing devices (emulate touch events, screen sizes), JetBrains' WebStorm, sharing tools via setapp.me. A genous idea to use GoogleAnalytics to track usage of features in a CLI app!

Other Interesting Stuff

Azul Systems' high-performance JVM on the Vega architecture (from The Trouble with Erlang (or Erlang is a ghetto)) looks very interesting:
The other night I tweeted "If you're looking for a language that gets multicore concurrency right, look at how Azul implemented Java on their Vega architecture" and I definitely stand by that. Azul is a company that got a lot of smart hardware and software people together and had them work on designing a custom system which would scale to hundreds of CPU cores (up to 768 of them), heaps that topped 500 GB (up to 768GB), and had the GC pause only 10-20ms at a time. The realtime performance characteristics Azul managed to eek out of their system lead them to often describe their GC as "pauseless".
Articles:

Clojure Corner

  • Discussion: How core.async compares to agents, future and promise? - future/promise: 1 producer, 1 value, multiple consumers; agent: an unbounded queue of functions mutating a single value, with multiple producers and consumers (reading the latest value produced); channel: multiple 1:1 producers/consumers, i.e. a value can only be taken once from the channel, using a bounded queue (=> slow consumers can block fast producers). As mentioned elsewhere, channels is a relatively low-level abstraction and other things can be built on the top of it.
  • Clojure Tradeoffs (design implications and why you should care) - perhaps not very unbiased but interesting anyway :) (shared-memory over other computing paradigms, i.e. message-passing, dynamic over static, speed over convenience, composition over IoC, ...)
  • Rich Hickey's post introducing core.async with its Go-like channels as a better alternative to a collback hell (I know everybody has already read it but it is still an important link :))
  • Tools etc.
    • Faster Clojure Startup with Class Data Sharing - use JVM's capability to include any classes in its boot image and include clojure in it
    • lein-ancient - checks for outdated dependencies and plugins => run "lein ancient :all"
    • lein-try - a Leiningen plugin that enables you to try a library in a REPL in the context of your project without having to add it to project.clj; simply run "lein try clj-time 0.5.1" and then in the REPL "(require '[clj-time.core :refer :all])" and e.g. "(date-time 1986 10 14)"
    • Lemur: tool to launch a Hadoop job locally/on EMR from a job definition file + actions before/after
    • Emacs: sexp fold/expand is very useful for exploring source code (hide all but the first lines of all top-level forms with hs-hide-all) - the built-in hs-minor-mode can hide/show all, or hide/show/toggle one but the keys for it are cumbersome; hideshow-org makes it possible to toggle hide/show with TAB, while preserving the original TAB behavior (it does the normal TAB first only only if nothing changes does it expand/fold); very useful!

Tools/Libs

  • devdocs.io (via @palruud): "an all-in-one API documentation reader for [web] developers," navigable via keyboard - JS, HTML, CSS, DOM, DOM events, jQuery, Underscore.js
  • Kilim - a message-passing framework for Java that provides ultra-lightweight threads and facilities for fast, safe, zero-copy messaging between these threads.
  • AssertJ - a library of assertions similar to fest-assert but providing a richer set of assertions (nicer API then fest-assert, according to a friend)
  • NetflixOSS - Netflix, the online streaming gigant, has open-sourced many fascinating components of its cloud infrastructure such as Karyon, a blueprint for web-ready components with many features (monitoring,...), Genie/Hadoop as a Service, Servo for monitoring, Archaius for configuration management - too many to list. Check out Chris Fregly's fluxcapacitor, a demo distributed application that uses many of the components
  • Tools to keep a daemon running:

Tags: architecture clojure webdev JavaScript methodology performance

Copyright © 2024 Jakub Holý
Powered by Cryogen
Theme by KingMob