Dashboards and information screens are becoming increasingly common for monitoring and displaying important, relevant information at a glance. This blog post is part two of a short series where we look at how I, without much programming skills, was able to build such a dashboard in the cloud using Google’s BigQuery and DataStudio tools.

In yesterday's post, we looked at how to get our data into BigQuery and build queries to extract the information we wanted. Now it’s time to visualize the data we have gathered using Google Data Studio.

4. Save the queries as views

As our real-time bike availability status did not contain the station names, which we would want to display in the dashboard, we simply had to join the realtime status table with a static table containing station names. Also, we wanted to calculate some euclidian distances between map locations and bike stations (yup, that rhymes). BigQuery lets you save these queries as views, which is a virtual table based on the query results. As views just gather and present data from other tables, they will be consistently up-to-date as the original tables have data added, changed or removed.

5. Visualize your data

When we have finished setting up our data tables and views in BigQuery, we can start building the dashboard itself using Google Data Studio. Data Studio is built for creating simple, interactive dashboards and reports. You can connect to a bunch of different data providers and services, such as - you guessed it - BigQuery, and share the results with others. It is also possible to combine data from different sources in the same dashboard, making it a flexible and versatile tool.

For this simple dashboard, we only needed to use a couple of different tables and views from BigQuery, such as the '10naermestsykler' view for showing the 10 bike stations with available bikes closest to our office. When you have connected your data sources, you can just make use of the drag-and-drop interface to place text, graphs, images, tables, and shapes. Data Studio offers some customization options, including Excel-like features such as calculated fields. You can also add pickers for dimensions, metrics and date ranges, so the end-users themselves can filter the data in realtime.

With the numbers and graphs all set up (and a couple of glances out the window and on official apps to check if the numbers were correct), the final part was just to clean up the design a bit. Data Studio has a bunch of different nice-looking templates you can choose from, but we wanted to keep it simple and just tweak the colors of elements to match Bekk's brand palette.

Final thoughts

While this hasn’t been a complete step to step guide, I hope you have gotten a decent overview of how to get started with BigQuery and DataStudio. I highly recommend testing out this powerful combination to build reports and dashboards, whether it is for an actual work-related project or just something convenient or fun for your own home. I don’t have much programming experience but was able to get this dashboard up and running with minimum time and effort.

For business insight purposes, these tools present an efficient, low-risk opportunity for experimenting and playing with your data to uncover new and interesting insights. It is also ideal for taking data otherwise only reachable to data engineers or scientists, and present it to not so tech-savvy users. Data Studio can, for example, automatically send out scheduled reports.

Data Studio, however, does have some limitations both in design flexibility and data manipulation. But even for those more advanced use cases, it can still be beneficial to develop and test different MVPs using DataStudio before you go on to build a full dashboard from the ground up.

But all in all: the power of the Google Cloud Platform, BigQuery and Data Studio, gives you the ability to build complex queries on giant datasets, and quickly present the results in a simple, visual manner.

Good luck!

Building a dashboard with Google BigQuery and DataStudio (2/2)

If you missed the two previous articles on coroutines you can read the first here👈 and the second 👉there

Now that we have learned about basic coroutine properties and know some details on how to work with coroutines is there more to coroutines? Other than very efficient asynchronous operations and great readability, do kotlin coroutines solve other problems as well? Of course!

In this code we first get a lot of images from the API, proceeds to put the result together and then returns the result to be presented somewhere in our application. It seems very suboptimal to first get all the images, construct some container for them, and then present them? That doesn't feel very nice😟

We don't really want to wait for the entire result to be retrieved, constructed, and then returned when the first image is available long before the other images. It would be ideal if we were able to process/present the images continuously as each image is retrieved from the API. A solution such as this would apply for any type of collection of responses.

One solution that the kotlin coroutine team came up with for solving these types of problems is the concept of Channels. A Channel can be thought of as a pipeline, one point send and the other receive.

The difference between this code snippet and the above is that what was previously images is now imagesChannel. We have replaced a list of images with a channel of images. When we iterate over the channel these values will be presented the instance send(image) is called in the channelOfImages() function. What is happening is that the channelOfImages() starts a coroutine and works together with the coroutine in the runBlocking scope.

