This Week at Skills Matter: 22 – 25 April

Here’s what’s coming up at Skills Matter this week!


The London Java Community return to Skills Matter HQ for a presentation by Arun Gupta, director of RedHat. Arun will discuss RedHat’s open source Java EE 7 compliant application server, Wildfly 8. Come along to learn about its features and how it contains robust implementations like WebSocket and all Java EE 7 technologies.

Also on Tuesday, James Nocentini and Matt Gaunt join this month’s London PhoneGap Meetup, where they will show you how to make a real offline mobileapp and how to optimize and debug your mobile application withDevtools, as well as covering other interesting topics like how PouchDB helped to avoid creating a backend.


Deep Learning London will be joined by Dr. Boumediene Hamzi who will take a closer look at machine learning, learning theory and Artificial Neural Networks. He will be characterizing the frameworks and use Artificial Networks to illustrate the thought process.


Mark Harwood will be joing us for an In The Brain talk, demonstrating scenarios with real-data and examples based around the forth-coming feature of the open source search and analytics platform – ElasticSearch. This demonstration will cover how anomaly detection algorithms can spot credit card fraud and some other rather useful uses. Mark is a software engineer at ElasticSearch and a long-time contributor to Lucene. Prior to joining Elasticsearch Mark was Chief Scientist at BAE Systems Detica, designing search and visualization systems on multi-billion document solutions for analysts in commercial and government clients.

And wrapping up the week, the Limited WIP Society will be concentrating closely on Theory of Constraints and ‘evaporating clouds. Using real-life examples, they will visualise both sides of the conflict and will try to find a better overall solution than just compromise.

Friday(ish) Round-Up: 14 – 17 March

OpenTechSchool London

Once again, we’ve had a fantastic week here at Skills Matter HQ! On top of the meetups and user groups below, we were also joined by the amazing OpenTechSchool London for their final introduction session to Python. This followed from their introduction to HTML and CSS back in February, and we’re joining with the group’s members in their excitement for the next event!

We’ve also had the chance to talk to some of our amazing experts this week for our While It’s Compiling series, most recently Martin Pilkington, founder of M Cubed Software.

If you missed out on coming along to Skills Matter this week, be sure to check out our upcoming events here!

The Week in Skillscasts

Every week we record the majority of meetups and user groups that come to our offices in London for evening events and talks. These are our Skillscasts – and their all available for free on!

The London Ruby User Group

Three speakers and two talks kicked off the week with the London Ruby user group, for their meetup on Re-using GDS code & aspect-oriented programming. Camille Baldock spoke about Aspect-oriented programming in Ruby. Camille discussed how aspect-oriented programming is a solution to the problem of some features affecting virtually all business requirements, and expresses that problem in a compact and DRY way. This practical talk introduced the basic concepts of AOP, showed how to easily leverage some AOP principles in your Rails application and walked through two existing Ruby frameworks to practice AOP.

The second talk from James Smith & Sam Pikesly looked at adventures in early-adoption of open-source code. James and Sam are from the ODI tech team that last year found themselves wanting to use the code behind for a new project. They talked on their experience of picking up a codebase which was open source, but never really designed for reuse, and what they learned along the way.

On Tuesday we were joined by Deep Learning London for a talk on Brains, Data, Machine Intelligence & Cortical Learning with Jeff Hawkins. Jeff was a founder of two mobile computing companies, Palm and Handspring, and was the architect of many computing products such as the PalmPilot and Treo smartphone. He discussed his past experiences revolving around Cortical Learning Algorithms to the Numenta Platform, streamed live from California!

Wednesday brought the London Scala user group through our doors, as they met to discuss Batshit Crazy Algebra with Types. Jon Pretty, a Scala community member since 2004 (when he launched the first commercial application in Scala), discussed what it means to “”add”” or “”multiply”” types like Boolean and List[Int], what interpretation you could attribute to differentiating types, and what this has got to do with zippers.

We were also joined by the London Java Community who met to talk about the what, why and how of Development Testing. After a quick lightning talk by Chris Newland, Marat Boshernitsan took a broad look at development testing and examined how it fits in a software development process. There was then an interactive discussion on some of the strategies for introducing development testing in both greenfield and legacy software projects.

Lock Free Data Structures and Designing Perfect Software was the topic of the day for the London Big-O meetup. Sergio from eBay gave a technical talk on lock free data structures before the group shifted gears somewhat, and Pieter Hintjens (founder of ZeroMQ, among other things) talked about algorithms on a meta level: how (not) to design and organize software projects. Unfortunately, due to unforeseen circumstances, we were not able to record this talk.

