Skip to main content

Scalar 2016

This year I’ve attended yet one more time one of the biggest Scala conference in central Europe – I am talking of course about Scalar.

My “Scalar adventure” started a day before the conference, during the official speakers dinner. Given the fact that I was taking part in Apache Spark workshop day before in Tricity, I’ve landed in Warsaw pretty late. Before I’ve actually sat down at the part, I’ve managed to: get lost in the city, find my way back to the club, meet Rafal from Virtus Lab, get lost one more time on a contrived & complex elevator system, before finally settling safely at the table.
During speaker’s dinner I’ve managed to have a (hopefully not too) long discussion with Mathias Doenitz. I don’t know how starting from Spary vs Akka-Http, through Rective Stream principles, we’ve ended up discussing different modern political system. The discussion was intense and engaging, but (when I think about it now) I get this notion that maybe Mathias had enough of me at the very end ­čÖé
When speakers party ended, it was time for me to move to the before party organised by Iterators. It was the same motor-cycle club/pub we’ve enjoyed last year. It was really awesome to see some old faces. I could not stay long that night, but a chance to meet that many friends in one place, was heart-warming before the next big day.

Chamberconf 2016

This year we held second edition of Chamberconf – an event that I call an anti-conference: mixture of talks, unconference, alcohol and rock&roll. The venue is always unique (a castle, palace or any other chamber), audience is small (80 people) but spirits and content are always high!
I’ve wrote few weeks ago about my love/hate relationship with conferences, but Chamberconf is something completely different. It’s a place where direction of speakers-audience vector is shifted: here the value of the event is tightly correlated with people attending it.

This year’s edition took place in Pa┼éac ┼üag├│w. How was it? Well, let this video talk for itself:

How did you guys enjoyed the Chamberconf conference? I would love to hear your story!

My Emacs For Scala Development – Part 2

This is Part 2 of “My Emacs For Scala Development. You will find Part 1 here.

Cumbersome navigation

So far we’ve learned how to open a new file (`C-x C-f`). Each time we open a new file, buffer is created. To get the list of all opened buffers you will have to `C-x C-b`. To split current window (in order to see two different buffers at the same time) you will `C-x 2` (for horizontal split) and `C-x 3` (for vertical split). To switch between splits you will have to `C-x o` and to go back to full-window mode run `C-x 0`. Finally to switch quickly to the buffer on left(or right) of your given buffer, you will `C-x left-arrow` or `C-x right-arrow` accordingly.

“The Flow”

You will quickly learn that the default configuration described above… it, well, it simply sucks! You might wonder “What? Why? It gets the job done, what more do you need?”. The answer is: “The Flow”.
Whenever we are working with Emacs, we are targeting to grab what some people call “flow”. An efficient, smooth and fast way to craft your code. In ideal state, your hands are steady, placed in one position, with your palms firmly laying next to the keyboard, never changing their position. While in the same time your fingers gently move around your keyboard, each key being pressed by the right finger. Modes and functions are being executed instantly, providing quickly currently needed functionality. An unfamiliar observer may get a notion of magic appearing in front of his eyes, as code is being produced, shortcut are being used and mouse is never touched by an Emacs user. Getting to that semi-Nirvana state takes time and practice, but it’s worth to aim for it, because “the Flow” is where the true power of Emacs really lies.

Our general goal is to seek that enlightenment. Endeavor true efficiency and speed. Let’s take small steps toward that now.


For long I had hate/love relationship with conferences. Their idea, the way I see it, was lost. Conferences I attended in early 2007/2008 were different. At some point everything has changed and went wrong (or maybe I evolved?).

The Venue

We tend to attend big conferences. The bigger the better, right? Organisers bragging about 1000+ attendees, giving up yo-yos, bags full of useless gadgets. They let us play the most ridiculous sponsors’ games (Q: “What will be result of `i++; j+(–i)+(++j)+(i++)`”; My Answer: “I don’t want to work in a company that produces such a mess”). The venue is big, the venue is overwhelming. And while we “feel” that we are taking part in something really big, I say we aren’t really.
Does it mean that 1k+ conferences are all bad? No! There are some I will always enjoy going to. What I say is, that organising numerous conference is a challenging undertaking. Task that requires a lot experience in logistics, management, while in the same time keeping the “spirit” of the event that is being organised. I feel that many conferences fail miserably on those fields.

My Emacs For Scala Development – Part 1

