Upgrade or not to upgrade dependencies? The eternal dilemma

October 20, 2015

Cross-posted from TeliaSonera Tech blog.



Handling dependencies is one of important challenges in any software project - and especially in the fast-moving JavaScript world. Our Nettbutikk team just had a heated discussion about handling upgrades of our dependencies that continuous our learning journey lined with failures (or rather "experiments that generated new knowledge" :-)).

Failed attempt one: Let tools do it



Originally we let npm automatically do minor upgrades but that turned out to be problematic as even minor version changes can introduce bugs and having potentially different (minor) versions on our different machines and in production makes troubleshooting difficult.


Continue reading →

Storytelling as a Vehicle of Change: Introducing ClojureScript for the Heart and Mind

October 7, 2015
People don't really like changes yet change we must in this fast-developing world. How to introduce a change, or rather how to inspire people to embrace a change? That is one of the main questions of my professional life.

I have recently talked about Functional programming (FP) in JavaScript and compared it to ClojureScript, which was designed for FP. To my surprise the team proposed to give ClojureScript a try and we agreed to have a live coding session, implementing a new functionality in our internal part of our webshop using ClojureScript. But how to kindle this little flame of motivation to keep it going, despite hurdles that will certainly come? And here I got a few interesting ideas.

  1. An experienced speaker once recommended sharing personal experiences (even - or especially - if they make me vulnerable) as it is much easier for people to relate to them than to general statements.
  2. A Cognicast eposide mentioned storytelling as a great tool for introductory guides. We humans are natural storytellers, we think in stories and relate to them much more easily - so a story should be great also to communicate the value of a change.
  3. My ex-colleague Therese Ingebrigtsen gave an inspiring talk presenting some points from The Switch - mainly that we need to address the recipient's minds with rational arguments, but also their hearts to involve their emotion (e.g. by drawing a picture of the new bright future), and that it is important to show a clear path forward.



Continue reading →

Refactoring & Type Errors in Clojure: Experience and Prevention

October 6, 2015
While refactoring a relatively simple Clojure code to use a map instead of a vector, I have wasted perhaps a few hours due to essentially type errors. I want to share the experience and my thoughts about possible solutions since I encounter this problem quite often. I should mention that it is quite likely that it is more a problem (an opportunity? :-)) with me rather than the language, namely with the way I write and (not) test it.

The core of the problem is that I write chains of transformations based on my sometimes flawed idea of what data I have at each stage. The challenge is that I cannot see what the data is and have to maintain a mental model while writing the code, and I suck at it. Evaluating the code in the REPL as I develop it helps somewhat but only when writing it - not when I decide to refactor it.


Continue reading →

An answer to CircleCI's "Why we’re no longer using Core.typed"

October 6, 2015
CircleCI has recently published a very useful post "Why we’re no longer using Core.typed" that raises some important concerns w.r.t. Typed Clojure that in their particular case led to the cost overweighting the benefits. CircleCI has a long and positive relation to Ambrose Bonnaire-Sergeant, the main author of core.typed, that has addressed their concerns in his recent Strange Loop talk "Typed Clojure: From Optional to Gradual Typing" (gradual typing is also explained in his 6/2015 blog post "Gradual typing for Clojure"). For the sake of searchability and those of us who prefer text to video, I would like to summarise the main points from the response (spiced with some thoughts of my own).


Continue reading →

Nginx: Protecting upstream from overload on cache miss

October 1, 2015
These 2 magical lines will protect your upstream server from possible overload of many users try to access the same in cached or expired content: 

Continue reading →

Shipping a Refactoring & Feature One Tiny Slice at a Time, to Reduce Risk

September 1, 2015
You don’t need to finish a feature and your users don’t need to see it to be able to release and start battle-testing it. Slice it as much as possible and release the chunks ASAP to shorten the feedback loop and decrease risk.

My colleagues have been working on a crucial change in our webshop - replacing our legacy shopping cart and checkout process with a new one and implementing some new, highly desired functionality that this change enables. We have decided to decrease the risk of the change by doing it first only for product accessories. However the business wanted the new feature included and that required changes to the UI. But the UI has to be consistent across all sections so we would need to implement it also for the main products before going live - which would necessitate implementing also the more complex process used by the main products (and not yet supported by the new backend). And suddenly we had a a load of work that would take weeks to complete and would be released in a big bang deployment.