We’re so quick with our Skillscasts, they’re available before the meetups even happen! (Well not quite… As we get an extra long weekend here in the UK, this post is going out a day earlier than normal, but these Skillscasts will be available later on this evening…)

The London Software Craftmanship Community wrap up the week here in sunny London. Ben Arroyo leads the evening off discussing efficient coding, teaching you how to save time in the mechanics of coding, and how to become a more efficient developer by taking advantage of productivity tools and practices.

Alastair Smith then discusses his top 10 tips for good object-oriented programming, covering some observations of common mistakes in object orientation, particularly in C# codebases. Alastair is the founder of the Cambridge Software Craftsmanship Community, and is part of team at Red Gate building ingeniously simple tools.

The Week in Blog


Martin Pilkington talked to us about iOS app developmentAndres Löh wrote a guest post about Haskell and Static Typing; we announced a very exciting – and exclusive – workshop with Daniel Steinberg!

Next Week in Brief

Monday: Four-day weekend, woooooooo!

Tuesday: The London Java Community talk WildFly 8

Wednesday: Deep Learning London on Artificial Neural Networks

Thursday: The Limited WIP Society on increasing creativity; Women In Date on Cynefin & speech recognition; In The Brain of Mark Harwood, software engineer at Elasticsearch

And Finally…

The amazing weather, fantastic user groups and meetups, and the long-awaited four-day weekend were topped off this week with the fact that iOScon 2014 – our first ever iOS focused conference – is now one month away. The response from the community has been amazing, and this promises to be one of the must-attend events of the year for all you iOS developers out there.

iOScon 2014

It may be a month away, but the line-up is already looking fantastic. The above mentioned Daniel Steinberg and Martin Pilkington will be joined by Lee Armstrong (one of the co-founders behind Pinkfroot), Abizer Nasir (organiser of NSCoder Night London), Kieran Gutteridge (co-founder of Intohand) and Matias Piipari (CTO of Papers at Springers Business and Media, and co-author of the Papers app) – and that’s just day one!

If that wasn’t enough (!), day two brings you Daniel Thorpe (iOS platform lead for Badoo), Simon Whitaker (developer of firmware for the embedded chip in a hydraulic test rig, debugged using an oscilloscope), Boisy Pitre (Affectiva’s Mobile Visionary and lead iOS developer), Amy Worrall (iOS developer passionate about user experience), Max Scott-Slade (Game Design Director at Johnny Two Shoes & GLITCHE.RS) and Tim Duckett (Product Lead for Numbrs).

Book your ticket for iOScon now, and make sure you don’t miss all of this! As an added bonus (yes, we know, just how could this be any better?), we will also be holding the iOS Hackathon on the weekend of the 17-18 May. Sign up to rise to our challenge of creating something unique and magnificent in just a few hours with a whole bunch of other eager developers: make new friends, exercise your creative muscles, and if you make a great app you’ll be in with a chance of winning a prize!

(We’ve got devices from companies like Estimote, who have created beacons which sense where you are and deliver cool extras to your phone, and Scentee, who have invented a device that can spray scents on command. Plus, we’ve got a giveaway of Pluralsight’s 30-day trial cards for premier membership for everyone who attends. Pow!)

That’s it from us, enjoy the long weekend – see you all next week!

Daniel Steinberg to give an exclusive iOS App Development workshop, 14th May


Daniel Steinberg will be joining Skills Matter this May to deliver an exclusive iOS App Development Quick Start workshop, covering all the fundamental cornerstones of developing apps for iPad, iPhone, and iPod Touch. The workshop includes Xcode, Objective-C, View Controllers, and Storyboards – everything you need to get started in just one day! This course suits developers from all levels, from beginner to advanced; so as long as you know a C-style language and some object-oriented programming, this workshop is for you.

Click here to find out more!

iOScon 2014

Not only is Daniel giving this fantastic course, he’ll also be presenting the keynote talk at iOScon, our first ever iOS developer conference. And he won’t be alone; you can meet other top thinkers like Martin Pilkington, who will be demystifying Autolayout, Amy Worrall to talk about Key Value Coding, and Simon Whitaker on UIKit Dynamics.

iOScon will be taking place the day after the workshop from May 15th – 16th, followed by a free weekend hackathon on May 17th – 18th where you can meet and collaborate with other iOS developers, create a new app or game, and even win a prize!

If you’re interested in learning more about iOS, meeting other developers, and enhancing your skills, we’ve got a great week coming up for you in May - take your pick!

