| Author: | Wojciech Muła |
|---|---|
| Added on: | 2018-11-18 |
Contents
In November this year there was new edition of code::dive, an IT conference in Wrocław, Poland. Practically nothing has changed from the previous edition: it is still great. The place is perfect, it's in a huge cinema located in the city center. There were free snack and water, and amazing coffee at decent price (the only downside was huge queues). As always, there were a lot of interesting talks; a new thing were "lighting talks", run during lunch break.
This edition was a bit different, though. Although Nokia still sponsors the conference, the organizers asked participants to buy tickets (25 złotych, 5 euro) and then gave all income to Polish Association of the Blind; I totally love this approach. BTW, approx 38,000 złotych were collected.
Disclaimer: I'm Nokia employee right now, but am writing this text in my spare time. The employer was so kind that I went to the conference during working hours.
The talks I attended:
This talk, split into two parts, was packed with information. Viktor presented an awful lot of different techniques and tools that might boost building C++ applications. On one hand it's good, but on the other hand I fell somehow overloaded.
I didn't like the slides. They were filled with lots of text, and also have links to other presentations or articles. It might be useful when one goes through the presentation at home, at own pace. On a conference it doesn't look well.
What I missed the most was real-life examples, hard numbers. There were some, but still not much. Also statements like "reportedly it's faster" are not too convincing.
I really liked the history of C++ modules. I'm always saying that development of C++ is too slow and it's delayed several years to market needs. Modules are a bright example. The first proposal appeared in 2004. Moving fast forward, now we have 2018 and modules have just been accepted for the upcoming standard. Only 14 years, and it's almost there! But the idea of modules is not new. For instance, the first Ada edition from 1983 had modules (not to mention Modula by Wirth); Ada 1995 introduced generic modules, that can be parametrized with types. C++ programmers might be envious.
Mateusz tried to defend a thesis that Go programs are by design clean. The definition of "clean code" is that something is clean if you see there what you expected to see.
The speaker cited all statements from the Go creators. So, we know that Go syntax is simple, there are no exceptions nor classes. That Go is stable, there are no new features and so on, and so forth. A Go source code is simple to read, reason about, etc. I was a bit disappointed with this form, I rather expected some real-world examples; I can always read Go propaganda on Hacker News.
And to be honest, I didn't get convinced. But I liked the talk, as Matuesz also mentioned not so bright features of Go. Like lack of generics which forces people to copy-paste-driven development.
The funny fact is the Go creators thought the language would lure C++ programmers, as they solved some painful C++ problems. It hasn't happened, people switched from PHP, Python and other dynamically-typed languages, but not from C++.
My English teacher often says that I would do exercises from our textbook much better if I read instructions. Add my glasses to this and you'll understand why I was sure I was going to see "GoLang Tips & Tricks".
The single letter made the difference. It was the live demo of a commercial product, an IDE for Go. During the presentation an extremely easy Go project was edited and refactored.
But I'm not going to complain, to my surprise I enjoyed the show... in a way.
Let me start with a bit of personal history. Last time I used an IDE was 15 years ago. It was a pirated copy of Borland Pascal, run in DOS and I was obviously younger. Later, when I moved to Linux, I realized that with multiple shells — provided natively by the system or programs like screen — an IDE is overkill, if not a plainly stupid concept. The standard shell commands, VIM and screen are enough to work rather efficiently.
So, while I was watching how these colorful boxes popping around, how magic combinations of keystrokes have to be pressed in order to do basic text editing, how many mouse clicks are needed to do this and that, I felt this is not how I want to write my code. Ever. A simple script is better than two clicks. This is my motto coined during writing this paragraph.
I enjoyed the talk, one of the best I saw this year. Andreas showed how simple allocation strategies work and also what traits do they have. He described memory pools and another one which name slept my mind (it's the allocation algorithm used by Pascal, where you allocate many objects but can free only all objects at once).
We also learnt that C++ offers an interface to plug custom allocators, and that the names of related namespace/function are as always counter-intuitive. The C++ committee is bad at names.
I'm not sure for 100%, but Brandon was the first presenter who wore a tie.
The whole lecture was funny. I love the slides — there were a few words on each slide, typeset in a large font. One can read a slide in an eye blink, and then concentrate on the speaker. Learn from Brandon.
It was talk about Python, how the language borrowed and simplified concepts, mostly from C++. He made fun from JavaScript ('4' - 3 is int(3), but '4' + 3 is "43"), saying that such an absurd are almost nonexistent in Python.
One really funny thing that caught my attention was hesitation about "tuple" pronunciation; English is funny.
BTW it was said that CPython has no garbage collection, but only referenced counting. It's not true, there's a generational garbage collector, which can be accessed via a standard module gc. Simple reference counting doesn't deal with cyclic references.
A nice description of three cases from Polish companies, huge ones: an insurance company and telecom. Unfortunately, the talk was too technical, most people are not data science practitioners. I expected something lighter and easier to digest, sometimes it was a bit difficult to follow.
Most important takeaways from this talk are: 1) the big business is keen on spending money if it can help (save more money, for instance), and 2) data science doesn't require top-notch technology, most of work can be done on consumer hardware; I think only the telecom case involved extra servers.
Do not confuse this talk with "C/C++ vs Security" (without the exclamation mark)!
It was a nice talk, which I didn't like. I feel like it was too chaotic, where rather simple problems were mixed with very complex (like Spectre). Try to explain Spectre in five minutes to a person who doesn't know modern CPUs' details; it won't work, sorry.
My second favourite talk. It was a story about IT reality, about hurdles, about specifications and implementations. I'm sure everybody listening to Gabriela stories will find there part of their own history. Thus no spoilers, but definitely loved XKCD used wisely!
A good overview of state of the art of augmented reality. The state is that although different solutions appears on the market they are not successful. But according to Rafał, this will finally happen and we should be already prepared.
One important takeaway is that we usually thing about augmented reality in terms of vision, but humans have more senses. For instance, these noise-cutting headphones are means of augment reality, which surprised me.
Well, this talk reminded me following joke: "any web service can be represent by a nine-element tuple, but... it doesn't help".
Bartosz showed algebra of functions, which is the foundation of, I guess, all functional languages. He claimed that C++ would be a better language if its type system was designed bottom-down, from these fancy theory. The problem is that all languages meant to replace C++ are either dead or used by few people. Also functional languages haven't taken over the IT world. My gut feeling is that a type system is not a crucial problem.
The speaker had enormous number of slides, so he managed to show us just a small portion of material. But I liked this, it was a bit like time travel to the past when I was programming in SML, Ocaml and reading about Clean (the language).