So the code stays about the same as it were before, only now we can process the data the moment it is available from the API. Pretty nice, but there is a problem with Channels. They are hot 🔥

A Channel is called hot because in practice it stays alive and runs as a coroutine the moment channelOfImages() is called. And why is this a problem you say🤔 This could be a problem when the coroutine that is receiving data from the Channel suddenly has an exception and are not able to receive anymore. In this case Channel will just live on doing nothing because it is unable to send its data to anyone and finish its work. When working with files or network connections this could prove to be a real problem as we will not be able to close either.

🌊Kotlin flow to the rescue! Flows were constructed by the kotlin coroutine team to make up for the error prone Channel, and was just stabilised a couple of months ago. If we change our previous code example from working with channels to working with flows it would look like the following code snippet.

The previous code example which returned a channel of images now returns a flow of images. It uses other words, but looks very similar to the previous example, so what is really the difference?🤔

A huge difference is that imagesFlow is just a reference to the flow it does not start the flow like the call to channelOfImages() further up does. The flow is not activated until .collect {…} is called. If we now get an exception in the code calling to collect the flow, or we for some other reason don't call .collect {…} our code will run fine.

Because of this, we can be certain that we do not have any open coroutines doing nothing as a result of the call to flowOfImages(). This is why we call Kotlin flow entities cold:snowflake:. Cold flows, hot channels.

Flow also have this builder called flowOf() where the input parameter is some collection. In the following example we compare the Collection approach to the Flow approach.

Here we have a suspend function listOfNumbers() and a normal function flowOfNumbers(), and there is a significant difference in how these two functions work. When we call listOfNumbers() just like the channelOfImages() function in an example further up they're called and executed right away. On the other hand, the function flowOfNumbers() is not called right away, we just define the flow describing what will be produced. Using flow this way seems to give it a very nice declarative property, making it safer and more predictable.

Coroutines channels🔥 and flow❄️

The next morning, Dag showed Halldis what he had done so far. After she had stopped laughing, she agreed it was pretty great. "Why don't you add some animations to it?" she asked. "Animations?" Dag asked. "You know, maybe some movement to the tree?".

Looking up the documentation, Dag quickly figured out how to make the tree move.

MDN web docs - CSS animations

Dag took the existing code and altered it so that the tree background moves 200px every 20seconds. And in the same time period have the tree move from the lower right to taller than normal in the middle, to give the feeling of wind.

‍

The card looked a bit strange, with only the tree moving, so he added animations to the pictures and the star as well.

Looking at the card, he was pleased. But he felt that the card had lost some of the attention on him and his team members. He figured he should add some animation to their images, as well.

This project had gotten him to explore new features he had not often used before, and he found it exciting. Looking up different ways of manipulating images with CSS, he found the filter function. "That might work. But what filter should I use?". He ended up try saturation, as Christmas has a lot of green and red, and with saturation, you can make things more green and red, therefore more Christmassy!

Playing around with for a few minutes, he ended up with

Based on MDN web docs - filter

Satisfied with the result, Dag opened his email client and sent the card to the wrong email list, to himself, then finally to the correct email list.

CSS Christmas card - Part 3: Shaking it up

When it comes down to it, machine learning is, as probably all of you know – statistics on steroids. That’s why todays post is dedicated to one of the fundamental tests we often use in statistics and we perhaps should use even more often.

I am of course talking (writing) about the t-test. The test that has come to be a useful variation of the Z-test. That’s because where the Z-test makes use of the normal distribution and assumes a large test-sample, not everyone has that luxury and thus there is ample room for the t-test that relies on the students t-distribution. But I’m getting ahead of myself, lets go back to the beginning, to 1908.

Willam Sealy Gosset was a chemist working at Guinness Brewery in Dublin, Ireland. Here he was tasked with, amongst other things, quality control of the beer. To do this he measured sugar content in the malt extract – too high sugar content would mean higher taxes, but too low and the alcohol percentage in the finished beer would be too low. By talking samples of the beer, he could use the normal distribution and Z-test to determine if the batch he was testing was outside the normal range.