While It’s Compiling: Skills Matter Interviews Martin Pilkington

martin pilkingtonWhile It’s Compiling is a series of interviews with experts across a range of bleeding-edge technologies and practices, exclusive to Skills Matter. Be sure to subscribe to this blog for future interviews, or follow us on Twitter.

Find out who we’ll be interviewing next, and get a chance to put your questions forward with the hashtag #whileitscompiling.

This week we chatted to Martin Pilkington, freelance iOS developer and founder of M Cubed Software, and has been writing for Apple’s platforms for 10 years. He started tinkering with Autolayout when it was first released and fell in love with it straight away, so much so that he is currently writing a book on the subject called The Autolayout Guide (due out Spring 2014).

1. What drew you towards mobile platforms?

I started out developing for the Mac well before the iPhone came about. One of the first apps I developed for the Mac was actually a tool to create linked collections of notes for the early iPods, so I’ve been working with portable devices for quite a while. I bought an iPod touch when they first became available and fell in love with it. When the iPhone SDK came out I jumped at the chance to play around with it, especially as all my skills from developing for the Mac were transferable.

2. Is there anything in particular about iOS that appeals to you?

The big thing is that it appeals to me as a user. There are lots of plusses as a developer, but the key question I have before developing for any platform is: “do I want to use this platform myself?”

3. What new projects are you working on right now?

I have various client projects I’m working on, which I can’t really talk about. The main project I can talk about, which is quite relevant for my talk, is a book I’m working on called The Autolayout Guide. I see a lot of people struggling with Autolayout, just as I did when I started, but the resources available now are just as lacking as they were for me. I wanted to write the definitive guide on Autolayout to help people learn to get the most out of it. It’s also a bit of an experiment as I’ll be releasing it as an iBook, so I’m hoping to add more and more to it as time goes on.

4. Where do you see iOS in the next five years?

I don’t know where it will be, but I know where it would like to be. There are two big problems I have with iOS that I’d like to see solved.

The first is the iPad. A lot of apps are designed to take full advantage of the iPad’s screen space, really making you feel the difference between the iPad and iPhone. Unfortunately, the OS is still stuck in the “big iPhone” world. This has become even more apparent with iOS 7, where the iPad feels like an afterthought. Despite the complaints Windows 8 gets, I believe it has far more interesting features on tablets than iOS (such as the split screen) and I’d like to see Apple catch up.

The second is better integration between the Mac and iOS. iCloud tabs is one small step towards this, but I want to see it in more places. If I’m writing an email, I want to be able to pick up my iPad and finish that email there. I want to be able to copy something on iOS and paste it on the Mac. And most importantly I want to be able to send files, photos, etc between the two without having to resort to email or syncing the device. Before they got shut down, Palm was starting to make inroads into this area, but no-one else has really picked it up.

5. What do you wish you’d known when you’d first started out?

How to use Instruments. I still haven’t mastered it yet, but it’s one of the most important tools in your arsenal.

6. If you could ask the iOS community anything, what would it be?

To file more radars asking for an official plugin API for Xcode. That’s probably the biggest change that could happen to our tools, and radars are the only way to get Apple to act.

Got a question for Martin? Leave us a comment below!

Martin will be giving a talk about mastering Autolayoutat iOScon, our first ever iOScon conference. Check Skills Matter for updates and tickets! 

Guest Post: “Haskell gets static typing right”, Andres Löh

andres-lohThis is a guest post from Andres Löh, a long-time functional programming enthusiast. He started using Haskell in 1997 while being an undergraduate studying mathematics. He obtained his PhD on datatype-generic programming using Haskell from Utrecht University in 2004. Since then, he has continued to use Haskell in research and practice, including teaching various courses both to students and participants from industry. Since 2010, Andres is an independent Haskell consultant and partner at Well-Typed LLP.

Andres teaches both introductory or advanced Haskell courses at Skills Matter, and will also be running a special course on Haskell’s type system. If you would like more information, or would like to enquire about attending any of our courses, you can email us or call our team on 0207 183 9040.

Haskell gets static typing right

Statically typed languages are often seen as a relic of the past – old and clunky. Looking at languages such as C and Java, we’re used to writing down a lot of information in a program that just declares certain variables to be of certain types. And what do we get in return? Not all that much. Yes, granted, some errors are caught at compile time. But the price is high: we’ve cluttered up the code with noisy declarations. Often, code has to be duplicated or written in a more complicated way, just to satisfy the type checker. And then, we still have a significant risk of run-time type errors, because type casting is common-place and can fail at unexpected moments.

