I wonder if the color model declared as HSL in Smith's paper is actually the color model common known as HSI. The formulas in [1] and the detailed information in [2] suggest this.

• [1] Plataniotis, Venetsanopoulos: "Color Image Processing and Applications", pp. 27-28.
• [2] "HSI and HSV color space", http://stackoverflow.com/questions/20853527/hsi-and-hsv-color-space/30007313#30007313

According to Wikipedia there are two uses of the term Map Coloring:

The first is in cartography, choosing the colors to be used when producing a map. The second is in mathematics, where the problem is to determine the minimum number of colors needed to color a map so that no two adjacent features have the same color.

This stream is primarily about the former.

HSV and HSL are cylindrical transformations of the RGB color cube model.

HSV (hue, saturation and value) and HSL (hue, saturation and lightness) were first described by Smith, Joblove and Greenberg in two articles in an ACM SIGGRAPH Computer Graphics issue from 1978.

Smith gave algorithms for conversion between HSV and RGB and between HSL and RGB in his article. Smith gave a formulation of HSV based on a hexcone representation and HSL based on a triangle representation.

Joblove and Greenberg gave an alternative formulation of the HSV color space based on a cylindrical representation.

Metrick and the graphic standards planning committee later gave a double-hexcone representation for HSL and improved the algorithm for conversion between HSL and RGB with one that does not require sqrt(), cos(), and arctan(). Fishkin finally improved the performance for conversion from HSL to RGB. It converts HSL to HSV and then uses the steps in the HSV to RGB conversion algorithm.

• Alvy Ray Smith (1978): "Color Gamut Transform Pairs", in: ACM SIGGRAPH Computer Graphics, Volume 12 Issue 3, August 1978, pp. 12-19, http://alvyray.com/Papers/CG/color78.pdf

• George H. Joblove, Donald Greenberg (1978): "Color Spaces for Computer Graphics", in: ACM SIGGRAPH Computer Graphics, Volume 12 Issue 3, August 1978, pp. 20-25, http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.413.9004

• Lee Metrick, et. al. (1979): "Raster Extensions to the Core System", in: ACM SIGGRAPH Computer Graphics , Volume 13 Issue 3, August 1979, pp. III-6-7, pp. III-37-38, http://dl.acm.org/citation.cfm?id=988497.988498

• Ken Fishkin (1990): "A Fast HSL-to-RGB Transform", in: Graphics Gems I, pp. 448–449, http://www.gameenginegems.net/gemsdb/article.php?id=751

Having seen both a naive use of ReactFX and a more reasonable, we take the opportunity to formulate an advice for profitably using ReactFX. One should try to minimize the use of subscribe as this function is inherently side-effectful. Ideally, subscribe should only be used at the boundary between ReactFX and non-ReactFX code.

via: Eugen Kiss (2014): "Comparison of Object-Oriented and Functional Programming for GUI Development", http://www.eugenkiss.com/projects/thesis.pdf

Wikipedia describes reactive programming as “a programming paradigm oriented around data flows and the propagation of change”. This description already gets to the core of what reactivity in the context of programming means. Now, the additional attribute “functional” in FRP as opposed to just reactive programming can [...] simply refer to a “programming paradigm for reactive programming using the building blocks of functional programming” [...]. We also note that FRP libraries differ from “non-functional” reactive libraries in that the former almost always provide functional combinators to manipulate reactive constructs and strive to be more declarative in general.

[...] We sum up that in this thesis we understand FRP as a paradigm around data flows, change propagation and time-varying values or event-streams using functional building blocks.

via: Eugen Kiss (2014): "Comparison of Object-Oriented and Functional Programming for GUI Development", http://www.eugenkiss.com/projects/thesis.pdf

When it comes to programming, my least favorite thing to work on is GUI back-ends. Traditional GUI programming involves a lot of mutable variables which represent the current state of your program; if at any point you want to modify part of the program, very often you have to take all of the potential states of your program into account. [...]

Reactive Programming aims to solve a lot of these issues. In a nutshell, all user-interaction with the UI can be represented as events; you can write code that responds to events by updating some state and UI. This isn't a new concept: anyone who has written applications in .NET is probably familiar with events. Reactive Programming takes events to the next level by allowing you to generate new events from existing ones: you can take an event that's fired when a Button is clicked, and make a new event that gets fired only when the Button was clicked with the left mouse button. You can take two events and combine them into a single event that's fired when either original event is fired. You can turn an event into a new event that returns the last two results of the original event. This alone can cut down on the complexity of a GUI implementation, but eventually you will still be manipulating state.

via: Stephen Elliott (2014): "Tutorial: Functional Reactive Programming in F# and WPF (Part 1)", http://steellworks.blogspot.com/2014/03/tutorial-functional-reactive.html

The goal of Rx is to coordinate and orchestrate event-based and asynchronous computations such as low-latency sensor streams, Twitter and social media status updates, SMS messages, GPS coordinates, mouse moves and other UI events, Web sockets, and high-latency calls to Web services using standard object-oriented programming languages such as Java, C#, or Visual Basic.