However, he had a problem. For the test to be valid he required a large sample size, because as he noted - “… the greater the number of observations of which means are taken, the smaller the error”. But this would mean taking away too much beer that should rather be sold. Preferable he should be able to test the quality of the beer with as few as two samples.

Gosset realised that with small sample sizes there was not errors, but even our estimate of the standard error had noise in it, causing a bias in the absolute values in the distribution. To account for this bias he created a new distribution that flattens the normal distribution and thus moves cut-off scores outwards.

At the time Gosset published his findings under the pseudonym “student” in order to be allowed to publish his findings. In 1912, mathematician Ronald Fisher discovered a mistake in the distribution and added a correction that said that the total sample size, n, should be reduced by 1, and it was at this time that the distribution became known as The Student’s T-distribution.

###The t-test

There are many variations of the T-test, depending, depending on the specific scenario your using it for, and if it’s a one-tailed or two tailed test. The following formula is for comparing two means to see if they are different from each other. Here it is assumed that the variance of the two datasets are similar.

Try using this formula the next time you conduct an AB-test to verify that your results are statistically significant!

A history of beer, statistics and pseudonyms

Hi, my name is Marte and I decided five montsh ago that I wanted to pursue a career within front-end development to get closer to the products and users. At that point in time I was working with strategy and business development, which I also studied for six years. The journey that has led me from being a management consultant to a developer has been filled with confusion, feeling of achievement, stupid questions, not so stupid questions, bad code and good code. And it is true what they say; the learning curve is steep! I will take you through some of the learnings I have encountered during my first months as a developer.

Online courses are helpful, but not everything

When I first started this process, I was determined to complete several online courses in detail. I invested a vast amount in time in it, and felt I got a good basis knowledge as a result. However, there is a problem with this kind of easy learning. Firstly, it may encourage passive consumption and gives the illusion of learning without any practical experience. Secondly, it avoids the real lessons that come with hard learning and stepping outside the comfort zone: The sooner you get your hands dirty and move yourself on deep water, the sooner your capabilities as a developer grows (as with most things in life I guess).

You can learn whatever you set your mind to

Most people will say it is not possible to become a developer in 3 months. Yes, you can learn to develop, but being a stand-alone developer requires years of deliberate practice. However, this statement might prevent non-technical people pursuing an interest in tech simply because they believe it will take them years before they are able to deliver value again. I believe you can learn anything you set your mind to do if you have the interest, motivation and the end goal in mind, and it might not take as long as you think. What is certain is that you become good at what you do eight hours every day when you are surrounded by highly skilled people and are being challenged with tasks gradually increasing in complexity.

The key is to focus on a few learning objectives

Attacking the developer world, you can get stunned by the amount of different languages, libraries and frameworks. And surely you are not able to learn everything. Especially if you are like me; new to the “developer world”. Something that was important to me at start, was, together with experienced developers and the world wide web, to set a plan for which languages, libraries, and frameworks I would prioritize to give me relevant knowledge for the market in Norway and Bekk’s customers. I simply ignored the rest and solely focused on acquiring a handful of skills. Furthermore, it was important to attack them in the right and logical order to build knowledge brick-by-brick.

Assuming that if things are working then things are right

A fundamental difference between developing in an unprofessional versus a professional setting, is the requirement for quality and performance of the code. As a beginner you are simply happy about your code working. However, the difference between being able to code and writing good, understandable, and proper tested code with high quality, is huge. Regarding this, I believe I will continue to learn something new every day for the rest of my development career. Both from my co-workers and from an industry in continuous evolvement.

Taking breaks will make you more efficient

As a management consultant, my workday would naturally be broken up by meetings and workshops every other hour. As a developer, the frequency of meetings is lower, which allows you to sit stationary at your desk for hours. However, your brain needs breaks. I find myself often in the zone and thus forget to take breaks. This leads me to feeling all boiled up at the end of the day and I might as well have used more time than necessary on problem solving or in fact written useless code. My mind is a bit contradictory on this. I often avoid taking breaks because I want to get things done, at the same time as I am fully aware that you are much more efficient with a fresh and clear mind. As a solution, I have tried to integrate measures in my workday that mitigate hours of continuous working. For example, filling up my water bottle on the other side of the building every hour or working out in the lunch break. This enables me to return to coding with fresh eyes and recharged brain power 👀💪🏼.