So it isn’t a big surprise that dynamically typed languages are now very fashionable. They promise to achieve much more in less time, simply by getting rid of static type checking.

However, I want to argue that we shouldn’t be too keen on giving up the advantages of static types, and instead start using programming languages that get static typing right. Many functional languages such as Scala, F#, OCaml and in particular Haskell are examples of programming languages with strong static type systems that try not to get in the way, but instead guide and help the programmer.

In the rest of this post, I want to look at a few of the reasons why Haskell’s type system is so great. Note that some of the features I’m going to discuss are exclusive to Haskell, but most are not. I’m mainly using Haskell as a vehicle to advertise the virtues of good static type systems.

1. Type inference

Type inference makes the compiler apply common sense to your programs. You no longer have to declare the types of your variables, the compiler looks at how you use them and tries to determine what type they have. If any of the uses are inconsistent, then a type error is reported. This removes a lot of noise from your programs, and lets you focus on what’s important.

Of course, you are still allowed to provide explicit type signatures, and encouraged to do so in places where it makes sense, for example, when specifying the interface of your code.

2. Code reuse

Nothing is more annoying than having to duplicate code. In the ancient days of statically typed programming, you had to write the same function several times if you wanted it to work for several types. These days, most languages have “generics” that allow you to abstract over type parameters. In Haskell, you just write a piece of code that works for several types, and type inference will tell you that it does, by inferring a type that is “polymorphic”. For example, write code that reverses all the elements of a data structure, and type inference will tell you that your code is independent of the type of elements of the data structure, so it’ll just work regardless of what element type you use. If you write code that sorts a data structure, type inference will figure out that all you require to know about the elements is that they admit an ordering.

3. No run-time type information by default

Haskell erases all type information after type checking. You may think that this is mainly a performance issue, but it’s much more than that. The absence of run-time type information means that code that’s polymorphic (i.e., type-agnostic, see above) cannot access certain values. This can be a powerful safety net. For example, just the type signature of a function can tell you that the function could reorder, delete or duplicate elements in a data structure, but not otherwise touch them, modify them or operate on them in any other way. Whereas in the beginning of this post I complained that bad static type systems don’t allow you to do what you want because they’re not powerful enough, here we can deliberately introduce restrictions to save us (as well as colleagues) from accidental mistakes. So polymorphism turns out to be much more than just a way to reduce code duplication.

By the way, Haskell gives you various degrees of selective run-time typing. If you really need it in places, you can explicitly attach run-time type information to values and then make type-based decisions. But you say where and when, making a conscious choice that you gain flexibility at the cost of safety.

4. Introducing new datatypes made easy

In Haskell, it’s a one-liner to define a new datatype with a new name that has the same run-time representation as an existing type, yet is treated as distinct by the type system. (This may sound trivial, but surprisingly many statically typed languages get it wrong.) So for example it’s easy to define lots of different types that are all integers internally: counters, years, quantities, … In Haskell, this simple feature is often used to define safe boundaries: a specific type for URLs, a specific type for SQL queries, a specific type for HTML documents, and so on. Each of these types then comes with specific functions to operate on them. All such operations guarantee that whenever you have a value of this type, it’s well-formed, and whenever you render a value of this type, it’s syntactically correct and properly escaped.

5. Explicit effects

In virtually all programming languages, a function that performs some calculations on a few numbers and another function that performs the same calculations, but additionally sends a million spam emails to addresses all over the world, have exactly the same type, and therefore the same interface. Not so in Haskell. If a function writes to the screen, reads from the disk, sends messages over the network, accesses the system time, or makes use of any other so-called side effect, this is visible in its type. This has two advantages: first, it makes it much easier to rely on other people’s code. If you look at the interface and a function is effect-free, then you for example automatically know that it is also thread-safe. Second, the language facilitates a design where side effects are isolated into relatively small parts of the code base. This may seem difficult to achieve for highly stateful systems, but surprisingly, it usually is not: even interactive systems can usually be described as pure functions reacting to a series of requests with appropriate responses, and a separate driver that does the actual communication. Such separation makes it not only easier to test the program, but also facilitates the evolution of the program such, for example, to adapt it to run in a different environment. Haskell’s type system therefore encourages good design.

6. Types as a guide in program development

