10 open source tech you should take a look at, before 2020
Tags: tech
Published: 2019-07-30 06:51:38

---
title: 10 open source tech you should take a look at, before 2020
published: true
description: At the beginning of the year, when I started building [Archbee](https://archbee.io), I evaluated some cool tech out there. Here's the list of the tech I think will change the world in ways we can't even predict.
tags: #tech #opensource 
---


At the beginning of the year, when I started building [Archbee](https://archbee.io), I evaluated some cool tech out there. Here’s the list of the tech I think will change the world in ways we can’t even predict.


#1. Swift
![Alt text of image](https://aws1.discourse-cdn.com/swift/original/2X/0/0d7ab3b633e07bf8ec99bdc18e22ad89d8934801.png)

Objective C was perceived as clunky/verbose by many, and hard to teach to younger developers. So Apple decided to brew their second programming language, Swift.
They recruited Chris Lattner, notorious from his work on LLVM and conceived one of the most impressive languages ever.
What many don’t know is that Swift is open source, and has a big and growing community behind it. They made Swift work on Linux, created Swift Package Manager and are making Swift a workable server-side language, all happening in a very short amount of time.
Take a look at a SwiftUI intro from Twilio:
{% youtube uv5L2HQqDPU %} 

###So why should you invest your time in learning a bit of Swift?
* Borrows heavily from functional languages with features like: non-nullable types, immutable data structures, first-class functions, higher-order functions, sum types with exhaustive switch patterns, partial and pure functions, tail-call optimisations for recursion, extensions and many more; Swift is no Haskell, but goes a long way from classic OOP languages like Java and C#;
* Swift is compiled to LLVM bytecode, so no CPU cycles will ever be wasted;
* Has Automatic Reference Counting for memory management. Although it can’t compete with something like compile-time memory management in Rust, in my opinion, ARC is the second-best;
* SwiftUI is a great UI library by Apple — heavily influenced by React, it proves once again that the ideas behind React are great: top-down data flow, immutability and language level declarative views. SwiftUI is not open-source but it’s so cool that it deserved to be on the list;
* Growing server-side ecosystem — Vapor and Kitura both great for writing backend systems; a bit immature, but very workable with;
* XCode is a very mature, fast and editor that is a pleasure to work with.
* Swift playground makes it easy to learn and experiment because of its immediate feedback, no compile required.
* Swift’s future is bright because of the active and excited community;
One of the highest paying jobs;


#2. Kotlin
![Alt text of image](https://kotlinlang.org/assets/images/twitter-card/kotlin_800x320.png)

A bit of the same story as Swift, Kotlin came to life as a modern less verbose Java alternative on the JVM.
Surprisingly, this great language was created and is being developed by JetBrains, a company that makes code editors.
Kotlin became popular through Android, when Google made it an official language for its OS, but is becoming a monster alternative for Java in the server-side world too, mainly because Spring Framework made it a priority to have it as first-class citizen.
Quick intro from Kotlin’s project lead:
{% youtube 6P20npkvcb8 %} 

###So why should you invest your time in learning a bit of Kotlin?
* Kotlin is multi-platform, meaning you can compile it to JVM, LLVM (and WASM by association) and JavaScript, covering most use cases;
* Modern type system with non-nullable types, generics, comprehensions, and great influences by functional programming languages. Arrow is an excellent addition to its standard library, take a look here: https://arrow-kt.io/;
* Server-side Kotlin can benefit from one of the most mature server-side ecosystem built over more than two decades since Java/JVM was introduced;
Coroutines make it a great programming language to build scalable asynchronous web APIs, but unfortunately, most libraries will block as they were designed for the old thread-per-request paradigm.
* One of the best IDEs out there — IntelliJ IDEA;
* React bindings for when you compile to JavaScript to build web apps.
Compile to executable files like Rust or Go.


#3. Kubernetes
![Alt text of image](https://d1.awsstatic.com/PAC/kuberneteslogo.eabc6359f48c8e30b7a138c18177f3fd39338e05.png)

When Docker came around, many developers didn’t see the value. Dependency isolation seemingly was not enough for most to make the switch from bare VMs running in the cloud.
After Google to open-sourced their internal project Borg, everybody started to see why containers and container orchestration are the way of the future for running systems in the cloud and on-premise.
Quick video explanation of Kubernetes:
{% youtube PH-2FfFD2PU %} 

###So why should you invest your time in learning a bit of k8s?
* Declarative infrastructure means you’ll be done with error-prone manual configuring of your system. Yes, YAML is not the best, but solutions like Pulumi make it a lot more reasonable;
* Distributed systems are more resilient, and Kubernetes makes it a lot easier to build one;
* Almost Hands-free scaling by just running configuration changes to add nodes or scale containers;
* Automatic revival of dead/crashed containers, with zero downtime deployments;
* Readiness and liveness probes for containers;
* Small to no attack surface if you create your cluster in private networks, only exposing through Ingresses;
* Greater security than self-managed servers: most hosted k8s clusters will have great security defaults right out the box;
* Most cloud providers will provide you with a free k8s master, so no actual resources will be added to your cost;
* As long as you can package your services as Docker containers, everything will work 100% the same in development and in production, making the development process faster;


#4. Elixir
![Alt text of image](https://pbs.twimg.com/profile_images/683949209050046464/-MWyJCb1.png)

What a beauty of a dynamic functional language! Built on top of the rock-solid Erlang VM and benefitting from the ecosystem and stability, Elixir marks the spot as one of the crucial technologies developed in the 2010s.
They said it best on their homepage so I’m just going to quote it:
“The unavoidable truth about software running in production is that things will go wrong. Even more when we take network, file systems, and other third-party resources into account. To cope with failures, Elixir provides supervisors which describe how to restart parts of your system when things go awry, going back to a known initial state that is guaranteed to work: The combination of scalability, fault-tolerance, and event-driven programming via message passing makes Elixir an excellent choice for Reactive Programming and Architectures.”

{% youtube cWAHpvkh8Vs %} 

###So why should you invest your time in learning a bit of Elixir?
* Functional language with immutability by default, first-class and higher-class functions, pattern matching, structs, sigils;
Phoenix Framework is really great, taking some hints from Ruby On Rails in productivity but scales a lot better and easier on the computing resources;
* Already true, but in the 2020s non-realtime applications won’t be acceptable anymore for user experience. This means that any language/platform with a focus on realtime data sync and WebSockets will have the edge, and Erlang VM + Elixir does it best in my opinion; Read up on the story of how WhatsApp team productivity skyrocketed with very low computing resources here: https://www.wired.com/2015/09/whatsapp-serves-900-million-users-50-engineers/;


#5. Elm
![Alt text of image](https://upload.wikimedia.org/wikipedia/commons/thumb/f/f3/Elm_logo.svg/1200px-Elm_logo.svg.png)

Elm is a delight. A very simple programming language with guarantees like no other.
Have you heard of the expression “Zero runtime exceptions”?. That comes from Elm.
Its Haskell inspired type system allows it to do this, meaning you’ll sleep better at night.
Elm is also very specific on what problem it solves — frontend development. In my opinion, this is a great choice by Evan Czaplicki acknowledging that “catch-all use-cases” languages won’t cut it anymore.

{% youtube o_4EX4dPppA %} 

###So why should you invest your time in learning a bit of Elm?
* Rock-solid type system means you’ll refactor easily because the compiler will guide you;
* Zero runtime exceptions in practice;
* Built-in toolkit for building user interfaces called The Elm Architecture (TEA). TEA is so great it inspired lots of clones in many other languages;
* Compiler is top-notch: set the new standard for error messages in the industry, very fast, type inference works great;
* Great ecosystem with “Enforced Semantic Versioning” meaning your dependencies will always know if something is broken or not — at build-time;
* Best asset size in the industry — smaller than React and even Preact.
* As you can see Elm has constantly set a bunch of new standards in our industry. Def one of the top innovations of the 2010s.


#6. Flutter
![Alt text of image](https://upload.wikimedia.org/wikipedia/commons/1/17/Google-flutter-logo.png)

Building native UIs is a very hard task. Add that you need to do it for 4–5 operating systems, and you’re in deep trouble. This is why Google started building Flutter, initially focusing on Android and iOS, and eventually adding the Web Platform and even macOS and Windows apps soon.
Take a look at this video:
{% youtube 80pRyn7fZRk %} 

###So why should you invest your time in learning a bit of Flutter?
* Helps you build performant mobile apps;
* Great backing from Google, which apparently is trying to build another OS called Fuchsia based on Flutter UIs;
* Dart 1 is kind of boring and old-school, but Dart 2 is more functional programming oriented, and also very specific on solving UI problems best;
Flutter’s hot reload helps you quickly and easily experiment, build UIs, add features, and fix bugs faster. Experience sub-second reload times, without losing state, on emulators, simulators, and hardware for iOS and Android.
* Delight your users with Flutter’s built-in beautiful Material Design and Cupertino (iOS-flavor) widgets, rich motion APIs, smooth natural scrolling, and platform awareness.
* Dart + Flutter has great IDE support in Intellij IDEA and Visual Studio Code;


#7. Redis
![Alt text of image](https://redislabs.com/wp-content/themes/redislabs/assets/images/redis-logo-stack.png)

From their homepage:
“Redis is an open-source (BSD licensed), in-memory data structure store, used as a database, cache and message broker. It supports data structures such as strings, hashes, lists, sets, sorted sets with range queries, bitmaps, hyperloglogs, geospatial indexes with radius queries and streams. Redis has built-in replication, Lua scripting, LRU eviction, transactions and different levels of on-disk persistence, and provides high availability via Redis Sentinel and automatic partitioning with Redis Cluster.”

###So why should you invest your time in learning a bit of Redis?
* Redis is insanely fast;
* Redis is a very versatile toolkit;
* You can use it as a cache store, database and message broker;
* You can use it as an in-memory data structure store, which is the most important aspect of Redis in my opinion. In the era of microservices, if you need some shared state that you need to modify concurrently, you basically have no choice but to use Redis;
* Most cloud providers will provide a managed Redis service for you;
* Bindings to most programming languages;
* Very small API surface, and very intuitive;
* Very scalable through high availability and automatic partitioning.


#8. TensorFlow
![Alt text of image](https://miro.medium.com/max/600/1*q2SZIL06g5ydAGUG1iHSzA.png)

TensorFlow is Google’s machine learning toolkit. From their homepage:
“TensorFlow is an end-to-end open-source platform for machine learning. It has a comprehensive, flexible ecosystem of tools, libraries and community resources that lets researchers push the state-of-the-art in ML and developers easily build and deploy ML powered applications.”
TensorFlow’s core strength is performance. It was built for taking models from research to production at massive scale and it delivers. Persevere and you’d be able to join the ranks of ML practitioners who use it for incredible things, like finding new planets and pioneering medicine.
The TensorFlow community put in a lot of elbow grease to make the initial magic happen, and then more effort again to polish the best gems while scraping out less fortunate designs. The plan was never to force you to use a rough draft forever, but perhaps you habituated so well to the discomfort that you didn’t realize it was temporary.


###So why should you invest your time in learning a bit of TensorFlow?
* High-performance machine learning library
* Bindings to high-level languages like Python, JavaScript and Swift;
* Can run on both CPU and GPU;
* Scalable horizontally;
* Many available trained models;
* Huge community, and backed by Google and a lot of big companies;
* Keras — the higher-level abstraction is now built into Tensorflow;
* Tensorflow 2.0 coming soon — “TensorFlow 2.0 focuses on simplicity and ease of use, with updates like eager execution, intuitive higher-level APIs, and flexible model building on any platform”.


#9. Istio
![Alt text of image](https://miro.medium.com/max/450/1*ikTnD7xDCs2Hi3-gX9qA3g.png)

Many organizations migrated their existing monolithic workloads/systems to Kubernetes.
But that is not where Kubernetes provides the most value, it’s in microservices architectures.
But this new way of writing systems brings a new set of problems with it, like: observability, connecting, controlling and securing the microservices. This is where Google saw the opportunity to build Istio, a service mesh.
If you are more on the DevOps side, you def need to take a look at Kubernetes and Istio.

{% youtube 1iyFq2VaL5Y %} 

###So why should you invest your time in learning a bit of Istio?
* Istio is very high performance, written on top of Envoy (C++);
* Helps you solve most of the problems that arise with microservice-based architectures;
* Side-car design pattern: most of the stuff every microservice needs to perform (logging, security, figuring out DNS, rate-limiting) will be moved out of the microservice into a “side-car”. This means less code (and error-prone) in each of your microservices;
* If you run on Google Cloud, you’ll be able to benefit greatly by their integration and ease of deployment.


#10. The ELK
![Alt text of image](https://miro.medium.com/max/980/1*AI3xU9ubuIBUoNlWR23Zhw.png)

“So, what is the ELK Stack? “ELK” is the acronym for three open source projects: Elasticsearch, Logstash, and Kibana. Elasticsearch is a search and analytics engine. Logstash is a server‑side data processing pipeline that ingests data from multiple sources simultaneously, transforms it, and then sends it to a “stash” like Elasticsearch. Kibana lets users visualize data with charts and graphs in Elasticsearch.”

{% youtube 6P20npkvcb8 %} 

###So why should you invest your time in learning a bit of ELK?
* Best in Class User Interface for Data Analysis;
* Data Visualization for the Amazing price of… Free;
* Extendable Source and Aggregation;
* Hosted by many cloud providers;
* Very versatile — works from ingesting logs, to text search, to filtering through huge datasets.

#Article originally published at https://archbee.io/blog/10-open-source-tech-you-should-take-a-look-at-before-2020