You made it through the whole post. That deserves a break!

5 things I have learned in my first months as a React Native developer

Have you ever been annoyed that your tests take an incredibly long time? I have. A simple trick can save time by running (almost) all your tests in parallel.

Sometimes tests can be a pain in the ass. I’ve used countless amount of hours waiting for slow tests, which in the end slows my progress. After an extensive session of searching the Internet, I found one cool experimental feature in JUnit5 that have saved me a lot of time.

By default, JUnit tests are run sequentially in a single thread. I like to compare that to a traffic jam caused by only one lane to be free during rush hours. If they decide to open more lanes, more traffic can pass through and the jam will eventually end.

Running tests in parallel - for example, to speed up execution is quite easy. In JUnit 5, parallel test execution is available as an opt-in feature and it is easy to configure. I’ll show you how.

You need these dependencies:

Are you using maven? Don’t worry!Use this link

Alright! Now we have the dependencies in order and it’s time to get our hands dirty. To enable parallel test execution you will have to create a file called junit-platform.properties. Add this file to your project’s test resources folder (usually src/test/resources).

The file should contain at least one line:

The line tells JUnit to enable parallel test execution. The desired parallelism will be equal to the number of available processors/cores.

If you run your tests now, you should see that JUnit has discovered your new configuration file (look for INFO: Loading JUnit Platform configuration parameters from classpath resource [...] in your console), but the tests still run sequentially. This is because we haven’t told JUnit which tests to run concurrent.

Luckily for us there is a simple solution for that! Annotate a test class with @Execution(ExecutionMode.CONCURRENT). This annotation tells JUnit to run the test in parallel.

I hope you learnt something useful. It does not solve all your time consuming problems, but at least it is a step in the right direction Good luck!

Use your time wisely! Run tests in parallel

Fra Excel-magiker og PowerPoint-akrobat til vaskeekte utvikler, hvordan er det å gå fra forretningsutvikler til utviker? Er tverrfaglighet vanskelig når man skal utvikle produkter? Vi prater om hva som er viktig for å oppnå velfungerende, tverrfaglig team med perspektiver både fra forretnings- og systemutvikleren. Sondre H. Graver, Marte Gleditsch og Snorre Gryte tar praten over en kaffe.

Er det utfordrende å jobbe i tverrfaglige team?

When hearing about security breaches and typically cybercrime, one is sometimes left wondering, where are these servers hosted and why can't they be stopped?

When hearing about security breaches and typically cybercrime, one is sometimes left wondering, where does these attacks originate. Who run these servers why can't they be stopped? Nefarious schemes also require reliable, stable hosting, pretty much the same as regular services.

Distributed denial of service attack (also known as DDOS-attacks) is one of the common attacks on computer systems or other network infrastructure on the net. In a DDOS scenario, a service or host, is flooded with coordinated requests from a large number of clients, or computers in the internet. These computers are typically under the control of a botnet. A botnet is a collection of computer devices under control of a third party. They devices are typically compromised by some malware or other attack. The member devices of such a network, is sometimes referred to as bot. Th botnet can contain anything from compromised blade servers in data centres or an IOT device on your home network. Once the attack is complete, the zombie, either goes back idle or they are reassigned to some other task by the botnet. The bots can have a short or long lifespan in the botnet, they are expandable.

Other attacks, such as deployment of malware, ransomware or command and control servers, needs some more permanent presence on the internet. If the attack requires a more persistent point of contact, a botnet may not be reliable enough. The alternative would be to host the service with a hosting provider. The hosting providers may not be as forgiving when they notice that their customers are spreading malicious content or breaking the law in some form or another. If a botnet loses its command and control centre, the whole operation may be stopped, and any financial gains lost.

Bulletproof hosting providers provide services, which at first glance are the same as services from normal hosting providers, servers, redundancy and customer support. They also provide anonymous payment methods such as cryptocurrencies or even cash to avoid a paper trail or traceable credit cards. A common thing is that the servers are hosted in countries with a more relaxed law when it comes to what content is considered illegal. Without the legal framework required for a take down, the bulletproof hosting provider keep their servers running without too much interference.