If you only ever see types as a source of errors, and therefore as enemies on your path of getting your program accepted, you’re doing them injustice. Types as provided by Haskell are an element of program design. If you give your program precise types and follow systematic design principles, your program almost writes itself. Programming with a strong type system is comparable to playing a puzzle game, where the type system removes many of the wrong choices and helpfully guides you to take the right path. This style of programming is supported by a new language extension called “Typed Holes” where you leave parts of your program unspecified during development, and obtain feedback from the development environment about what type has to go into the hole, and what program fragments you have available locally to construct a value of the desired type. Playing this kind of puzzle game is actually quite fun!

7. Programming on the type level

Haskell’s type system provides many advanced features that you don’t usually have to know about, but that can help you if you want to ensure that some complicated invariants hold in your program. Scarily named concepts such as “higher-ranked polymorphism”, “generalized algebraic datatypes” and “type families” essentially provide you with a way to write programs that compute with types. The possibilities are nearly endless. From playful things such as writing a C-printf-style function where the first argument determines the number of arguments that are expected afterwards as well as their types, you can go on to code that provides useful guarantees such as that mutable references that are available within one thread of control are guaranteed not to be accessed in a completely different context, arrays that can adapt to different internal representations depending on what type of values they contain, working with lists that are guaranteed to be of a specific length, or with trees that are guaranteed to be balanced, or with heterogeneous lists (where each element can be of a different type) in a type-safe way. The goal is always to make illegal inputs impossible to construct. If they’re impossible to construct by the type system, you can isolate sanity tests at the boundary of your code, rather than having to do them over and over again. The good thing is that these features are mostly optional, and often hardly affect the interface of libraries. So as a user, you can benefit from libraries employing such features and having extra safety guarantees internally. As a library writer, you can choose whether you’re happy with the normal level of Haskell type safety (which is already rather a lot), or if you want to spend some extra effort and get even more.

If my overview has tempted you and you now want to learn more about Haskell, you’re welcome follow one of my introductory or advanced Haskell courses that I (together with my colleagues at Well-Typed) regularly teach at Skills Matter. These courses do not just focus on the type system of Haskell (although that’s a significant part). They introduce the entire language in a hands-on way with lots of examples and exercises, as well as providing guidelines on how to write idiomatic Haskell and how to follow good development practices.

If you already know some Haskell and are particularly interested in the advanced type system features mentioned in point 7, we also offer a new one-day course on Haskell’s type system that specifically focuses on how far you can push it.

This week at Skills Matter: 14th – 17th April 2014

Here’s what’s coming up at Skills Matter this week!


The Open Tech School are back for round 2 of their introduction to programming. They will continue with the back-to-basics of writing code, setting you up with the friendly programming language, Python. No experience necessary.

The London Ruby User Group will be around tonight to discuss aspect-oriented programming in Ruby and run through some of the adventures in early-adoption of open source code. Three leading experts, Camille Baldock, James Smith and Sam Pikesley will take you through these interesting topics.


Deep Learning London will be joined by Jeff Hawkins, a serial entrepreneur, scientist and Numenta co-founder. He will discuss his past experiences revolving around Cortical Learning Algorthims to the Numenta Platform. This talk will be streamed live from California, so make sure you are there to ask any questions!

Paul Ardeleanu will be joining Skills Matter to deliver an In The Brain on the ever popular topic of iOS testing. Usually perceived as a painful experience, Paul will get hands-on and show you how BDD can make your iOS projects a much more enjoyable experience.


The London Java Community will be joined by Marat Boshernitsan, a software development researcher and practitioner who will take a look at development testing. He will examine how it fits in a software development process, discussing strategies for introducing development testing in both Greenfield and Legacy software projects.

The Scala User Group may take you by surprise this week, as they are joined by Jon Pretty, who will be running through some crazy algebraic stuff with types with results that my shock you. Jon has been an active member of the Scala community since 2004, when he launched the first commercial application in Scala. This talk is definitely not one to be missed!


Ben Arroyo and Alastair Smith will be speaking at this month’s London Software Craftmanship Community, a great opportunity to pick up top tips for good object-oriented programming and saving time in the mechanics of coding. They will be running through the ins and outs, the mistakes made and how to improve OO and efficient coding.

Heartbleed Update


In light of the Heartbleed bug, a serious vulnerability in the popular OpenSSL cryptographic software library, we have taken steps to ensure that your information on is protected from theft or loss.

Action we have taken:

  • Servers have been patched with latest OpenSSL fix (courtesy of Heroku, read more here)
  • Generated and installed new SSL certificates.

It’s now safe to change your passwords - do this by clicking on the ‘forgot your password?’ link at the login screen and send a reset link to your registered email address.

Many thanks,

The Skills Matter Team