After years of using Intelij IDEA both as Java and then Scala developer, I’ve finally said enough is enough. I could somehow live with the fact that with each version dramatically changes the way you configure the Scala plugin. It was pain (yet bearable) that majority of features I was so accustomed to as Java developer, were simply not represented in the Scala experience. But the thing that crossed the line was it’s slowness. Horrifying, horrendous┬áslowness! I stopped running tests in IDE as SBT was way faster (by the time the tested passed in SBT, Intelij was still compiling sources). Code completion did not work (or worked with 5 seconds latency). I could go on with examples, but the bottom line is that Intelij became enormous, gigantic process that consumed 1 GB of RAM to provide features of a sluggish, leisurely, languid text editor.

That’s when┬áI discovered Emacs. Yeah, I know, it took me a while. But better late then never. I was hoping to get fast text editor with colour┬áhighlighting, but I got much much more richer tool. Today I can not think of not using Emacs for any kind of development: Scala, Haskell, Erlang – you name it. Once you are sucked in, you are there forever.

Emacs is all about configurability. However it took me a few weeks to get things the way I want them to be. In the following posts I plan to document all that I’ve learned so far.

99 Scala Problems Challenge – 4/333

Problem 4 – Find the number of elements of a list

P04 (*) Find the number of elements of a list.
scala> length(List(1, 1, 2, 3, 5, 8))
res0: Int = 6

I’ve started with writing some tests to verify my future implementation

test("that empty list is of length 0") {
    p04.length(List()) should equal(0)

test("that one-element list is of length 1") {
    p04.length(List(1)) should equal(1)

test("that returns the list length") {
    p04.length(List(1, 3, 7, 9, 0)) should equal(5)


Talking at London Scala User Group

Few days ago I flew to London to give a talk about Apache Spark at local Scala User Group. This was both enriching and fun experience. Not only I could catch up with some old friends, but I was also able to meet new ones. I also had time to do a lot of sight-seeing, thanks to my lovely wife, who guided me through all the cool places that London has to offer. We’ve also had couple of unexpected surprises, one of which was actually showing up late at Skill Matter’s venue due to the the fact we’ve completely messed up our time table. Eventually we were forced to take a taxi, which, as one can imagine, is extremely expensive in London.

Around 120 people showed up at the venue. I was happy to learn that the audience was pretty much familiar with Map Reduce concepts, thus, even though I’ve stared with my original talk “Apache Spark 101”, I was able to quickly skip through a lot of slides and focus on Spark’s core and internals.


99 Scala Problems – 3/99

Problem 3 – Find the Kth element of a list.

P03 (*) Find the Kth element of a list.
By convention, the first element in the list is element 0.
scala> nth(2, List(1, 1, 2, 3, 5, 8))
res0: Int = 2

Return n-th element

As the problem seemed easy and straightforward I wrote first test that checked general case

class P03Test extends FunSuite with Matchers {
  val p03 = new P03[Int]()

  test("that returns nth element") {
    p03.nth(0, List(7, 6, 2, 3, 5, 8)) should be(7)

Implementation was nothing more then, well …, returning the n-th element

class P03[T] {
  def nth(nth: Int, list: List[T]): T = list(nth)

Well, that was oddly fast. I knew there must be something more to it.

What’s so BIG about Big Data?

Term Big Data is in the top ten of most popular buzz words in the industry nowadays. You’ll find it flying back and forth on Twitter, you will talk about it at your local meet-up and you won’t be able to skip it at your next IT conference. There are more then few completely different coursers currently running on Coursera, that touch the ground of big data and data science. There’s even a chance, that the next HR specialist that you encounter, will present his latest work opportunity with phrase “big data” somewhere in the middle of the job description – since you are the person he trusts ­čśë

So what is this fuss all about? Is it just yet another word that we came up with, to name a commonly known issue that the industry tries to address since the beginning of the 80’s or even 70’s? Or is there more to it and we are really challenging completely new, vast and unexplored landscape of computer science world?
This is really hard and difficult question to answer. In order to do so, we need to first find out what are the challenges of the Big Data. What kind of problems does it try to address.

99 Scala Problems Challenge – 2/99

Problem 2 – Find the last but one element of a list

P02 (*) Find the last but one element of a list.
scala> penultimate(List(1, 1, 2, 3, 5, 8))
res0: Int = 5

Empty list and one element list scenario

I’ve started with a test which stated, that both empty and one-element list should return None.

class P02Test extends FunSuite with Matchers {

  val p02 = new P02[Int]()

  test("that returns none for empty list") {
    p02.penultimate(List()) should be(None)

  test("that returns none for one-element list") {
    p02.penultimate(List(5)) should be(None)

And implementation was simple enough to fit the requirements

class P02[T] {
  def penultimate(list: List[T]): Option[T] = None