Some providers take this ever further by renting out compromised servers and stolen cloud service accounts. These servers can be used for short term task, such as specific attacks or just computer intense tasks, password hashing for example.

The availability of bulletproof hosting providers seems to indicate that there is a thriving market for such services. But as these services become more prevalent, they are also exposing themselves to authorities. But as soon at one provider is taken down, it seems that another enterprising start-up sees an opportunity and announces their bulletproof services.

Bulletproof hosting

Me: “Hey Goog..”\ *Bang* The sound of my girlfriend’s palm hitting the light switch, and the room goes dark. With a tear from the corner of my eye I go to sleep, well aware that I won’t be turning the lights off with my voice tonight either. \ \ A true and heart-breaking story from my life, and one that I guess many technology lovers out there can relate to. Because even though smart speaker sales numbers has been going through the roof over the last few years, my impression from talking to friends and reading articles is that voice user interface (VUI) still struggles to find its place among the mainstream user. One of the main reasons for this is bad UX. Nielsen Norman Group formulated it well comparing todays voice assistants with mobile phones from year 2000.\ \ I know the struggle. I’ve made two voice skills for Amazon Alexa, advised on voice projects at work and read a lot of articles. So, I’d like to summarise a couple of important things to be aware of and some tips and tricks when making a VUI:

--

Ask yourself “Why is VUI the right interface for this solution?”. This is for example not the best interface for selling paintings. In my opinion, one of the biggest problems for VUI so far is that it needs to prove itself useful and not only “nice to have”.\ \ Tips & tricks: People use VUI when their hands are busy - for example to set a timer when cooking or to find a song while driving. And they use it when it’s faster to ask a question than trying to find the answer by themselves - for example getting the outdoor temperature or the name of a capital.

--

Speaking and listening share the same short-term memory and working memory as recall and problem solving. So thinking while speaking requires quite an effort. The consequences of this is that people struggle remembering answers, options and commandos voice assistants give them.\ \ Tips & tricks: You have to prioritise hard on the amount of information to give the user. Too much information, and you lose your user. This is mobile first level 100. Also if you have several options for the user, don’t give them more than three at a time. Let the user know they can ask for more options instead if needed.

--

“What can I do in this VUI? And how do I do it?” These are questions your users will have.\ \ Tips & tricks: Offer a tutorial for first time users. Offer guidance, for example when users say “help”. If you have other interfaces explain the VUI here as well. This is also good marketing, people won’t find your VUI by themselves.

--

There’s a lot of questions to consider when it comes to branding. How does your brand sound? Male or female? Funny or serious? Old or young? Excited or calm? One voice or several voices? Any other sounds including voices? \ \ Tips & tricks: If possible, use a human voice instead of a built-in robot voice. This will create a more engaging experience. The use of sounds is also a powerful tool for evoking feelings and create engagement.

--

Words matter more than ever. The chosen words are the ones that dictates how the user understands your product, and that shapes their experience.\ \ Tips & tricks: End your sentence with a question, and avoid placing it in the middle. People tend to answer the questions immediately. This is, by the way, not the time and place for those rhetorical questions trying to pretend to be a great author.

--

Don’t tell the user what to say. Like the old phone bots telling you to press 1 for this and 2 for that. I can’t imagine anybody associating that with a great experience. \ \ Tips & tricks: Try to make a normal conversation. Ask questions instead: “Do you want this or that?”

--

Unfortunately, a lot of things still go wrong when using VUIs. This is well documented both in studies and in user testing.\ \ Tips & tricks: Blame the assistant, not the user, when telling the user that something went wrong. Test your VUI to see if it’s some place where the voice assistant easily gets the response from the user wrong. Especially in Norway responses easily gets misunderstood because of all the dialects. Offer a phone call to a real person or information of where to get help if something goes wrong several times.

