Posted on

How To Maintain Quality When Transitioning From Monolith to Microservices

Piece by piece, legacy monolith applications are being broken down and replaced by microservices. Organizations large and small are making the transition, but that doesn’t mean the transition is easy. Until recently, the challenge of transitioning well has held up many organizations, but there are some options to make this easier. In this post, we’ll look at some of the critical metrics to monitor when making the transition, along with helpful tools to get you from monolith to microservices.

The Why and the How

Organizations make the switch to microservices for several reasons. When an application is broken into small pieces, those pieces are easier to test and quicker to deploy. With this modularization also comes more clearly scoped responsibilities for developers and teams.

Posted on

Integrating Commerce and Marketing Systems Using Expressway

Expressway comes with a set of extensions to be added on the System Applications and Products (SAP) Commerce side to enable this point-to-point Integration between Commerce and Marketing systems. Expressway gets deployed with SAP Commerce application. People skilled in SAP Commerce can easily work on Expressway based Integration.

It is important to note that Expressway is not a standard Integration solution and is not officially supported by SAP. However, it can be a useful option in certain situations when there are constraints around time and cost.

Posted on

Fluent-API: Creating Easier, More Intuitive Code With a Fluent API

We know that, in a software project, nothing replaces good documentation. However, it is also necessary to pay attention to how intuitive the written code is. After all, the simpler and more natural the code is, the better its experience for users.

In the simple "programming rule", in which we will forget everything we have to remember, an API that "forces" you to remember is crucial proof of failure.

Posted on

7 Examples of Sneaky Tech Debt and How to Spot Them

At Stepsize, helping high-growth software companies measure and manage technical debt is our business. And this means we get to spend our days with some of the best engineering minds out there.

We've listened to their stories, and analysed hundreds of thousands of lines of their code and contextual data, to identify the signals of technical debt in all the noise. Following on from our broader definition of tech debt, in this article we'll share some examples of technical debt that we've spotted in the wild, to help you identify it in your own codebase — before it catches you off-guard.

Posted on

SOLID code, the Silver Bullet

SOLID is one of those words we developers throw around us, implying some deeper meaning, hopefully helping us to create better software systems. It should be second hand nature to all (OO) developers, but unfortunately is often misunderstood, or used to defend a decision, based upon flawed logic. Hence, in this article, I will try to "dumb it down" and use analogies for each of its 5 items, in an attempt at making it more easily understood, to avoid confusion.

Single Responsibility Principle

The "S" I'm solid implies that each class should only do one thing. It often helps to break down your flow into verbs to make sure you follow this principle. For instance, imagine you have a task scheduler, that should implement the ability to create tasks for execution at some point into the future. Maybe you want it to have the ability to persist tasks, in case the process is recycled, without dropping tasks. Imagine Hangfire here as an example. Well, ask yourself how many verbs you have in the above feature requirement, and then try to group them into related actions. I could find the following.

Posted on

Magic Workflow

Few people are at this point in time willing to bet their money on .Net Framework, simply because .Net Core is obviously the future. This creates problems for us developers, since a lot of the tools we have grown used to, simply doesn't exist in .Net Core. One example of such a tool is Microsoft Workflow Foundation. According to what I've read, Microsoft is not willing to port Workflow Foundation to .Net Core either, so as you cross the bridge into ".Net Core land", you'll have to leave workflows behind.

What is Microsoft Workflow Foundation?

To find out how to replace Workflow Foundation, we must first ask ourselves what its primary feature is. As in, what makes MWF valuable for developers, and why have so many chosen to use it over the years?

Posted on

Anemic Domain Model in Typical Spring Projects (Part 1)

When I just started my career as a Java developer, I knew only a few basic design patterns. I tried to implement them everywhere, even when I shouldn't have, and I thought that more experienced people use them on a daily basis. With time, I have changed several different teams and companies, but I have never seen real usage of “real” patterns. Of course, I am not talking about Builder, Singleton, or Abstract Fabric, but rather about more complicated and less common ones like Bridge, Observer, etc. Familiar situation, isn’t it?

Basics

For a full understanding of the problem, we should begin with the basics. 

Posted on

Internal Architecture of the SQLite Database

In a computer program, the database is the heart of handling data and provides a fast and efficient way of storing and retrieving data. Learning the database's internal architecture and looking into a fully featured database at the code level is not so easy because of the database's complexity. But SQLite is a nice little compact database that is used in millions of devices and operating systems. An interesting fact about the SQLite database is that its code base is highly readable. Most of the code is well commented, and the overall software architecture is highly layered. My previous article describes the backend implementation of the SQLite Database, while this article looks into how the SQLite compiler and the VM work at a high level.

As I mentioned earlier, SQLite has a highly layered architecture that can be separated into seven layers. We will go through each of the layers one-by-one.