via: Erik Meijer (2012): "Your Mouse is a Database", http://queue.acm.org/detail.cfm?id=2169076

Coursera course "Principles of Reactive Programming" (since 2013) by Martin Odersky (Scala programming language), Erik Meijer (Reactive Extensions library) and Roland Kuhn (Akka concurrency toolkit).

• Week 1: Review of Principles of Functional Programming (1h:30)
• Week 2: Functional programming and mutable state (2h:00).
• Week 3: Futures (1h:30).
• Week 4: Reactive stream processing (1h:30).
• Week 5: Actors (2h:00).
• Week 6: Supervision (1h:30).
• Week 7: Conversation Patterns (2h:00).

https://www.coursera.org/course/reactive

Stream about (functional) reactive programming techniques.

Related combined stream: https://thoughtstreams.io/combined/functional-reactive-programming/

Good news.

The Kotlin plugin will be part of IntelliJ IDEA 15.

Today, we’re excited to share with you that the EAP build we published yesterday comes with a bundled Kotlin plugin

JetBrains aims to release Kotlin 1.0 this year.

If you’re following the latest news in the Kotlin blog, you may know that its team is working hard to make it ready for the release this year.

http://blog.jetbrains.com/idea/2015/07/intellij-idea-15-eap-kotlin-love/

Slides: Memes vs. Reaction GIFs

I think reaction gifs are better in presentation slides than memes. Memes are usually shared within groups and often difficult to catch for outside members, reaction gifs are better because emotions are universal for humans.

Kotlin now has sealed classes. I think they primarily resemble the concept of "tagged union"s. Rust has a similar elegant construct in form of enums.

sealed class Type () {
    class Named(val name: String): Type()
    class Nested {
        class Function(val param: Type, 
                       val result: Type): Type()
    }
    object Top: Type()
}

when (type) {
    is Named -> println(name)
    is Nested.Function -> println("$param -> $result")
    // Alternatively, we can omit is here
    is Top -> println("TOP")
}

• Sealed Class Hierarchies and when-expressions, https://github.com/JetBrains/kotlin/blob/2dea17a3a937940bd1f668307db7110edc6b9da3/spec-docs/sealed-hierarchies-and-when.md
• Support exhaustive when for sealed class hierarchies, https://youtrack.jetbrains.com/issue/KT-7606
• https://doc.rust-lang.org/book/enums.html

A basic incomplete version of the organization and project pages is online: https://entera.github.io/.

Lifelong learning

It is not enough to only watch a documentary.

It can give you a first, quick overview about a topic. But if you want to dive in, you actually need to write about it. You need to transfer the content of the video into text.

The wikipedia has an example how this can look for a three-part documentary about electricity from BBC Four.

https://en.wikipedia.org/wiki/Shock_and_Awe:_The_Story_of_Electricity

Kevin Hale (2013): "Getting Developers and Engineers to Write the Docs"

Below are some talks from past events that we feel really captured the spirit of Write the Docs:

• Daniya Kamran --- Translating Science into Poetry
• Kevin Hale --- Getting Developers and Engineers to Write the Docs
• Matthew Butterick --- Typography for Docs
• Kenneth Reitz --- Documentation at Scale
• Heidi Waterhouse --- The New Sheriff in Town: Bringing documentation out of chaos

Videos from Write The Docs conferences:

• http://videos.writethedocs.org/category/3/na-2015
• http://videos.writethedocs.org/category/2/na-2014
• http://videos.writethedocs.org/category/1/na-2013

Write The Docs Europe Conference

Aug 31 - Sept 1 2015 in Prague.

Write the Docs is an event for anyone who cares about documentation and wants to gather and learn from like-minded people, no matter their personal or professional background. Whether you're a tech writer, programmer, designer, support technician, or something else entirely, come and share your tips, tricks, experiences, ideas, frustrations, hopes, and anything else that your passion for documentation inspires you to bring to the table.

• http://www.writethedocs.org/conf/eu/2015/cfp/

Some links for the Kotlin programming language:

• Project homepage — https://kotlinlang.org/
• Source repository — https://github.com/JetBrains/kotlin
• Trending Kotlin projects — https://github.com/trending?l=kotlin&since=monthly
• Interactive web console — http://try.kotlinlang.org/
• Discussion site — https://devnet.jetbrains.com/community/kotlin?view=discussions
• Reddit community — https://www.reddit.com/r/Kotlin/
• Maven repository for snapshot artifacts — http://repository.jetbrains.com/all/org/jetbrains/kotlin/

GitHub Pages is a nice place to host static websites. We also need a lightweight static site generator. I really like Harp.js and Metalsmith.

Harp.js provides a zero-configuration solution, whereas Metalsmith provides a configurable plugin system.

• http://harpjs.com/
• http://www.metalsmith.io/

"Java is a blue collar language. It’s not PhD thesis material but a language for a job. Java feels very familiar to many different programmers because I had a very strong tendency to prefer things that had been used a lot over things that just sounded like a good idea."