--\ \ So here you go. Now go out and make a great (as possible) voice user experience!\ \ If you would like to read more about voice UX here are some articles I will recommend:\ https://www.bbc.co.uk/gel/guidelines/how-to-design-a-voice-experience\https://www.dtelepathy.com/blog/design/the-ux-of-voice-the-invisible-interface\https://uxdesign.cc/design-guidelines-for-voice-user-interfaces-3c3b73982f4c\https://uxdesign.cc/designing-better-voice-interfaces-for-everyday-life-2cb344913fae\https://medium.com/@Chakib.Labidi/alexa-happily-ever-after-bbf52ddc552d

Tips & Tricks for Better UX in Voice Interfaces

Modern frameworks are easy to learn. From zero web experience, they help you get productive in a matter of weeks. But for me, the web remained a mystery until I taught myself the very basics.

Some learned web development when JavaScript was just a small, but neat script-tag, supporting otherwise static HTML and CSS. Some picked it up during the days of JQuery and Ajax, where every client-side problem could be solved with a magical dollar sign. Others were introduced to a world of extensive frameworks and abstractions, attempting to solve every problem of web development.

I belong to the latter group. I was introduced to the web in 2016, during an internship at my University. React had just started getting traction, and my colleagues wanted to build new applications using this library with a fancy web stack.

Frameworks. A dual-edged sword

Current users of the web have high expectations of modern web applications. Frameworks attempt to solve the most challenging problems that emerges when building such apps. In a lot of ways, they succeed in doing so. Modern frameworks are surprisingly easy to learn, and during my internship, they helped me get productive in a matter of weeks.

Using a modern web stack also meant that every line I wrote was type checked, transpiled, minified and compressed before reaching the end user. Libraries and tools such as React, JSX, Babel and Flow.js helped me write complex applications with relative ease, but what I wrote looked nothing like the resulting HTML, CSS and JavaScript delivered to the end user. In the following weeks or months, I struggled to distinguish what parts of the code was JSX, what was Flow and what was just plain, old JavaScript.

During my internship, this was not a huge problem. I had become productive and was happily delivering features in production. However, the symptoms became much worse when switching to another project with a slightly different web stack. I had become specialized in my current stack, and could not handle libraries, tools and code other than what I initially had learned to love.

Don't invest in the framework. Invest in yourself.

To specialize oneself in a framework is not necessarily a good fundament in a rapidly changing world. Frameworks are fragile. Over the years, they emerge, evolve and disappear, only to be remembered in legacy code. It's okay to learn a framework first. Get productive. But don't forget the fundaments they build upon.

Invest in yourself, rather than the fancy web stack. If you teach yourself HTML, CSS and JavaScript in an isolated context, without the supportive libraries and build tools, you are doing yourself a favor that will pay back in heaps. You will become an adaptive web developer.

Who knows how the frontend landscape will look like in two, five or ten years. I'm not sure we'll still use React, Vue, Elm or other popular frameworks. But I'm pretty sure HTML, CSS and JavaScript are still around, powering the latest and greatest of the future web. Don't just take my word for it. As Allen Wirfs-Brock frames it, "[JavaScript's] role on the web means that it is likely to be one of the world's longest-lived programming languages."

If you missed it, day 13 of this calendar includes a list of resources you can use to learn JavaScript and web development. Make sure to check it out, whether you're new to the web or just need to freshen up your skills!

The Adaptive Web Developer

Today's interview is with @webmaxru. Maxim works at @MicrosoftNorge in Developer Relations and is active in the Progressive Web App (#PWA) scene. He also organizes @ngVikingsConf & @mobileeraconf confs, @AngularOslo & @MobileOslo meetups, and is a @GoogleDevExpert.

The questions below came from a simple question we asked ourselves:

if you had the chance, what would you ask an Open source maintainer/person/community member.

Here we go!

What are your biggest challenges in working with Open source today and how do you handle them?

Building a healthy community around your project who could take care of maintaining while core contributor(s) takes a break (which will inevitably happen) or leaves the project. Sustainability is the cornerstone.

Are there any useful tools you use to make your GitHub-life easier to manage, and if so, could you share a few of them with us?

The default toolset, VS Code + its GitHub and npm plugins + Terminal, covers pretty much all I need to build and maintain my projects

How can repository-owners facilitate contributions from newcomers in Open source?