Such a large-scale and time-consuming change without any feedback from reality whatsoever and then releasing it all at once, having impact on all our sales - I find that really scary (and have fought it before). It is essentially weeks of building risk and then releasing it in a big kaboom. How could we break it down, to release it in small slices, without making the business people unhappy?


Continue reading →

Running Gor, the HTTP traffic replayer, as a service on AWS Elastic Beanstalk

July 30, 2015
Gor is a great utility for replicating (a subset of) production traffic to a staging/test environment. Running it on AWS Elastic Beanstalk (EB) has some challenges, mainly that it doesn't support running as a daemon and that there isn't any documentation/examples for doing this. Well, here is a solution:


Continue reading →

AWS ebextensions: Avoiding "Could not enable service" (or .. disable ..)

July 30, 2015
If you are adding a service entry to your .ebextensions/
Continue reading →

Fixing a mysterious .ebextensions command time out (AWS Elastic Beanstalk)

July 29, 2015
Our webshop, nettbutikk.netcom.no, runs on AWS Elastic Beanstalk and we use .ebextensions/ to customize the environment. I have been just trying to get Gor running on our leader production instance to replay some traffic to our staging environment so that we get a much richer feedback from it. However the container_command I used caused the instance to time out and trash the environment, against all reason. The documentation doesn't help and troubleshooting this is hard due to lack of feedback and time-consuming. Luckily I have arrived to a solution.


Continue reading →

AWS: Passing private configuration to a Docker container (via S3)

July 29, 2015
Philipp Garbe describes how to pass environment variables that you want to keep private to a public Docker instance run on Amazon Web Services (beanstalk or ECS) in his post How to Run HuBot in Docker on AWS EC2 Container Services - Part 3
Continue reading →

Book Review & Digest: Release It! Design and Deploy Production-Ready Software

July 22, 2015
By Michael T. Nygard, 2007, ISBN: 978-0-9787-3921-8

My digest and review of the book.

Review



Of the books I have read, Release It! is the one I would require all "senior" developers to read (together with something like Architecting Enterprise Solutions: Patterns for High-Capability Internet-based Systems). Especially the first part on stability with its patterns and anti-patterns is a must read. Without knowing and applying them, we create systems that react to problems like a dry savannah to a burning match. I found also to next to last chapter, #17 Transparency, very valuable, especially the metrics and design of the OpsDB and observation practices.

One thing I have left out of the digest which is really worth reading are the war stories that introduce each section, they are really interesting, inspiring, and educational.

Extra Links





Stability



Stability x longevity bugs

ReleaseIt-patterns Selected (anti)patterns

Stability antipatterns



Integration points



Integration point = call to a DB, WS, ... . Stability risk #1.


Continue reading →

NDC Oslo 2015: Talk notes, recommended talks (security, FP, etc.)

June 19, 2015
A great conference. A good deal of good talks.

To (perhaps) check later



Wednesday



Thursday



Friday



Keynote Data and Goliath ☆☆☆☆




Continue reading →

Why do companies fail at adopting Functional Programming?

June 17, 2015
According to the NDC Oslo talk Lean and Functional Programming
Continue reading →

Notes from Troy Hunt's Hack Yourself First workshop

June 17, 2015

Troy Hunt (@troyhunt, blog) had a great, very hands-on 2-day workshop about webapp security at NDC Oslo. Here are my notes.



Highlights - resources



Personal security and privacy





Site security





Breaches etc.





To follow






Continue reading →

NDC: Async and Streaming JavaScript, We're All Doing it Wrong! (Promises, Streams, Rx)

June 17, 2015
By Matthew Podwysocki

Events



Lot of work (setup, remove listeners ...), not composable.

Promises



No way to abort promise in progress. (Me: has to remember to check for errors: then(onOk, onError).)

No try-catch-finally; only try-catch.

Streams



Node: Stream 1 were terrible (pause/resume unusable, data sent before ready, ...).


Continue reading →
Copyright © 2024 Jakub Holý
Powered by Cryogen
Theme by KingMob