
Managing software and the machines that are running it can be a challenge.
Kubernetes makes it easy to manage and deploy software on a cluster of machines.

## Why use Kubernetes?

We at Ontola use Kubernetes for most of our deployments.

- **Automate deployments**. Achieve continuous integration by deploying your software automatically and programmatically.
- **Easy scaling**. Grow or shrink your cluster of machines automatically, and only scale the applications that need it.
- **Self-healing**. Automatically restart containers that fail.
- **High compatibility**. Works with AWS, DigitalOcean, Azure, Google, and others.
- **Easier devops**. With Kubernetes, most of the logic and configuration required for managing your applications is stored in standardized, re-usable files.

## Need help?

The Kubernetes [documentation](https://kubernetes.io/docs/home/) and [tutorials](https://kubernetes.io/docs/tutorials/) are a great place to start.
If you need any other help with Kubernetes to manage your devops, feel free to [get in touch](/contact)!


Managing cloud environments with Kubernetes


NextJS is a modern framework for building websites.
It combines the flexibility of modern web applications with the speed of static websites.
By making clever use of _Server Side Rendering_ (SSR), NextJS applications can be loaded very quickly into browsers.
NextJS uses the [React](/enl/tech/react) framework.
This builds websites with _components_, which are reusable.
This modular approach allows a NextJS website to grow.

This website is also built in NextJS.
You can [view the source code on Github](https://github.com/ontola/home).

## Why Use NextJS

- **Fast loading, fast clicking**. NextJS supports static site generation (SSG), server-side rendering (SSR), and client-side rendering (CSR). As a result, NextJS applications load extremely fast.
- **Better SEO**. Due to the short loading times, your pages rank better in search engines.
- **Works with virtually all back-ends**. NextJS works with various CMS systems and databases, such as Stripe, Contentful or any [RESTFul APIs](/en/blog/api-design)
- **Easy Deployability**. Services like AWS Amplify and Vercel make hosting NextJS applications very fast.
- **Translations**. You can make NextJS websites work well in different languages.
- **Fast development**. NextJS is nice to work with because it allows you as a developer to get results at a fast pace.
- **Images**. NextJS converts images to the right sizes, without you having to optimize yourself when uploading. This saves time and keeps the website fast.

## Combine with...

You can choose to manage your NextJS application data as files in Git, but that's not useful if your content changes a lot, or if non-programmers need to be able to modify the content.
You can use services like [Contentful](https://www.contentful.com/developers/docs/compose/building-a-website-with-compose/), or develop a custom back-end.

## Do you want a NextJS application too?

Then get in touch!


What is NextJS, and when should you work with it?

NextJS website development


React JS is the most popular front-end Javascript Library to develop web applications with.
It was developed by Facebook, and then used as an Open Source library in many thousands of projects.

## Why use React?

We at Ontola are fans of React - most of our projects (including this website) are built with it.
So in many cases we recommend developing web applications with it.

- **Re-usable components**. In React you build _components_, which can be shared between screens and between applications. This keeps your code manageable and modular.
- **Gigantic community**. A large community means that it is easy to find solutions if you have a problem. In addition, there are very many ready-to-use components to be found. Finally, you can also find many developers for it!
- **Fast development**. Building with React is fast - and a productive developer means a happy customer!
- **Flexible deployment**. React can be used from highly dynamic, agile applications, to static websites (like this one).
- **Short loading times**. With React, web applications can be built both on the server (_SSR_), and in the browser. This makes for very short loading times!

## Combine with...

React is a front-end library, and thus (often) needs a back-end where the data should come from.
A few suitable options (which we also work with a lot) are:

<TechWrapperSmall>
  <TechPill technology="nextjs" />
</TechWrapperSmall>


Developing React JS web applications


Rust is a modern programming language that is rapidly gaining popularity.
It is _low-level_ language with _high-level_ features, which compiles directly to machine code (assembly).

## Why use Rust

- **Safe**. Rust introduces a unique solution to manage memory called _ownership_. This ensures that Rust applications are typically very secure.
- **Fast**. Rust allows you to get the last bit of performance out of your machine. It is therefore no surprise that in most benchmarks Rust applications come out as the very fastest.
- **Compact**. A Rust application can be compiled into small binaries (executables).
- **Run anywhere**. You can compile Rust to practically any platform.
- **No runtime required**. You can run a Rust application _without external runtime_, unlike languages like Python, Javascript and Java.
- **Blessed programmers**. Rust has been [voted](https://insights.stackoverflow.com/survey/2021#technology-most-loved-dreaded-and-wanted) the most popular programming language every year since 2016, and we understand why.

## Ownership and the Borrow Checker

The most distinctive new invention of Rust, is the concept of _Ownership_ (ownership).
It is a solution to a fundamental aspect of how computers work today: keeping track of what data can be released into your working memory.
As an application runs, it typically loads more and more data into working memory.
Every computation needs working memory.
It is the responsibility of the software to free up this working memory again when it can.
Traditionally, two solutions to this problem were:

1. **Manual memory management**. The programmer must indicate in his code when a piece of memory can be freed. This is a cumbersome and above all error-prone process, which can cause nasty (unsafe) bugs. For example [Microsoft indicated that 70% of the security issues come from memory management](https://www.zdnet.com/article/microsoft-70-percent-of-all-security-bugs-are-memory-safety-issues/).
1. **Garbage Collection**. The programming language's _runtime_ occasionally removes pieces of data from working memory that are no longer needed. This is nice and easy for the programmer, but it causes your code to become _trager_, because your application now has to spend time checking what can be discarded.

Rust introduces a third solution to memory management: _Ownership_.
In Rust, every variable (every piece of data in your working memory) is owned by a certain _scope_.
When a variable leaves this scope, the piece of data can be pulled from working memory.
An elegant solution, as this does not cost the application any extra time, allowing you to achieve the full 100% of the theoretically achievable speed.

## WebAssembly and Rust

WebAssembly is a standard to describe applications with.
It is not so much a programming language, but a _compilation target_ (just like the Assembly mentioned earlier).
So it is (almost) not written by humans, but programming languages can compile to it.
With almost all compiled applications, they must compile to a specific _target_ (a specific architecture).
For example, an application for Windows has a different binary than one for MacOS, or for Linux.
This means that you as a developer have to take that into account, and thus offer (quite a lot of) different versions.
That takes time, and makes the distribution of your application a lot more complicated.

What makes WebAssembly interesting is that it runs practically everywhere.
The same WebAssembly code runs on x86, Arm, 32bit, 64bit....
It is designed to run in Browsers, as an alternative to Javascript.
This allows some tasks to run a lot faster.
It also allows you to reuse code from a programming language that compiles to WebAssembly, without having to rewrite it in Javascript.

But WebAssembly is not _only_ interesting for browsers.
WebAssembly _runtimes_ are environments that can run WebAssembly, as is in your browser.
We can also use these runtimes in a server context.
The features that make it suitable for browsers also enable a whole new kind of server architecture.
It starts up fast, it's secure, it's lightweight.
For example, the emerging FaaS (Functions as a Service) architecture works very well with WebAssembly.
For example, Amazon with Lambda and Cloudflare with their Workers already offer ways to write server logic with WebAssembly.
In addition, WebAssembly is also an interesting language for developing plug-in architecture.
All in all, there are lots of applications for WebAssembly that will now grow in popularity in the coming years.

One of the unique advantages to Rust, is how well it compiles to WebAssembly.
The generated binaries are fast to execute, start up quickly and are also compact.
The community that works on WebAssembly also largely works in Rust, and so you can see that there is a lot of good tooling for Rust + WebAssembly.

## Combine with...

Rust can work in almost any context, but it is especially useful in server-side or embedded applications.
If you want to create a web application, and the server writes in Rust, you'll still need front-end technology
A few suitable options (that we also work with a lot) are:

<TechWrapperSmall>
  <TechPill technology="react" />
  <TechPill technology="nextjs" />
</TechWrapperSmall>


What is Rust, and when should you use it?

Developing Software with Rust


## Svelte

[Svelte](https://svelte.dev) is a modern framework for developing websites and web applications.
You can think of it as a kind of React or Angular, but with some innovations that make it faster and nicer to work with.
We have written mostly React applications in the past few years, but we got really excited about Svelte after trying it out
We find that developing in Svelte is even faster than in React.
And we're not the only ones who are positive about Svelte, as it was the [most loved framework in recent StackOverlfow surveys](https://insights.stackoverflow.com/survey/2021#section-most-loved-dreaded-and-wanted-web-frameworks).

## SvelteKit

[SvelteKit](https://kit.svelte.dev/) offers additional features on top of Svelte, such as routing, static site generation (SSG) and server-side rendering (SSR).
If Svelte is a kind of React, then SvelteKit is a kind of NextJS.
It combines the flexibility of modern Web applications with the speed of static Web sites.

## Why SvelteKit

- **Very fast**. Both on loading, and every subsequent click: with Svelte(Kit) you get an extremely fast website.
- **Choose your own back-end**. You can connect SvelteKit to different data sources. Choose your own (Headless, open source) CMS, such as Strapi or [Atomic-Server](), or use an existing [RESTFul API](/en/blog/api-design).
- **Easily deploy to the edge**. Cloudflare, Netflify and Vercel support Sveltekit. So deploy to all corners of the world very easily.
- **Fast development**. Because Svelte(Kit) has a fine workflow, development goes nice and fast.

## Do you want a Svelte or SvelteKit application?

Get [in touch](/contact)!


What is Svelte, and when is it wise to use?

Svelte / SvelteKit website development


Typescript is a programming language that adds several features to the popular Javascript.
The most important of these is _type-safety_, which means that as a developer you can define the data type of functions and variables.
This allows many errors in code to be seen much earlier, so your applications have fewer bugs.

## Why Typescript instead of Javascript

When we can choose between the two, we practically always go for Typescript.
For example, this website was also written in Typescript (with [React](/enl/tech/react) and [NextJS](/enl/tech/nextjs))

- **Less bugs**. Because you encounter many errors (type-related bugs) much earlier, you have fewer bugs in production.
- **Faster development**. With Typescript, your code editor often gives much better _autocompletions_. This makes development faster.
- **Easy to learn**. If you can do javascript, you can already do most of Typescript.
- **Front-end and back-end**. You can use Typescript in the browser, because it compiles to Javacsript, but you can also create server side (Node or Deno) apps with it.

## Convert existing Javascript project to Typescript

Strictly speaking, it is a _superset_ of Javascript, which means that all Javascript is also valid Typescript.
This means that it is possible to take an existing Javascript project, and convert it to Typescript piece by piece.
You can step by step turn up the _strictness_, and thus slowly but surely improve your code quality.

## Looking for a Typescript development team?

Ontola has a lot of experience with Typescript, both in the front-end and the back-end.
Get [contact](/en/contact) to discuss your needs!