Creating a welcoming environment (it's way more challenging than technical issues), providing good logistics (clear guidance, ergonomic templates, thoughtful issues labeling), educating by blog posts and sessions at the conferences.

If you could time-travel to when you first started, what advice would you give yourself as an Open source rookie?

Don't wait with starting your contributions and be patient both as maintainer and contributor. Also, don't limit yourself by committing to the codebase only, there are lots of other ways to contribute to the project.

Can you describe how you see the future of Open source, what new directions or paths do you think it will take?

As now we use "open source software" term to distinct from "default" one (closed source), in the future, we could have just "software" (open source a-priory) vs Closed Source Software as something exceptional. I.e. the OSS term will fade away, becoming just a mainstream.

Thanks for taking the time to talk with us Maxim! 💪

Interview with Maxim Salnikov

In this article I would like to introduce you to two common composition operators and explain some of their utility, using first a made up example, and then an example from the real world. These operators are all about composing functions of slightly weird types. For while regular function composition combines functions of types a -> b and b -> c, these guys concern themselves with combining functions of types which don't naturally fit perfectly together.

The Kleisli arrow is often written using the fishbone operator. f >=> g is the Kleisli composition of the functions f and g with the following abstract types.

If we consider lists of numbers as a concrete example, the types would be

and their composition would also have the type Int -> List Int. Such a function might for instance be the square root function, such as

If you're using complex numbers you can also consider the n'th root function, where it will produce a list of n roots.

The function doubleSquareRoot which takes the square root of a number twice can be defined as the Kleisli composition of this square root function with itself.

To understand what doubleSquareRoot 16 will evaluate to, we will first consider the first sqrt evaluation. sqrt 16 will produce [4, -4]. For each of the results in this list, the next sqrt function will be evaluated:

These results are then consolidated to produce the final result.

This technique can be used to chain together many computations to produce a larger result. When thinking about lists this can be understood as modeling problems with many results such as finding roots, or maybe finding the possible next moves in a graph traversal problem.

A real world example

At work we have recently been experimenting with using F# for a simple web api. An endpoint might look like

This constructs a larger function using the regular >> function composition operator. The input for this function will be a context object which contains the body of the HTTP request as well as a reference to the database, which the Service uses.

We use Result.map to handle errors along the way using the built-in Result type. For instance getBody might fail if the incomming JSON cannot be parsed as a Models.WriteModel type. The Result.bind function reveals that the Service.updateEvent function itself may fail and produce a Result.Error.

This seems like it will work, until you consider which functions needs use of the context object. getBody obviously needs the context to access the HTTP body. In addition, both Service.updateEvent and commitTransaction needs a reference to the database. The way we solve this is to consider Service.updateEvent id not as a function from the domain model to Result<DomainModel> but as a function from the domain model to ctx -> Result<DomainModel>. That is, a function which takes domain models and produce domain models and can fail but also needs a context. That might sound and indeed be confusing, but if you don't think too much about it, it kind of makes sense. Using Kleisli composition's closely related cousin the bind operator >>=, we can rewrite our function.[0]

It's a small change, but now our two functions can access the context. The way I think about it, is that this is regular composition of functions, but when you need the context object, you inject it using the bind operator instead of regular composition. And that is all you need to know to use this pattern productively!

Technicalities

If you're interested, the bind operator may be defined as follows.

The reason we are using the bind operator here instead of the Kleisli fishbone operator, is that the very first function only takes the context as a parameter. Had the first function also taken a parameter in addition to the context, you would just replace all instaces of >>= with >=>. The implementation of the Kleisli arrow might then look like

It might be difficult to see the similarities between functions that produce lists of things and functions that produce functions which need contexts, but they are there. They have some similar properties and can be understood in the same way. And of course, if you don't need to, you don't have to think too much about it to be able to use composition operators such as the bind and Kleisli arrows effectively.

[0]: It is well known that monads don't compose, and both Result and functions which need contexts are monads. This is only a problem if you're trying to write code that works generically with two different types of abstract monads, and this is where people use monad transformers. However, we only need these specific, concrete monads, which allow us to write a single >>= bind operator which handles all of our needs.

14-Dec

Today's posts