I think Kotlin is a language that adopts this idea really good.

• via: http://www.reddit.com/r/Kotlin/comments/30vgnn/does_kotlin_have_any_killfeatures/crxbe25

• James Gosling (1997): "The Feel of Java", http://www.win.tue.nl/~evink/education/avp/pdf/feel-of-java.pdf

Graph Theory

Hope I can write some interesting stuff about these gentlemen (and gentlewomen) graphs in the future:

Mr. House of Santa Claus Graph:

Mr. Markov Chain:

Mrs. Constraint Network Graph:

Mrs. Mechanism Design Graph:

They were typesetted in LaTeX with VauCanSon-G (not TikZ).

Some Mozilla guys released a paper about programming experience with their new programming language Rust and this Servo web layout engine.

I didn't program much in Rust, but follow a lot of their work on Github and Reddit. I have some old Rust code of a "CPU emulator" inspired by LLVM and libcpu by Michael Steil et al with deprecated sigil syntax ~ for pointers.

I really like Rust but the borrow checker is not my best friend.

• http://arxiv.org/abs/1505.07383, "Experience Report: Developing the Servo Web Browser Engine using Rust"
• https://github.com/libcpu/libcpu

This austrian music by Parov Stelar is fine. Listening to "Supereight" in repeat. Is this so called lounge music?

Thanks to the speedrunner Cosmo for inspiration.

This academic stuff is very arcane somehow. Let's go mainstream, but with a bit pattern-matching sugar:

fun fib(n: Int): Int {
    return when (n) {
        1, 2 -> 1
        else -> fib(n - 1) + fib(n - 2)
    }
}

fun main(args: Array<String>) {
    for (n in 1..10) {
        println("fib($n) = ${fib(n)}")
    }
}

Is recursion good? I don't know. Just make sure you use the iterative version in production code.

There is also a lot of beauty in the polymorphic defined recursive functions I first saw in Erlang:

-module(fib).
-export([fib/1]).

fib(1) -> 1;
fib(2) -> 1;
fib(N) -> fib(N - 2) + fib(N - 1).

Similarily, there is also a lot of beautyness when we consider logical programming and this substitution and unification stuff in Prolog. I first saw this, when I learned about contraint satisfaction problems.

append([], X, X).
append([X|XS], YS, [X|ZS]) :- append(XS, YS, ZS).

% ?- append([], [1, 2], [1, 2]).
% true.

% ?- append([6], [1, 2], [6, 1, 2]).
% true.

% ?- append(X, [1, 2], [6, 1, 2]).
% X = [6] ;

• Petra Hofstedt, Armin Wolf (2007): "Einführung in die Constraint-Programmierung", Springer

The first time I saw variable and return types on the right side after a colon was in ActionScript. This was beautiful.

function repeatString(string:String, 
                      numTimes:uint):String 
{
    var output:String = "";
    for(var i:uint = 0; i < numTimes; i++) 
    {
        output += string;
    }
    return output;
}

Now a lot of very nice modern programming languages use this convention: TypeScript, Scala, Kotlin, Rust, Swift.

Jetbrains Kotlin has a new fresh background image on its project site.

What does this tower mean? Somehow this is very impressive.

• http://kotlinlang.org/

June 4, 2015 @ Biking

• Distance: 40.5 km
• Elevation: 41 m
• Moving time: 2h 15m 47s
• Avg. speed: 17.9 km/h
• Max. speed: 38.9 km/h
• Audiobook: "Blink" by Malcolm Gladwell, chapters 1, 2

Several rounds around the Maschsee. A lot of other bikers, skaters and joggers around there. A big group of pensioners on the east waterside, of course on the street for bikers. Nice music and lights at the hotel near the sea.

Tested a running/biking app. I like the segmented way feature. One can compare their best times to others. I think one person cuts a GPS route into segments and the app uses a geometric buffer to match the routes of others.

http://www.strava.com/activities/318425419

I wonder how thoughtstreams relates to these fundamental thought processes I stumbled upon this month.

some software companies prefer to test job candidates on the white board instead in front of computers. I think the big advantage is here, that it helps interviewers to better understand the candidate's thought processes and how it relates to the team's thoughts.

there are also visual tools for diagrammatic thinking called thinking maps (based on the works of albert upton and richard samson), that can help with this process.

in thinking maps these processes are basically defining context, describing things, sequencing events, identifying relationships, classifiying, comparing and contrasting as well as analyzing causes and effects and illustrating analogies.

this indicator for the reading direction of streams is sometimes too small and too hidden. a bigger arrow icon on the bottom-center of the first card would be nice.

maybe also on the top-center of the last card for convenience.

if thoughtstreams makes it into an android app for my tablet:

increase the header's height, make the search field hidable, make the person data on the left hidable or smaller in width, change the hyperlinks outside of paragraphs to buttons, and add the ability to share selected texts and urls from other apps.

I really love the UI's layout so far, and my listed points are not a big problem so far.