10 open source tech you should take a look at, before 2023

Founder, robot with feelings. From planet Aiur.

We take a look at strong tech developed in the 2023s

At the beginning of the year, when I started building Archbee, 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

Document image

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:

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

Document image

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:

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

Document image

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:

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

Document image

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."

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

Document image

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.

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

Document image

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:

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

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

TensorFlow is a 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

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.

10. The ELK

Document image

“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.”

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;

Frequently Asked Questions

What is Swift and why should you consider learning it?
Expand FAQ
Swift is a second generation programming language created by Apple. It's known for being less clunky than Objective C and it's able to run on Linux, making it versatile. Key features of Swift include non-nullable types, first-class functions, automatic reference counting for memory management, and SwiftUI, a powerful UI library. Also notable is it has a growing server-side community, maintains high performance due to LLVM bytecode compilation, and offers Swift playgrounds for easy learning and experimentation.
What is the focus of TensorFlow and why is it recommended for learning?
Expand Button
TensorFlow is a toolkit for machine learning developed by Google. It is known for high performance and scalability. Its key offerings include bindings to high-level languages like Python, JavaScript and Swift, the ability to run on both CPU and GPU, and access to many already trained models. Learning TensorFlow can allow users to participate in advanced machine learning initiatives that have far-reaching impacts across various industries.
What are the notable aspects of Elm and why should you learn it?
Expand Button
Elm is a simple programming language focused on frontend development. Key features of Elm include a rock-solid type system, zero runtime exceptions, The Elm Architecture for building user interfaces, and a fast, type inference-supporting compiler. Additionally, Elm handles dependencies via Enforced Semantic Versioning. Learning Elm can equip developers with a reliable tool for frontend development, encouraging efficient coding practices and reducing potential errors.
How does Kubernetes enhance systems operation in the cloud and why should you consider learning it?
Expand Button
Kubernetes is an open-source system for automating deployment, scaling, and managing containerized applications. It provides a framework to run distributed systems resiliently, offering features such as self-healing, automated rollouts and rollbacks, and secrets and configuration management. Kubernetes modules are loosely coupled and extensible to support diverse workloads, promoting greater efficiency and resource management. It's recommended for DevOps professionals and developers working in a microservices architecture.
What is Kotlin known for and why should you invest time in learning it?
Expand Button
Kotlin is a modern, less verbose alternative to Java developed by JetBrains. It became popular when Google recognized it as an official language for Android. Kotlin is multi-platform, enabling it to compile to JVM, LLVM and JavaScript. It's known for its modern type system, excellent additions to its standard library like Arrow, and compatibility with the mature server-side ecosystem of Java/JVM. It's beneficial for individuals interested in developing Android applications and server-side programming.

📖 Table of contents

Answer questions instantly

Create and share documentation that answers questions instantly with Gen AI

Discover Archbee

Receive documentation and technical writing tips & trends — our newsletter

Join 5000+ people from around the world that receive a monthly edition of the Archbee Blog Newsletter.


Knowledge Management