Blog

Aeternity Smart Contract Deployment

The Forgae framework offers developments tools to easily test and deploy Aeternity smart contracts, and start a local environment on the developer’s workstation.

Blog Post

Aeternity Smart Contract Development

Aeternity is a blockchain implementation which offers the functional language Sophia for smart contract development and a number of native components like oracles, names for addresses and state channels. The Sophia language is a strongly typed language which helps to focus on business logic during the implementation of a smart contract.

Blog Post

Remote Mob Programming

Blog Post

Ethereum Contracts with Truffle Framework

There are many ways of development for new Smart contracts for Ethereum. Truffle Suite is one of them. It gives the developer the power to focus more on business logic than on operations.

Blog Post

Functional Service in Scala

Functional programming helps programmers to reason about their codebase using referential transparency and side-effect control principles. Let’s push the limit and make pure-functional REST service using IO Monad from Cats-Effect project. First, we will do that using Akka-HTTP library and standard Scala Future as effect type. Afterwards, we will switch to abstract effect F to have a choice, when it comes to run our embedded program.

Blog Post

Cooking with Onions: Inward-Pointing Arrows

Blog Post

Report Generator in Rust

In this blog post, we are going to build a backend application in Rust for converting HTML report into PDF format. Rust is a system programming language which focuses on performance, stability and memory safety. There are thousands of Rust libraries built by its community and we are going to build our application using some of these libraries.

Blog Post

Domain Events vs. Event Sourcing

Why domain events and event sourcing should not be mixed up.

Blog Post

Handling German Text with torchtext

Some nasty details on dealing with non-English text

Blog Post

Declarative Data Transformations

This describes a declarative approach to validating and transforming inconsistently structured data.

Blog Post

Testing is storytelling

Tests do not only exist to verify the absence of known bugs. They’re also documenting the expected behaviour of a system. Moreover, they’re showing developers how to use code.

Blog Post

Continuous Integration Contradicts Features Branches!

…but both approaches might work.

Blog Post

Do We Worship Complexity?

Complexity is the most important challenge in software development. So it is important to always strive to eliminate complexity. But sometimes we worship complexity - and that can make complexity problems unsolvable.

Blog Post

Building a Load Test with Tsung for a Login and Post Session with dynamic url-encoded variables

If you want to test your website, app or API endpoint by simulating how it will perform when hundreds or more users visit it, you are probably writing a load test. This blogpost covers a step-by-step instruction on how to build a load test for a Ruby on Rails app with a login and post session and dynamic variables with Tsung, a distributed load testing tool.

Blog Post

The Problem With Agility

Why We Are Still Stuck in Agile Transformations

Blog Post

No-Principles Software Architecture

The traditional principles of software architecture often lead to problems. Understanding these challenges is the first step towards eliminating them or even avoiding them right from the start.

Blog Post

Code Redundancy or Reuse?

Reuse used to be the holy grail of software development. If developers reuse code, they don’t have to write it again. This should increase productivity significantly. In the meantime, however, some things have changed - and even redundant code has advantages. So avoiding redundancy is also just another trade-off.

Blog Post

Server-sent events in .NET with Akka

Blog Post

Blockchain Mining: Embarrassingly Parallel?

In this blog post, we are going to look at three different approaches at mining new blocks in a blockchain using Rust, all of them using multiple threads, and we’re going to compare their runtime performances with each other and with that of the two single-threaded solutions from the previous post.

Blog Post

Blockchain Mining with Rust

Recently, at one of our yearly hands-on events, we took on the challenge of implementing our own blockchain. One of the core challenges of this is the mining of new blocks. In this blog post, I want to show two different approaches we tried out for this task, using the Rust programming language.

Blog Post

Understanding decomposed

Blog Post

Technical Debt Just Happens

“Technical debt” is a great metaphor to reason about the quality of a software project. But a closer look also reveals some problems and shows approaches how to deal with software quality even better.

Blog Post

Microservices? Or Rather Monoliths?

Microservices are a hype. Now, critics suggest to return to monoliths. But does that really help?

Blog Post

A Playground for Testing OpenID Connect

Solving problems we wish we didn’t have

Blog Post

Native Clojure with GraalVM

The newly-released GraalVM changes the status quo in the realm of JVM-based programming languages. In this instalment we’ll explore its impact on Clojure. We’ll start small, but by the end we’ll compile an entire Ring web application into a self-contained native binary.