#### **Introduction**
#
Choosing the right programming language is crucial when it comes to developing custom software solutions. In this article we will explore the suitability and limitations of two popular programming languages: Java and Golang (Go).   
#
Both languages have gained significant traction in the software development industry, but they have distinct characteristics that make them suitable for different scenarios. 
#
#### **Java**
#
Although Java has been a dominant player in the software development landscape for many years, it has limitations.   
#
Memory consumption is one such area where Java tends to be more resource-intensive compared to other languages. Additionally, Java's startup time can be slower, making it less suitable for certain latency-sensitive applications.   
#
#### **Golang**
#
Golang, also known as Go, has gained rapid popularity in recent years due to its simplicity, efficiency, and built-in support for concurrent programming, but has some drawbacks.   
#
Previously, the lack of generics was a prominent concern. However, with the introduction of Go 1.18, generics are now supported, which addresses a long-standing limitation of the language.   
#
Another consideration is that Golang's ecosystem might still be immature for certain domains, like ML/AI, IoT, Game development, and Desktop Applications. While there are frameworks for Go for each of the above-listed domains, Go strength is in other domains.  
#
#### **Conclusion**
#
Choosing the right programming language for custom software solutions is crucial. Java and Golang are both powerful languages with their own strengths and limitations.   
#
When making a decision, it is essential to consider project requirements, team expertise, and the specific needs of the software solution. Java and Golang each have their place in the software development landscape, and understanding their suitability and limitations is key to building successful custom software solutions. 
#

Blog cover java vs go.png

Choosing the right programming language is crucial when it comes to developing custom software solutions. 

Java vs. Golang: Limitations in Custom Software Solutions  

I had long been aware of the [effort of cznic](https://gitlab.com/cznic/sqlite) to automatically translate the C source of SQLite to Go while avoiding the complexity CGo would introduce. SQLite was always meant to be a database you embed into your application, and I was curious what tradeoffs that meant, if any, and just generally how it differed from the usual suspects (PostgreSQL, etc.).
To explore these trade-offs and differences, I decided to dive deeper into the usage of this library.

SQLite is a single-writer multiple-reader database. Using just a single instance of database/sql.DB will not work well with this, because it will make it hard to avoid receiving SQLITE_BUSY errors when multiple writers try to run at the same time (because sql.DB is a connection pool). So we will need to separate readers from writers by making two instances of database/sql.DB and limiting the writer to a single [MaxOpenConn](https://pkg.go.dev/database/sql#DB.SetMaxOpenConns) and the reader to as many as you require.

So far, SQLite is behaving remarkably like other databases apart from the single-writer gotcha; we still have connections and per-connection settings. The usual way to pass these settings is usually in the DSN you pass to [sql.Open](https://pkg.go.dev/database/sql#Open) and this is [definitely possible](https://pkg.go.dev/modernc.org/sqlite#Driver.Open), but I find that it would be more straightforward if I could just run my custom SQL when a new connection is made[1]. We can do that with [sqlite.RegisterConnectionHook](https://pkg.go.dev/modernc.org/sqlite#RegisterConnectionHook).

Now the question is what settings to use, because [there are quite a few of them](https://www.sqlite.org/pragma.html). These are the ones I am using personally:

- `PRAGMA journal_mode = WAL;`
  Use write-ahead-logging. Better concurrency, but with an edge-case: with heavy writers, the wal can grow idefinitely ([see for more](https://www.sqlite.org/cgi/src/doc/wal2/doc/wal2.md)). I don't expect this will happen in my use-case. For a good description on the various jornal modes, [see this blogpost](https://www.mycelial.com/learn/sqlite-journal-mode-options).
- `PRAGMA synchronous = NORMAL;`
  Since with the WAL journal mode, this is safe, there is no reason to use FULL.
- `PRAGMA temp_store = MEMORY;`
  Let's store temporary indices, tables, etc. in memory, my use-case is not very resource-constrained to require using the filesystem (also, [this is a fun read](https://www.sqlite.org/fasterthanfs.html) if we are talking about additional syscalls to the kernel)
- `PRAGMA mmap_size = 30000000000; -- 30GB`
  Just making sure, access to my database is always done with memory-mapped I/O.
- `PRAGMA busy_timeout = 5000;`
  How much time to wait in milliseconds after which SQLITE_BUSY is returned when waiting for the db to unlock.
- `PRAGMA automatic_index = true;`
  Make sure [automatic indexing](https://www.sqlite.org/optoverview.html#autoindex) is enabled, it can only help, and is a great way to get warnings about indexes that should be created.
- `PRAGMA foreign_keys = ON;`
  Make sure foreign key enforcement is enabled.
- `PRAGMA analysis_limit = 1000;`
  Make sure [ANALYZE](https://www.sqlite.org/lang_analyze.html#approx) returns quickly in case the DB gets large.
- `PRAGMA trusted_schema = OFF;`
  No idea what security audited functions are, but this setting makes sure only those can be run. The manual page tells me to turn it off anyway, so let's do that.

Not all of these settings are per-connection settings, but it doesn't hurt to always run all of these on every connection, and having a single "Init SQL" makes things simpler.

Let's deal with explicit transactions next. The default transaction mode is DEFERRED, meaning that it depends on the next statement what type of transaction is started (if a SELECT statement comes first, a read transaction is started, with the possibility of upgrading it to a write transaction depending on the statements that follow). With our setup, there should never be multiple writers concurrently, so making all transactions write transactions from the get-go (with BEGIN IMMEDIATE) can only help us show if this invariant is violated.

Putting this all together, this is the code we arrive at:

```go
package main

import (
	"bytes"
	"context"
	"crypto/sha1"
	"database/sql"
	"database/sql/driver"
	"encoding/hex"
	"fmt"
	"time"

	"modernc.org/sqlite"
)

type DB struct {
	dbPath    string
	Read  *sql.DB
	Write *sql.DB
}

const initSQL = `
	PRAGMA journal_mode = WAL;
	PRAGMA synchronous = NORMAL;
	PRAGMA temp_store = MEMORY;
	PRAGMA mmap_size = 30000000000; -- 30GB
	PRAGMA busy_timeout = 5000;
	PRAGMA automatic_index = true;
	PRAGMA foreign_keys = ON;
	PRAGMA analysis_limit = 1000;
	PRAGMA trusted_schema = OFF;
`

func New(ctx context.Context, dbPath string) (db *DB, err error) {
	db = &DB{
		dbPath: dbPath,
	}

	// make sure every opened connection has the settings we expect
	sqlite.RegisterConnectionHook(func(conn sqlite.ExecQuerierContext, _ string) error {
		_, err = conn.ExecContext(ctx, initSQL, nil)

		return err
	})

	write, err := sql.Open("sqlite", "file:"+db.dbPath)
	if err != nil {
		return
	}
	// only a single writer ever, no concurrency
	write.SetMaxOpenConns(1)
	write.SetConnMaxIdleTime(time.Minute)
	if err != nil {
		return
	}

	read, err := sql.Open("sqlite", "file:"+db.dbPath)
	if err != nil {
		return
	}
	// readers can be concurrent
	read.SetMaxOpenConns(100)
	read.SetConnMaxIdleTime(time.Minute)

	db.Read = read
	db.Write = write

	return
}

func (db *DB) InTransaction(ctx context.Context, tx func(context.Context, *sql.Conn) error) (err error) {
	// cancel anything that takes longer than 5 seconds
	var cancel func()
	ctx, cancel = context.WithTimeout(ctx, time.Duration(5*time.Second))
	defer cancel()

	// separate conn thats just for us
	// so that the transactions queries are executed together
	conn, err := db.Write.Conn(ctx)
	if err != nil {
		return
	}
	defer conn.Close()

	_, err = conn.ExecContext(ctx, "BEGIN IMMEDIATE TRANSACTION")
	if err != nil {
		return
	}

	defer func() {
		if r := recover(); r != nil || err != nil {
			if _, err = conn.ExecContext(ctx, "ROLLBACK"); err != nil {
				return
			}
		}
	}()

	err = tx(ctx, conn)
	if err != nil {
		return
	}

	_, err = conn.ExecContext(ctx, "COMMIT")
	return
}
```

Just as a small added bonus, it's also very easy to register our own go functions that we can then call from SQL. In this example, we define the sha1 function, receiving and returning a single argument, and always returning the same output for the same input (thus the deterministic). For more information, [see the docs](https://www.sqlite.org/appfunc.html)

```go
func registerFuncs() {
	// lets add our own sha1 hash function usable from SQL
	sqlite.MustRegisterDeterministicScalarFunction(
		"sha1",
		1,
		func(ctx *sqlite.FunctionContext, args []driver.Value) (driver.Value, error) {
			var arg *bytes.Buffer
			switch argTyped := args[0].(type) {
			case string:
				arg = bytes.NewBuffer([]byte(argTyped))
			case []byte:
				arg = bytes.NewBuffer(argTyped)
			default:
				return nil, fmt.Errorf("expected argument to be a string, got: %T", argTyped)
			}

			h := sha1.Sum(arg.Bytes())
			return hex.EncodeToString(h), nil
		},
	)
}
```

In conclusion, this solution works perfectly well for most of the usage scenarios out there where immense scaling is neither expected nor needed. There are faster ways to use SQLite with Go (see the [excellent cvilsmeier benchmarks](https://github.com/cvilsmeier/go-sqlite-bench)), but its still plenty-fast enough, and avoiding CGo makes it very convenient also.

[1]: This is another thing that database/sql.DB being a connection pool makes harder.

thumb.webp

Explore how to use modernc.org/sqlite with Go to handle SQLite's single-writer, multiple-reader model, optimize PRAGMA settings, and avoid CGo.

modernc.org/sqlite with Go

## The problem

Request comes in, is processed correctly including the response generation, but the response never arrives to the client.

Luckily we have extensive logging, so we could at least rule out any problem in the application layer.
This did not happen often and we could never reproduce it manually, so we added even more logging to all layers of the stack, which helped pin-point the issue. It required looking deeper into what is happening exactly at the various stages of the applications lifecycle.

For some more context we have the following systems architecture: an OpenShift k8s cluster, load-balancing to nginx instances that serve the application.

## The investigation

On new deployments with the rolling strategy, new containers are brought up and do not receive traffic until they report as ready (according to the readinessProbe option). While this is going on, the old containers are still running and handling requests. The switch-over happens by OpenShift redirecting traffic to the new containers and at the same time signaling the old containers to terminate by sending a [SIGTERM](https://en.wikipedia.org/w/index.php?title=Signal_(IPC)#SIGTERM) to them (or whatever the container specified in its Dockerfile in the `STOPSIGNAL` option).
But of course when nginx receives a `SIGTERM`, it does not finish processing outstanding request, it exits immediately. This explains why we sometimes lost a perfecly good response to a request: nginx was simply killed before it could return it.
Luckily nginx knows how to gracefully exit, it simply requires another signal entirely: `SIGQUIT`.
But this is not the default in the [bitnami/nginx](https://hub.docker.com/r/bitnami/nginx/dockerfile) container as opposed to the [official nginx](https://github.com/nginxinc/docker-nginx/blob/master/mainline/debian/Dockerfile#L118) container.

## The solution

While we wait for bitnami/nginx to fix [the issue](https://github.com/bitnami/containers/issues/65691) upstream, we can add the necessary configuration to our own Dockerfile:

```dockerfile
FROM bitnami/nginx:latest

STOPSIGNAL SIGQUIT

# etc...
```

In case the used OpenShift environment is too old and does not support `STOPSIGNAL`, we can use a `preStop` lifecycle hook in our helm chart, this should not be necessary:

```yaml
kind: "DeploymentConfig"
apiVersion: "apps.openshift.io/v1"
metadata:
  name: "nginx"
spec:
  selector:
    name: nginx
  template:
    metadata:
      labels:
        name: "nginx"
    spec:
      containers:
        - name: "nginx"
          lifecycle:
            preStop:
              exec:
                # send PID 1 (nginx) a SIGQUIT so that it gracefully shuts down
                # wait to delay the SIGTERM by kubernetes
                # if nginx shuts down inside the delay, the pod is killed anyway
                command: ["/bin/sh", "-c", "kill -s QUIT 1; sleep 2m"]
          [...]
```

Before debugging the issue, searching for the symptoms did not produce any usable results, and this is the reason for this blog post existing.

k8s-nginx.jpeg

By understanding the nuances of signal handling in containerized environments, we can prevent unexpected disruptions and maintain robust application performance.

Graceful termination of Nginx in K8s

#### **Introduction** 
#
React has become a dominant force in the world of web development, enabling developers to create highly interactive and dynamic user interfaces. However, with the growing demand for mobile applications, React Native has evolved into a powerful framework for native mobile application development. In this article, we examine React Native and React Web and discuss when to use them. 
#
#### **Understanding React Native**
#
React Native is a framework that helps developers to create native mobile applications using JavaScript. Leveraging React's component-based architecture, React Native enables the creation of performant and platform-independent mobile applications. Key features of React Native include: 
#
**Native mobile app development:** React Native provides access to native UI components, allowing apps to feel and behave like native apps on both iOS and Android platforms. 
#
**Code reusability:** React Native allows you to share large portions of your code base between iOS and Android apps, reducing development time and effort. 
#
**Performance and Speed:** React Native uses a bridge to communicate between JavaScript and native components, allowing for faster rendering and smoother animations compared to hybrid frameworks. 
#
**Access to device features:** React Native allows developers to access device-specific features such as camera, GPS, and push notifications for a seamless user experience. 
#
However, React Native does come with some limitations and considerations. Building platform-specific components may be required to achieve a truly native look and feel. 
#
Debugging can be more challenging, as issues may arise from the JavaScript code, bridge communication, or native modules. 
#
Additionally, developers new to React Native may face a learning curve to understand the framework's nuances. 
#
#### **Understanding React Web** 
#
React Web, also known as React.js or React for the web, is a JavaScript library for building user interfaces on the web. It follows a similar component-based architecture to React Native but focuses on web development. Key features of React Web include: 
#
**Cross-platform web development:** React Web allows developers to build interactive web applications that work across different browsers and devices. 
#
**Component-based architecture:** React Web's component-based approach promotes reusability, modularity, and maintainability of code, making it easier to build complex UIs. 
#
**Virtual DOM for efficient rendering:** React Web utilizes a virtual DOM, which updates only the necessary parts of the UI, resulting in improved performance and faster rendering. 
#
**Huge community support:** React Web has a large and active community, providing extensive documentation, libraries, and resources to support developers in their web development projects. 
#
Despite its advantages, React Web does have some limitations and considerations. 
#
It lacks the native capabilities of React Native, making it unsuitable for building mobile applications that require access to device-specific features. 

Performance concerns may arise when dealing with large-scale applications or handling computationally intensive tasks. 

Compatibility with older browsers may also be a consideration depending on the target audience. 
#
#### **When to Use React Native** 
#
**Mobile app development for iOS and Android**
#
React Native excels when the primary objective is to create mobile applications that provide a native-like experience across multiple platforms. 
#
**When native features and performance are paramount** 
#
If your application heavily relies on device-specific functionalities or requires exceptional performance, React Native's ability to access native components and optimize rendering makes it the ideal choice. 
#
**Leveraging existing React Native expertise** 
#
If your team already possesses experience and proficiency in React Native, it is advantageous to capitalize on that knowledge for new mobile app projects. 
#
#### **When to Use React Web** 
#
**Cross-platform web development** 
#
React Web is the go-to choice when the focus is on building web applications that work seamlessly across different browsers and devices. 
#
**Rapid prototyping and development** 
#
React Web's component-based architecture and large community support make it ideal for quickly prototyping and iterating on web applications. 
#
**Compatibility with older browsers and a wider web audience** 
#
If your target audience includes users on older browsers or you need to ensure wider compatibility, React Web's widespread adoption and community support can help navigate these challenges. 
#
#### **Case Studies and Examples** 
#
To showcase the capabilities of React Native, we can highlight successful projects such as Facebook, Instagram, and Airbnb, which have built their mobile apps using React Native. 
#
For React Web, we can mention popular websites like Netflix, Airbnb (web version), and Slack, which have leveraged React Web to deliver rich and interactive user experiences on the web. 
#
#### **Conclusion** 
#
React Native and React Web serve different purposes in the realm of software development. React Native is the ideal choice for building native mobile applications with access to device features and optimal performance, while React Web excels in cross-platform web development and rapid prototyping.  
#
Understanding the requirements and priorities of your project is key to selecting the right framework. By considering factors such as platform, native capabilities, performance needs, and development expertise, you can make an informed decision on whether to choose React Native or React Web for your next project. 
#

Blog cover React vs React web.png

React has become a dominant force in the world of web development, enabling developers to create highly interactive and dynamic user interfaces.

React Native vs. React Web: What's the Difference and When to Use Them 

#### **Introduction** 
#
Choosing the appropriate **front-end framework** for your software development project can be a daunting task. With so many options available, it usually boils down to two popular options: React and Angular.  
#
In this blog post, we'll dive into the features, strengths, and weaknesses of both frameworks to help you make an informed decision. 
#
#### **I. React**
#
- React, developed by Facebook, is a JavaScript library for building user interfaces. 
#
- It follows a component-based architecture, where the user interface is broken down into reusable components. 
#
- React utilizes a virtual DOM (Document Object Model), which allows for efficient rendering and updates, resulting in high-performance applications. 
#
- It offers excellent community support and a vast ecosystem of third-party libraries and packages. 
#
- React's lightweight nature makes it an ideal choice for single-page applications (SPAs) and mobile app development. 
#
- It embraces a declarative programming style, making it easier to understand and maintain code. 
#
#### **Strengths of React** 
#
**Flexibility and Scalability** 
#
React's component-based architecture encourages code reusability and makes it easier to manage complex applications. React empowers developers to create compact, reusable components that can be seamlessly integrated to construct expansive applications. 
#
**Virtual DOM** 
#
Virtual DOM effectively updates only necessary components, improving performance and responsiveness. It provides a seamless user experience, especially when dealing with large amounts of data. 
#
**Large and Active Community** 
#
React has a thriving community constantly contributing to its growth and improvement. Developers can benefit from extensive documentation, tutorials, and support provided by other community members. 
#
#### **Weaknesses of React** 
#
**Learning Curve** 
#
React has a steeper learning curve compared to some other frameworks. Understanding concepts like JSX syntax, component lifecycle, and state management may require additional time and effort. 
#
#### **II. Angular** 
#
- Angular, developed by Google, is a TypeScript-based open-source front-end framework. 
#
- It follows a modular architecture and employs a component-based structure similar to React. 
#
- Angular uses two-way data binding, allowing changes in the UI to be reflected in the underlying data model and vice versa. 
#
- It provides a robust set of tools and features, including dependency injection, form handling, and built-in testing capabilities. 
#
- Angular's focus on convention and structure can be advantageous for larger projects with multiple developers. 
#
#### **Strengths of Angular** 
#
**Complete Framework** 
#
Angular offers an all-inclusive framework that covers various aspects of application development, including routing, form handling, and state management. 
#
It provides a consistent and standardized approach to building applications, making it suitable for enterprise-level projects. 
#
**TypeScript** 
#
Angular leverages TypeScript, a statically typed superset of JavaScript, which adds type-checking and better tooling support. 
#
TypeScript helps catch errors during development, improving code quality and maintainability. 
#
**Robustness** 
#
Angular has a robust set of features and tools built in, so it can reduce the reliance on third-party libraries. 
#
It ensures a consistent development experience and can handle complex projects with ease. 
#
#### **Weaknesses of Angular** 
#
**Complexity**
#
Angular's comprehensive nature can make it overwhelming for small or simple projects. Its steep learning curve and extensive documentation may be intimidating for beginners. 
#
#### **Conclusion** 
#
React and Angular are both powerful front-end frameworks with strengths and weaknesses. Choosing between them ultimately depends on the specific requirements of your project, your team's skill set, and your long-term goals.  
#
If you prefer a lightweight and flexible library with a vibrant community, React might be the right choice. On the other hand, if you need a complete framework that provides robustness and structure, Angular may be the better fit.  
#
Consider evaluating your project's needs and conducting further research to make an informed decision that aligns with your development goals.
#

Blog cover react vs angular.png

Choosing the appropriate front-end framework for your software development project can be a daunting task. 

React vs. Angular: Which Front-End Framework Is Right for You? 

#### **Introduction** 
#
Over the years, **React** has become one of the most popular JavaScript libraries for front-end web development. Its component-based architecture and efficient rendering have revolutionized the way developers create user interfaces. 
#
However, like any technology, React has its pros and cons. In this article, we'll explore the pros and cons of using React in your next web project and help you make an informed decision. 
#
#### **Benefits of using React** 
#
**Component-based architecture** 
#
React's component-based approach allows developers to create reusable UI components. This modular structure increases code reusability, improves maintainability, and improves collaboration among team members. 
#
It simplifies the development process by breaking the UI into different components, making it easier to maintain and update specific parts of the application. 
#
**Virtual DOM** 
#
React uses a virtual DOM (a lightweight copy of the real DOM) to efficiently update and render UI changes. The way Virtual DOM works is that when a change occurs, it compares the previous Virtual DOM with the new Virtual DOM and if there is a difference between the new and the old, only then will the real DOM be updated. 
#
With Virtual DOM, React minimizes unnecessary updates, which improves performance and user experience. This approach is especially beneficial for complex and data-intensive web applications. 
#
**Reusable components** 
#
The component-based nature of React encourages the creation of reusable UI components. Developers can create a library of components that can be shared across projects, saving time and effort in the long run. This reusability promotes consistency in design and user experience and makes applications easier to maintain and scale. 
#
**One-way data flow**
#
React follows a unidirectional data flow which helps maintain a predictable state of the application. It ensures that data flows in one direction, so it's easier to track changes and debug issues. By enforcing this pattern, React improves the stability and maintainability of the codebase. 
#
**Performance optimization** 
#
React's efficient rendering capabilities and virtual DOM enable powerful web applications. Virtual DOM efficiently updates only necessary parts of the UI, resulting in faster rendering and improved user experience. React also provides tools like memoization and lazy loading that developers can use to further optimize performance. 
#
#### **Disadvantages of using React**
#
**Steep learning curve** 
#
React has a relatively steep learning curve, especially for developers new to JavaScript frameworks. Unique concepts like JSX syntax and virtual DOM take some time and effort to understand. However, with many learning resources such as tutorials and documentation, developers can overcome this hurdle with dedication and practice. 
#
**Tool complexity** 
#
React's ecosystem includes various tools and libraries like Webpack and Babel to improve the development process. While these tools offer powerful features and benefits, they can add complexity, especially for beginners. Configuring and setting up these tools properly may require additional study and effort. 
#
**Poor SEO support**
#
Because React applications are often rendered client-side, search engine optimization (SEO) can be challenging. Traditional web crawlers can have difficulty indexing and understanding React-based content. However, SEO can be effectively addressed through server-side rendering (SSR) techniques or using frameworks like Next.js. 
#
**Frequent updates and breaking changes** 
#
React is an actively maintained library, meaning it regularly releases updates and introduces breaking changes. While these updates bring new features and improvements, they can require developers to invest time and effort in keeping their code bases up to date. Proper planning and staying abreast of the latest updates are key to mitigating potential problems. 
#
**Limited Mobile App Development** 
#
While React can be used for developing mobile applications through frameworks like React Native, it has some limitations compared to native development. React Native's performance and access to native APIs might not match the capabilities of native development in all scenarios. For complex or performance-critical mobile applications, native development might be a better choice. 
#
#### **Conclusion** 
#
**React** has gained immense popularity in the frontend development community due to its powerful features and efficient rendering capabilities. It offers benefits such as a component-based architecture, virtual DOM, and performance optimization. 
#
However, it also presents challenges like a learning curve, tooling complexity, and limited mobile app development capabilities. 
#
By weighing the pros and cons, considering project requirements, and leveraging the vast React ecosystem, developers can make an informed decision on whether to choose React for their next web project. 
#

Blog cover React pros and cons.png

Over the years, React has become one of the most popular JavaScript libraries for front-end web development.

The Pros and Cons of Using React for Your Next Web Project 

#### **Introduction** 
#
In **cloud-native applications,** scalability, flexibility, and efficiency are all paramount, so choosing the appropriate programming language is crucial. #
While several options are available, **Go** (or Golang) has emerged as a popular choice among software developers due to its features and capabilities.  
#
In this blog post, we will explore why Go is a perfect fit for cloud-native applications deployed in Kubernetes, and we will focus on the advantages that microservices written in Go offer. Let's dive in. 
#
#### **Scalability and Concurrency** 
#
Go's **built-in support for concurrency and scalability** is one of the key reasons it excels in the cloud-native space. 
#
Go's lightweight goroutines and channels make writing highly concurrent code effortless, allowing applications to handle thousands of concurrent requests. This inherent concurrency model enables developers to use available system resources, improving application performance and responsiveness. 
#
#### **Kubernetes Deployment**
#
**Kubernetes,** a robust and scalable container orchestration platform, has emerged as the de facto standard for deploying and managing cloud-native applications.  
#
Go's static binary compilation allows applications to be easily packaged and deployed as standalone executables, eliminating the need for runtime dependencies. This property makes it easy to create lightweight and portable Docker containers that can be seamlessly orchestrated by Kubernetes.  
#
Additionally, Go's **efficient memory management** and small binary footprint help reduce resource consumption, resulting in optimal use of the underlying infrastructure. 
#
#### **Efficiency and Performance** 
#
**Microservice architectures** have gained enormous popularity in the cloud-native space due to their ability to decompose complex applications into smaller, loosely coupled components. When implemented in Go, microservices can leverage the power of the language to deliver exceptional efficiency and speed. 
#
Go's static typing and compilation process ensures that applications have minimal runtime overhead, resulting in faster startup times and a reduced memory footprint. Its garbage collection mechanism is designed for low-latency applications, further improving performance.  
#
These factors make Go an **excellent choice** for building microservices that require fast response times and can handle heavy loads without sacrificing stability. 
#
#### **Developer Productivity and Maintainability** 
#
Go's **simplicity and minimalist design** have had an impact on developer productivity. The language has a small, clean standard library that covers most of the basic functionality, allowing developers to focus on writing clean, readable code. Go's solid type system helps detect errors at compile time, reducing the chance of errors and making maintenance easier as applications grow. 
#
Additionally, Go's rich testing framework and support for concurrent testing make it easy to write unit tests and run integration tests for microservices. The language's straightforward syntax and tool ecosystem help improve code quality and facilitate collaboration between development teams on cloud-native applications. 
#
#### **Conclusion**
#
For developing cloud-native applications, Go is an ideal choice for numerous reasons. Its support for concurrency and scalability, compatibility with Kubernetes deployments, efficiency and performance optimizations, and developer-friendly features make it a go-to language for building microservices that power modern cloud architectures. 
#
With its growing adoption and thriving community, Go continues to evolve, offering an even more compelling platform for building cloud-native applications. As the demand for scalable and efficient software solutions continues to rise, investing in Go and leveraging its advantages can provide a solid foundation for success in the cloud-native landscape. 
#
Keep in mind that picking the appropriate language is only the first step. To use the full potential of Go and build robust cloud-native applications, it's crucial to continually explore best practices, stay updated with the latest trends, and use the resources available in the Go ecosystem. 
#

Blog cover basic Go in cloud native applications.png

In cloud-native applications, scalability, flexibility, and efficiency are all paramount, so choosing the appropriate programming language is crucial. 

How Golang is Perfect for Cloud Native Applications 

#### **Introduction**
# 
Today in the fast-moving and technology-driven business environment, the choice of programming language plays a vital role in the success of an application. Golang, aka Go, has evolved into a powerful language for developing scalable and efficient software solutions. 
#
In this blog post, we will explore the use of Golang by big names like Uber and SendGrid, and its adoption in the fintech space. We will also learn about Golang's ease of learning and how it ensures a steady supply of skilled developers. 
#
#### **Golang in Prominent Companies**
#
**1.1 Uber** 
#
Ride-hailing giant Uber is known for crunching **massive amounts of real-time data** and delivering a seamless experience to millions of users around the globe. Golang plays an ultimate role in the backend infrastructure of Uber, contributing to its scalability and reliability. 
#
Golang's built-in concurrency and efficient garbage collection allow Uber to handle heavy request loads, ensuring the shortest response times and best performance. 
#
Additionally, Golang's simplicity and readability allowed Uber developers to iterate and improve their systems quickly. 
#
**1.2 SendGrid**
#
SendGrid, the leading cloud-based email delivery service, relies on Golang to provide its powerful email infrastructure. Golang's lightweight goroutines allow for easy concurrency, enabling SendGrid to efficiently **process millions of emails per day.** 
#
Additionally, Golang's powerful standard library, including extensive networking and security support, has played an important role in developing a secure and scalable email delivery system. Using Golang, SendGrid achieves high throughput and low latency, ensuring reliable email delivery for its customers. 
#
#### **Golang in Fintech**
#
The fintech industry is characterized by the need for secure, robust, and scalable systems to handle complex financial operations. Golang's unique features and capabilities make it a pioneer in the industry. 
#
#### **High Performance and Scalability**
#
Golang's statically typed nature and lightweight goroutines make it ideal for developing low-latency financial applications. Golang's efficient memory management and garbage collection allow the handling of large datasets with minimal overhead. This performance advantage has attracted many fintech companies, allowing them to handle real-time transactions, risk analysis, and other essential financial operations. 
#
#### **Safe and Reliable**
#
Golang's standard library includes strong cryptographic packages, making it a solid choice for fintech applications that handle sensitive financial data. Golang's error handling helps to deal with cases that can be easily missed in other languages. Thus, the robustness of the solutions is enhanced by its error handling. These properties help to improve the overall reliability and resilience of fintech systems. 
#
#### **Ease of learning and availability of qualified developers** 
#
One of the reasons for Golang's growing popularity is its simplicity and **ease of learning.** Designed with readability and productivity in mind, Golang has a clean and concise syntax. The language specifications and standard library documents are comprehensive and clear, making it easier for developers to understand language concepts and quickly create practical applications. 
#
Golang's ease of learning has fostered a **thriving developer community.** As Golang becomes more recognized in the industry, the number of qualified Golang developers is also growing. This ensures that companies can find and hire competent developers who can effectively implement and maintain Golang-based systems. 
#
#### **Conclusion**
#
Golang's **impact on business applications** is undeniable, as evidenced by its adoption by companies like Uber and SendGrid. Its scalability, performance, and simplicity make it an excellent choice for developing powerful and efficient software solutions. 
#
In the financial technology industry, the characteristics of Golang make it the language of choice for its high performance, security, and reliability. 
#
As more and more developers adopt Golang, its ecosystem, and community will continue to thrive, providing businesses with a steady stream of skilled professionals. With its many advantages, Golang will play an increasingly important role in shaping the future of business applications. 
#

Blog cover basic Golang in Business.png

Today in the fast-moving and technology-driven business environment, the choice of programming language plays a vital role in the success of an application. 

Golang in Business Applications: Powering Uber, SendGrid, and More 

#### **Introduction**
#
Choosing the **right programming language** is crucial for the success of any software project. When it comes to Java and Golang, developers often find themselves at a crossroads. 
#
Java, a mature and versatile language, has been a popular choice for enterprise-level projects for many years. On the other hand, Golang, also known as Go, has gained significant traction in recent years due to its simplicity and performance. 
#
In this article, we will explore the strengths and limitations of both Java and Golang, helping you make an informed decision for your next project.  
#
#### **Java**
#
Java is a widely-used programming language known for its object-oriented approach and platform independence. Its robustness and stability have made it a preferred choice for developing large-scale enterprise applications. 
#
One of the strengths of Java lies in its extensive ecosystem and community support. From frameworks to libraries, Java offers a wide range of resources that can significantly speed up development. 
#
However, one limitation of Java is its verbosity and the need for boilerplate code, which can sometimes make the development process more time-consuming.  
#
#### **Golang**
#
Golang, developed by Google, is a relatively newer programming language that focuses on simplicity and performance. 
#
It offers a clean and readable syntax, making it easier for developers to write and maintain code. Golang's speed is one of its major strengths, as it compiles directly to machine code, resulting in efficient execution. 
#
Another advantage is its built-in concurrency support, which simplifies the implementation of concurrent and parallel tasks. 
#
#### **Factors to Consider When Choosing**  
#
When deciding between Java and Golang, several factors need to be considered. First and foremost, project requirements and objectives play a crucial role. 
#
Java's extensive ecosystem and mature tooling make it suitable for complex enterprise projects, while Golang's simplicity and performance make it a good fit for smaller, high-performance applications. 
#
The experience and skill set of the development team also need to be taken into account, as familiarity with a particular language can significantly impact productivity. Performance and scalability requirements, community support, and long-term maintenance considerations should also be evaluated to ensure the chosen language aligns with the project's needs.  
#
#### **Decision-making Process** 
#
To make an informed decision, it is essential to evaluate project requirements against the features of both languages. 
#
1. Consider the strengths and limitations of each language and how they align with the project's goals. 
2. Consultation with the development team and stakeholders can provide valuable insights and perspectives. 
3. Weighing the trade-offs between Java and Golang, such as development speed versus execution speed or community support versus simplicity, will help in reaching a well-considered decision that sets the project up for success.  
#
#### **Case Studies**
#
Examining real-world examples can provide further guidance on which language is better suited for specific types of projects. 
#
Java has been widely used for building enterprise systems, web applications, and Android apps. On the other hand, Golang has found success in projects that require high performance, such as networking applications, microservices, and backend systems. 
#
Analyzing these case studies can help draw parallels to your own project requirements and provide insights into the suitability of each language.  
#
#### **Real-world examples of successful projects in each language**
#
#### **Java**
#
**a) Apache Kafka** 
#
Apache Kafka, a distributed streaming platform, it is widely used for building real-time data pipelines and streaming applications. Kafka's scalability, fault tolerance, and reliability are attributed to Java's robustness and ecosystem support.  
#
**b) Minecraft** 
#
The popular sandbox game Minecraft, developed by Mojang Studios, is primarily written in Java. Java's cross-platform compatibility allows Minecraft to be played on multiple operating systems seamlessly. The game's extensive modding community thrives on Java's versatility and support.  
#
#### **Golang**
#
**a) Kubernetes** 
#
The container orchestration platform Kubernetes, developed by Google, is built using Golang. Golang's performance, efficiency, and concurrency features make it an ideal choice for managing and scaling containers in a distributed environment.  
#
**b) Dropbox** 
#
The file hosting service Dropbox has incorporated Golang into its infrastructure for improved performance and reliability. Golang's speed and simplicity enable efficient handling of file uploads, downloads, and synchronization across multiple devices.  
#
#### **Conclusion** 
#
Choosing between Java and Golang depends on various factors such as project requirements, team expertise, performance needs, and long-term maintenance considerations. Java's strengths lie in its object-oriented approach, platform independence, and extensive ecosystem. 

 

Blog cover Java vs Golang v2.png

Choosing the right programming language is crucial for the success of any software project. When it comes to Java and Golang, developers often find themselves at a crossroads. 

Java vs. Golang: Choosing the Right Language for Your Next Project  

#### **Introduction**
#
Java has long been a dominant player in the programming world, known for its versatility, robustness, and extensive community support. In the realm of enterprise architecture, Java continues to hold its ground, proving its relevance and value in building large-scale, complex systems. 
#
This article explores the reasons why Java remains a popular choice for enterprise architecture, its role in modern enterprise systems, the frameworks and tools available, successful case studies, and its future prospects in this evolving landscape. 
#
#### **Java's Advantages in Enterprise Architecture**
#
**Platform Independence**
#
One of Java's greatest strengths is its "write once, run anywhere" philosophy, allowing developers to create code that can be executed on different platforms without the need for extensive modifications. This platform independence makes Java an ideal choice for enterprise systems that need to run on diverse operating systems and environments.
#
**Robustness and Reliability**
#
Java's strict compile-time error checking and runtime exception handling contribute to its robustness and reliability. These features help detect errors early in the development process and ensure graceful handling of exceptions during runtime, making Java suitable for building enterprise systems that demand high availability and fault tolerance. 
#
**Extensive Ecosystem and Libraries**
#
Java boasts a vast ecosystem of libraries and frameworks that provide developers with a rich set of tools and functionalities. This ecosystem includes popular frameworks like Spring, which simplifies enterprise application development, and Apache Kafka, a distributed messaging system for building scalable and event-driven architectures. The availability of these resources helps expedite development and enhances the overall productivity of enterprise teams. 
#
**Strong Community Support**
#
Java enjoys a thriving community of developers, architects, and enthusiasts who actively contribute to its growth and improvement. This vibrant community provides valuable resources, forums, and open-source libraries that facilitate knowledge sharing, troubleshooting, and collaboration. The continuous support from the community ensures that Java remains up-to-date and relevant in the rapidly evolving enterprise architecture landscape. 
#
#### **Java's Role in Modern Enterprise Architecture**
#
**Integration with Legacy Systems**
#
Many enterprises rely on legacy systems that still hold critical business functionality. Java's compatibility with legacy systems enables smooth integration and coexistence, allowing organizations to leverage their existing investments while gradually modernizing their architecture. 
#
**Microservices and Modular Architecture**
#
Java's object-oriented programming paradigm, coupled with frameworks like Spring Boot, facilitates the development of microservices-based architectures. Microservices offer flexibility, scalability, and resilience, enabling enterprises to build complex systems composed of loosely coupled and independently deployable components. 
#
**Scalability and Performance**
#
Java's robustness and efficient memory management make it suitable for handling high-volume and resource-intensive enterprise workloads. With technologies like Java Virtual Machine (JVM) optimizations, just-in-time (JIT) compilation, and garbage collection, Java provides excellent scalability and performance characteristics, ensuring reliable and responsive enterprise systems.
#
**Security and Compliance**
#
Enterprises deal with sensitive data and must adhere to strict security and compliance regulations. Java offers robust security features, including secure coding practices, encryption libraries, and authentication mechanisms. Additionally, the extensive security frameworks and tools available in the Java ecosystem help developers build secure enterprise applications that comply with industry standards and regulations. 
#
#### **Java Frameworks and Tools for Enterprise Architecture**
#
**Spring Framework**
#
Spring is a comprehensive framework that simplifies enterprise application development. It provides features like an inversion of control (IoC), aspect-oriented programming (AOP), and support for building RESTful APIs, making it a go-to choice for building scalable and maintainable enterprise systems. 
#
**Java EE (Enterprise Edition)**
#
Java EE, now known as Jakarta EE, is a collection of specifications and APIs that enable the development of enterprise applications. It provides a standardized platform for building robust, scalable, and secure enterprise systems, with features such as JavaServer Faces (JSF), Enterprise JavaBeans (EJB), and Java Message Service (JMS). 
#
**Jakarta EE (Eclipse Enterprise for Java)**
#
Jakarta EE builds on the foundation of Java EE and is now managed by the Eclipse Foundation. It continues to evolve with new features and enhancements to meet the needs of modern enterprise architectures, including cloud-native development, microservices, and reactive programming. 
#
**Apache Kafka and Messaging Systems**
#
Apache Kafka is a distributed streaming platform that provides high-throughput, fault-tolerant, and real-time data streaming capabilities. It plays a vital role in building event-driven architectures, enabling reliable communication and data flow between different components of an enterprise system.
#
**Hibernate and JPA (Java Persistence API)**
#
Hibernate is an object-relational mapping (ORM) framework that simplifies database interaction in Java applications. It provides a high-level abstraction over database operations and allows developers to work with objects rather than writing complex SQL queries. The Java Persistence API (JPA) is a specification that standardizes ORM in Java, providing a consistent and portable way to persist and retrieve data.
#
#### **Case Studies: Successful Java Implementations in Enterprise Architecture**
#
**Netflix**
#
Netflix, a leading global streaming service, relies heavily on Java for its backend infrastructure. Java's scalability, fault tolerance, and ecosystem of tools and frameworks have enabled Netflix to handle millions of simultaneous streaming sessions and deliver a seamless user experience. 
#
**Amazon**
#
Amazon, the world's largest e-commerce platform, utilizes Java extensively for its enterprise architecture. Java's reliability, performance, and strong ecosystem have enabled Amazon to build and maintain a highly scalable and secure infrastructure, supporting millions of daily transactions.
#
**LinkedIn**
#
LinkedIn, the popular professional networking platform, leverages Java for its enterprise architecture needs. Java's versatility, compatibility with legacy systems, and support for large-scale distributed systems have enabled LinkedIn to handle a massive user base and provide a robust and feature-rich platform.
#
**PayPal**
#
PayPal, a leading online payment system, relies on Java to power its enterprise architecture. Java's security features, scalability, and performance characteristics have been instrumental in ensuring the secure and efficient processing of millions of financial transactions on a daily basis. 
#
#### **Java's Future in Enterprise Architecture**
#
**Java's Adaptability to Emerging Technologies**
#
Java has consistently evolved to embrace emerging technologies and trends. With the introduction of features like modules, reactive programming, and support for cloud-native architectures, Java continues to adapt to the changing landscape of enterprise architecture, making it a future-proof choice for organizations. 
#
**Support for Cloud-Native Development**
#
As organizations increasingly migrate their applications to the cloud, Java provides strong support for cloud-native development. Frameworks like Spring Cloud and tools like Kubernetes and Docker enable Java developers to build and deploy microservices-based architectures in cloud environments, ensuring scalability, resilience, and elasticity. 
#
**Java's Role in Big Data and AI Applications**
#
With the proliferation of big data and AI technologies, Java remains relevant in handling large-scale data processing and analytics. Frameworks like Apache Hadoop and Apache Spark, built on Java, offer powerful tools for distributed data processing and machine learning, making Java a valuable asset in enterprise architectures dealing with data-intensive applications. 
#
#### **Challenges and Considerations in Java Enterprise Architecture**
#
**Learning Curve and Complexity**
#
Java, being a mature and feature-rich language, has a learning curve associated with its complexity. Developers new to Java may need time to become proficient in the language and its associated frameworks, which can impact the initial development timeline. 
#
**Performance Optimization**
#
While Java provides strong performance characteristics, inefficient code or improper use of frameworks can lead to performance bottlenecks. Developers need to be mindful of optimizing code, minimizing resource consumption, and leveraging performance profiling tools to ensure optimal performance in enterprise systems. 
#
**Maintaining Code Quality and Minimizing Technical Debt**
#
As enterprise systems grow in complexity, maintaining code quality and minimizing technical debt becomes crucial. Consistent code reviews, adherence to coding best practices, and refactoring efforts are necessary to keep the codebase maintainable, extensible, and resilient in the long term. 
#
#### **Conclusion**
#
Java's relevance in the world of enterprise architecture remains strong and justified. Its platform independence, robustness, extensive ecosystem, and strong community support continue to make it an ideal choice for building large-scale enterprise systems. 
#
With its adaptability to emerging technologies, support for cloud-native development, and role in big data and AI applications, Java is well-positioned to meet the evolving needs of modern enterprise architectures. Despite challenges, Java's future prospects in the enterprise space remain promising, ensuring its continued importance and value for years to come. 

Blog cover basic Java Enterprise Architecture.png

Java has long been a dominant player in the programming world, known for its versatility, robustness, and extensive community support. 

Why Java is Still Relevant in the World of Enterprise Architecture 

It is no surprise for all of us working in the software development domain, but **communication is key.** We even came up with complete ways of working where communication is part of the way of working, like Scrum, Agile, which has all the artifacts in place to manage this. 
#
- Design to brainstorm about the ideas, needs, and solutions
- Refinement to determine impact and way to go
- Demo/Review to show the output of the iteration and discuss the next steps coming iteration
- Retrospective to discuss what went well and what could be improved, including determining actions to do so
- Planning to determine what to pick up during the next iteration
- Daily standups
#
Where teams and organizations often tend to find themselves in pretty long meetings, these ways of working give a clear structure and, in the meantime, flexibility due to the short iterations.
#
The clear **structure is focused on communication** because we are not having all these sessions in place without a reason. The idea is to have a continuous alignment in the team and with the business, where e.g. the daily stand-up is not meant to check on people being awake but focuses on the progress in the sprint (iteration) towards the sprint goal. If there is an impediment to reaching the goals, we can address and solve this immediately. Next to that having the designs and refinement gives us the ability to understand the needs, and our retros allow us to learn and optimize. In the end, this is all communication.
# 
So why does this often not result in the best and expected results? Well, multiple reasons, but having sessions planned and in place is only the first step. Often we see people simply not playing by the rules. The business does not attend the demo/review (they are too busy), refinement we do without the business (because they do not understand), daily we use to explain that the cat was sick or to change scope (but the sprint goal is no longer a goal?).
# 
Of course, **not everyone** is a good communicator. We and especially the younger generations are learning more and more that communication is important, but it remains a challenge. Does this mean you can't solve this, and every IT project is a hassle? No, of course not. 
# 
This is why **we work with cross-functional teams,** where the T-shaped people (which means everyone has a different sweet spot) work together to make sure that technical skills, communication skills, and business sensitivity are part of the skillset. You can work with small teams, preferably you do, but make sure you add the right PO, devs/dev ops, and QA automation.
#
Discover the secret ingredients to success that we've honed through our years of experience! Ready for an engaging conversation about what propels you toward greatness? Don't hesitate to reach out, and let's dive deep into the recipe for your triumph!

Blog cover basic cross functional teams.png

It is no surprise for all of us working in the software development domain, but communication is key. 

Maximizing Efficiency: Unlocking Potential with Cross-Functional Teams

So last week, we talked about how the customer needs to determine the technology stack if you focus on creating the right solution for the challenge.
#
Having a certain technology stack based on what is needed for the solution is, of course, not the only reason to choose a given stack. In the end also here there are multiple roads you could follow. 
#
**- What is the knowledge and skill set of your current teams?** What fits our team?
#
**- What about the mentality of the dev teams?** Are they able and willing to learn and adapt, and most important fail?
#
**- What about the leadership of the company?** Is there a culture where you can fail?
#
**- What about the budget?** Adapting a new stack, learning, and failing, of course, all cost money.
#
Let's also be honest. Our clients are running a business, and businesses often need to make money to pay salaries and the new boat of the owners/investors. There are more things to take into account than following the almost romantic books and examples out there. 
#
When we talk about the "romantic" part of nowadays ways of working, in my opinion, beautiful culture that these ways of working, like our beloved scrum, bring. A culture and mentality that is built upon trust, ownership, innovation, agility, and failing to learn, will in my opinion build stronger teams that have more perspective, are more confident, show more commitment, and as a result output in terms of quantity and quality (innovation).
#
But if your leadership does not have enough finances, it often leads to skipping important parts of the way of working or team setup, like PO, and QA. If the organization does not understand the way of working or is not willing to adopt it, or the dev team exists out of people who hide behind the way of working instead of embracing ownership, proactivity, trust, and teamwork. In this case, you will fail in the long term. 
#
Congratulations on your "failed fast," but sadly, it is not the type of failure you wanted.
#
Can you solve this? Yes, of course! Start with being honest with everyone, including yourself.
# 
Are we as an organization fit to develop software?
#
**1. Do you have the right competencies?**
#
Yes - OK, great. Please, continue.
No - OK, great. Now you know, so buy your standard solution SAAS/PAAS, or hire an IT partner that guides you.
#
**2. Do you have the right budget?**
#
Yes - OK, great, check again. IT development is expensive!
No - OK, great. Now you know, so could you maybe limit the requirement or standardize your processes so standard SAAS/PAAS will help you optimize. So kill exceptions!
#
**3. Do you know what you need?**
#
Yes - OK, great. Are you sure? Please, check answer b. below.
No - OK, great. Then hire an IT partner that guides you and starts your project with a POC or MVP to prove your ideas make sense. Is there a market for your solution? Is the market willing to pay for your solution? Does it indeed optimize your processes limiting the cost to serve, or was it all a wrong assumption? These are all important questions. Here is our romantic frase applies - failing is not bad, but do it fast.
#
**4. Are you able to explain what you need?**
#
Yes - OK, great. You are probably the right PO, but do you have the time to help the devs?
No - OK, great. No worries, just make sure the competency is in your dev team by hiring the right PO. 
#
In the end, next to choosing the right technology stack, it is even just as important to **have the right team, organization, competencies, values, and way of working** to deliver value for the organization. 
#

Blog cover Beyond the Code.png

So last week, we talked about how the customer needs to determine the technology stack if you focus on creating the right solution for the challenge.

Beyond the Code: The Vital Human and Organizational Elements of Tech Success

#### **Solution first**
#
At The IT Solutions, **we focus on the solution, not the technology stack.** Let's be honest, for every solution and situation, you can use a certain stack that is probably more suitable. 
#
Let me give you some examples.
#
#### **The Dutch Railroads**
#
We work for the NS (Dutch Railroads) which has a **clearly defined stack of Azure, Java, and Angular** (and in some projects, we use React). It is logical for the NS, who has an enterprise architecture, that even new POCs should follow the same setup. This does not mean the NS is not innovative. I think they are probably one of the most innovative and modern companies out there. They just can't afford to not go with the stability that a language like Java provides.
#
#### **Gulf Gas and Power**
#
We work with Gulf Gas and Power which are growing big in the energy domain. In this project, we work with a stack that for example includes **AWS, Python, Java, and React.** Most companies in the energy domain need the stability of grown-up languages, but because of the dynamics in this domain, we also need to take newer languages into account to reach the goals. For example data, but also IoT, is getting more and more important. We encounter more and more of a need to use data to forecast, which is often done by using AI. AI is mostly being built in languages like Python and Go. Go for example performs way better than Java with large amounts of data. 
#
#### **Start-ups and scale-ups**
#
We often work with start-ups, that **do not care about the stack,** they just have a great idea. Starting with a language like Java is often not a good idea. Not because you could not start fast (we showed it multiple times it is possible) but because the goals of the typical start-up often need a different approach. Let's say the first step is to build a POC or MVP to get in new investors, then Languages like **Python** (usually for AI, but hey.... aren't we all working with AI nowadays, haha), but also **Node.js and Next.js** will do the trick. But if you envision yourself having an enterprise someday, you need to think about the **pros and cons of the stack you chose.** upfront. 
#
#### **Technologies we use**
#
So does that mean at The IT Solution we do everything? No, absolutely not. Our **backbone is still Java** it is where we come from. This is why we say we have the **best engineers** because if you know how to program in Java, you know how to build a solution. Are we sticking to Java? No, we are absolutely not! We do more and more in the area where **Go** is more suitable, and we are big fans!
#
#### **Cloud solutions**
#
And what about the Cloud? Yes, we are an **AWS partner,** which is logical if you look at the stack we work with often. Does that mean we do not see the benefits of other cloud solutions? No, of course not. We also work with **Azure** and some really cool private clouds.
#
#### **Clients to succeed**
#
In the end, it boils down to **what our clients need to be successful** and we are more than happy to help our clients in those choices. 
#
#### **Real business partner**
#
Oh yes, I almost forgot. No, we do not use .net (as Messi will also never play for Real Madrid, right?), but we will always be here to help you find the **right solutions** and to be your **real business partner.**
#

Blog cover basic Solutions first.png

At The IT Solutions, we always say we focus on the solution, not the technology stack, which is completely true. 

Putting Clients First: The IT Solutions' Solution-Driven Approach

#
#### **Bence Koncz** 
![1.png](https://backoffice.tis-io.theitsolutions.io/uploads/1_f931776d44.png)
#
**Where did you hear about Tech Academy?**
#
I've been following The IT Solutions on LinkedIn for a while, and that's where I found Tech Academy. 
#
**Why did you apply for the Tech Academy?**
#
It was a perfect opportunity to expand my professional knowledge and learn about new technologies, so I applied almost immediately.
#
**How did the Tech Academy start?**
#
After a few email exchanges, things quickly picked up. First, I received the test assignment. I could choose to do frontend or backend tasks. I opted for the backend task and had two weeks to do it. Shortly after completing the test task, I received another email with the good news that I was one of the lucky ones to participate in Tech Academy. The training started in late October last year and ran until this March.
#
**Have you ever studied software development?**
#
Yes, I have. I'm currently a final-year student of Computer Science at the Faculty of Informatics at the University of Debrecen, so I was excited to start this course.
#
**How was it working with your mentor?**
#
Working with my mentor was very smooth. We usually met in person once a week in the office to discuss current issues and problems with the project. Otherwise, we were in daily online contact, so if I got stuck on something, I could get quick help from him.
#
**What did you like most, and what new things did you learn at Tech Academy?**
#
I liked that I got to go into the office and see a little bit of the inside of how a software development company works. The other thing is that I learned a lot. I improved my knowledge of Spring Boot and also learned about new technologies. One of these was Docker. 
#
**How will you use the knowledge you have gained? What are your plans for the future?**
#
I feel that the Tech Academy was a good choice, as I have gained a lot of useful knowledge in the last few months. I will be able to use all of this in my future job. I want to expand my Java backend knowledge even more because that's what I want to do in the future.
#
#
#
#### **Andrea Kis-Lődár** 
![2.png](https://backoffice.tis-io.theitsolutions.io/uploads/2_a7ac22f678.png)
#
**Where did you hear about Tech Academy?**
#
I came across the Tech Academy in a LinkedIn post, which appealed to me at first, but I wondered whether I should take it up or not, as I had never participated in a similar program before. I didn't know what to expect, to be honest.
#
**Did you have any previous training?**
#
I studied Computer Science in high school, where I learned the basics of HTML and CSS. But after high school, I continued my studies in a different direction, at the University of Debrecen, Faculty of Economics, where I graduated as an economist. Later, I took a web design course, where I honed my HTML and CSS skills and was introduced to the Bootstrap framework. This course was good not only because it gave me new skills but also because it was here that I started to get interested in frontend development and where I realized that I had a knack for it.
#
**Why did you apply for Tech Academy?**
#
I wanted to improve the skills I had already acquired, and I felt Tech Academy was a superb opportunity for this. I was looking for a training program with a clear and transparent structure. I think the advantage of the Tech Academy over self-study was that it gave a defined system with appropriate deadlines. I needed to have a mentor for the assignments and continuous feedback on my work.
#
**How long did the Tech Academy last?**
#
The Tech Academy lasted for three months and involved an average of 20 hours per week, which included office work one day per week.
#
**How was it working with your mentor?**
#
I can only say positive things about working with him. He was helpful, and I learned a lot. We took the project very seriously and worked on it as if it was a real company project. We had standup meetings online on Monday, Wednesday, and Friday and talked about how the project was going and the parts I was stuck on. The project was to create a web application for a dog school. 
#
**What did you learn? What was the most useful part of the training?**
#
As I had no previous training in this area, I had to start from the ground up, so I learned a lot of theory, especially at the beginning of the Tech Academy. It was very useful to learn about several technologies and try them out in practice during the training, as well as to discuss best practices with the mentor.
#
**What are your plans for the future?**
#
I did not stop studying when Tech Academy ended. I'm still learning. I'm working on a new project where I think I can gain more routine in the technologies I've learned. Soon, I would like to get a job as a frontend developer, and I'm looking forward to putting the theoretical and practical knowledge I have gained to good use. 
#
#### **Ádám Dorogi**
![3.png](https://backoffice.tis-io.theitsolutions.io/uploads/3_91e4ea660d.png)
#
**Where did you hear about Tech Academy?**
#
I first heard about it on The IT Professional Days at the University of Debrecen, and later my friend who works at The IT Solutions shared a post about it on Facebook.
#
**Why did you apply for Tech Academy?**
#
I felt that I was completely stuck in my professional studies and needed a direction in which I could progress. 
#
**Did you have any previous qualifications?**
#
I had minimal knowledge of Java, which I learned during my university studies. I have never participated in a program like this before. 
#
**How was it working with your mentor?**
#
Very good. He was always available and didn't spare me. He gave me a lot of tasks, but of course, he also helped me when I got stuck.
#
**What project did you work on? What did you learn?**
#
I worked on an almost complete backend implementation of a dog school. It's hard to list how much I've learned. My knowledge of Java has improved, such as in Git, Jira, Gradle, Spring Boot, PostgreSQL, Docker, and Postman.
#
**What did you like the most?**
#
Beyond the learning, I think the best thing was that everyone at The IT Solutions treated me as if I worked there, and I had the opportunity to gain insight into the day-to-day life of a software development company. It was pretty cool.
#
**What did you like about the training?**
#
For me the whole training was useful, it's hard to single out one thing. I was able to hone my Java skills further, and of course, I could learn about other technologies.
#
**How will you use the knowledge you have gained? What are your plans for the future?**
#
First, I want to finish my studies at the university and then complete the junior recruitment task at The IT Solutions. If there is vacancy, I would love to work at the company. If that is not possible, I hope to find a job soon where I can use what I have learned. I am confident that the knowledge I have gained at the Tech Academy will help me to find a job in the labor market.



Blog cover TA inteview.png

The Tech Academy finished just a few weeks ago, so we interviewed three graduates to share their personal experiences with the training program.

The Tech Academy finished just a few weeks ago, so we interviewed three graduates to share their personal experiences with the training program and how it helped them to move toward their career goals. 
All graduates shared their unique stories and spoke about the comprehensive training they received at The Tech Academy. Thanks to the practical, hands-on approach of the program and the mentorship opportunity, graduates gained the confidence and skills needed to succeed as software developers.


From Zero to Hero: How The Tech Academy Transformed These Graduates

#
#### **Our Why**
**"Because we believe every business deserves an IT partner who understands that IT should increase business value."** Of course, it leads to a really cool and logical dream and clear brand promise because partnering with us will give our clients "acceleration on their business through innovative/modern IT Solutions."
#
At the same time, we also wanted to be an organization with a **no-nonsense mentality.**
#
**So how do we roll?**
#
As a modern software development team, you need to have the **right competencies** and core values to be able to understand and help the client. For us, that means creating software that enables the **success of our clients' business models.** Next to having skilled people this also means we focus on values like customer centricity, business sense, open and direct communication, and teamwork, of course.
#
#### **Reaching goals**
To be able to reach the goals we set with our clients, we build small teams that exist out of different **skillsets and experiences,** but also we follow the T-shape model where the different team members have areas they have more affinity with than the others, stand out in or still have to learn. 
#
#### **Our teams**
Some like to focus on automated tests, some on the functional part of the app, and others on the look and feel. Combining different interests, competencies, and levels of experience will lead to having **self-organizing teams** that bring the **biggest value to our clients.** Especially if the client is looking for proactive teams that embrace ownership, open and direct communication, and trust, the team is able to start a project fast and deliver the best quality needed for the clients' goals. 
# 
This, in the end, builds self-organizing teams, which bring the biggest value to our clients. Especially if the client is looking for **proactive teams** that can **start a project fast** and **deliver the best quality** needed for the goals. 
#
#
**Quincy Verkolf, CEO**
#
+31 (0) 64 188 33 10
#

Blog cover how tis roll.png

Recently I informed you about why Meindert Prins and myself started The IT Solutions. This time I would like to tell you about what we do.

How Do We Roll?

#### **The beginning**
With our **5th anniversary** at our doorstep and preparing for our celebration, I stumbled upon some documents from the very beginning. 
#
I am very proud that even though we changed the road and toolset a couple of times along the way, the goal remained the same. The goal we wrote down on our first business canvas and later our scale-up methodology, but of course, they have been very ambitious to reach.
#
#### **Our belief**
That first discussion on **our WHY** led to our belief that **”Every business deserves an IT partner who understands that IT should increase business value.”**
# 
#### **Partnerships that last**
Who could have imagined that after five years of creating self-organizing software development teams, **helping our clients** from idea to startup, to scale up even enterprises to their next phase in digitization, has **led to partnerships** where our clients promote us as advocates to their network? Next to the feeling of succeeding, of course, this is the biggest compliment we could get.
 # 
 But enough of the bragging! Of course, we are not perfect. We made many mistakes during our journey, and we learned from them. 
# 
#### **Get to know us**
Would you like to **learn more about who we are**, why we are here, and what we deliver? Would you like to know what we have learned about working with our hybrid teams, different cultures, and people working on the same goal, and **how we cooperate successfully** with our clients and partners?
# 
#### **Follow us**
If yes, please **follow us on [LinkedIn](https://www.linkedin.com/company/the-it-solutions/)** or on our website in the upcoming period, when we will share all the aspects of being a solution provider in the international custom software world.
# 
And if you can’t wait, and of course, you can’t, **give me a call or send me a [DM!](https://www.linkedin.com/in/quincyverkolf/)**
# 
**Quincy Verkolf, CEO**
#
+31 (0) 64 188 33 10
#
[quincy.verkolf@theitsolutions.io](emailto:quincy.verkolf@theitsolutions.io)


Blog cover who is TIS.png

With our 5th anniversary at our doorstep and preparing for our celebration, I stumbled upon some documents from the very beginning. 

Who Is TIS, and Why Are We Here?

#### **Introduction**
In software development, two essential skills stand out. One is coding skills, and the other is teamwork. While coding skills refer to the technical abilities required to write efficient and effective code, teamwork is the ability to collaborate and work effectively with others. 
#
Which one is the most important? 
#
Both are crucial for developers, and their importance can vary depending on the project and its specific requirements. In this article, we'll explore the importance of both. 
#
#### **The Importance of Coding Skills for Developers**
**Technical skills required for coding**
#
Coding skills involve proficiency in programming languages, understanding algorithms and data structures, and knowledge of database technologies, among other things. The most successful developers possess expertise in multiple programming languages and tools.
#
**Education and training necessary for developing coding skills**
#
A developer's education and training are crucial in developing their coding skills. Formal education in computer science, engineering, or a related field is a great foundation, but self-learning and continuous professional development are also essential. Developers can participate in online courses, read blogs, and attend conferences to stay up-to-date with new technologies and tools.
#
**Importance of coding skills for creating high-quality code**
#
Coding skills are essential for writing efficient, bug-free code that meets project requirements. High-quality code is maintainable, scalable, and easy to modify, making it more cost-effective in the long term. Developers with stable coding skills can create software that performs well, is easy to maintain, and adapt to new features or requirements.
#
#### **The Importance of Teamwork for Developers**
#
**Collaboration and communication skills are necessary for teamwork**
#
Collaborating with fellow developers, designers, and stakeholders towards a shared objective is essential in teamwork. To achieve effective collaboration, it's crucial to possess exceptional communication skills, listen actively, and communicate clearly and concisely. In this regard, giving and receiving feedback is one of the most critical abilities.
#
**Importance of working closely with other team members**
#
Working closely with other team members is vital for developing software that meets the project's requirements. Developers must understand how their code interacts with the rest of the project. They must work collaboratively with others to identify and resolve issues.
#
#### **Instances Where Teamwork Outweighs Coding Skills**
#
**Illustrations of projects where successful outcomes hinge on teamwork**
#
In certain projects, teamwork plays a more significant role in achieving success than coding skills. One such example is software development for medical institutions or government agencies. These endeavors entail strict requirements, regulations, and communication with stakeholders. In such projects, the capability to work well with others and manage multiple stakeholders is pivotal to success.
#
**Importance of sustainable and extensible code in the long run**
#
For any project to flourish in the long run, the code must be sustainable and extensible. Developers must take into account the needs of future developers who will maintain and augment their code. Collaborating effectively with other team members, including testers and project managers, guarantees that the code is sustainable and extensible over time.
#
#### **When Coding Skills are More Important than Teamwork**
#
**Examples of projects where technical skills are critical**
#
In some projects, technical skills are more important than teamwork. For example, developing a high-performance video game or a machine learning algorithm requires advanced coding skills and knowledge of specific programming languages and tools.
#
**Importance of expertise in specific programming languages and tools**
#
Expertise in specific programming languages and tools is critical in some projects. Developers must have a deep understanding of the chosen technology and use it effectively to achieve the project's objectives. In these cases, technical skills are more important than teamwork.
#
#### **The Importance of Both Coding Skills and Teamwork**
Developers who work well in a team environment can be more productive, efficient, and creative, resulting in better software products. When developers work together, they can share their expertise and learn from each other, leading to increased innovation and problem-solving abilities.
#
Adaptability is also a critical skill for developers. With the rapid pace of technological change in the industry, developers must be able to adapt quickly and learn new skills and technologies as they emerge. Developers who possess both coding skills and teamwork abilities are often more adaptable, as they can work well in different team environments and are more likely to embrace new technologies and ways of working.
#
#### **Conclusion**
In conclusion, coding skills and teamwork are equally essential for developers to be successful in software development. While coding skills are critical for creating high-quality code, effective teamwork is just as important. 
#
Developers who possess both skills can be more productive, innovative, and adaptable, resulting in better software solutions. However, the importance of each skill depends on the project, and developers must be able to adapt and prioritize accordingly.

Blog cover teamwork.png

In software development, two essential skills stand out. One is coding skills, and the other is teamwork. Which one is the most important? 

The software development industry is constantly evolving and becoming more complex. It means developers must have a wide range of skills to be successful. Two of the most important skills for developers to possess are coding skills and teamwork.

Teamwork vs. Coding: Which is the Key to Successful Software Development?

#### **Short description**
Once when I was on the **JetBrains** site, I noticed a hover effect that caught my eye. This effect follows the movement of the mouse inside a box and a highlight appears around the cursor. As a Frontend Developer, I immediately had the idea to create this trick myself. I created it in **React,** because that is the framework I like the most. Now let's see how I made the implementation this component! The project repo can be found on **GitHub,** in the links at the end of this article.
#
But what exactly are we talking about? Here's a screenshot from the [JetBrains site](https://www.jetbrains.com/space/), the link is also at the end of the article.
#
![JetBrains.gif](https://tis-tis-io-asset-prd.s3.eu-central-1.amazonaws.com/Jet_Brains_252839e127.gif)
#
#### **How does it work?**
First, a summary of how the magic works: is actually a function that **continuously follows the movement of the mouse inside the box.** So need to be able to determine the exact position of the cursor. And display the highlighting around the cursor. Which we will achieve by changing the background of the Box itself.
#
#### **Let's get started!**
As a first step, I created a new **React** application. I've also included **TypeScript** in it.
#
```bash
npx create-react-app moving-highlight --template typescript
```
#
Then install the necessary libraries that will be used during development. I will now use **Styled Components** for CSS.
#
```bas
hnpm install --save styled-components
```
#
We also want to use icons, for which I chose **Fontawesome.**
#
```bas
npm install --save @fortawesome/fontawesome-svg-core
npm install --save @fortawesome/free-brands-svg-icons
npm install --save @fortawesome/free-solid-svg-icons
npm install --save @fortawesome/free-regular-svg-icons
```
#
Once these steps are done, let's do a little cleanup of our file structure. Delete the **App.css** file, because as I mentioned we will use **Styled Components.** Feel free to do the same with the logo.svg file. We won't use this one either, as we will have the **Fontawesome** icons there. And convert the **App.tsx** file as follows:
#
```javascript
import React from 'react'

const App = () => {
  return (
    <div></div>
  )
}

export default App
```
#
Then create a folder called **components** inside the **src** folder. And inside the **components** folder, create a file called **MovingHighlight.tsx,** which will be the component we want to create.
#
We initialize our component as follows:
#
```javascript
const MovingHighlight = () => {
  return (
    <div>
      <h3>Moving highlight</h3>
      <p>
        Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
        quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
      </p>
    </div>
  )
}

export default MovingHighlight
```
#
Then import it into our **App.tsx** file:
#
```javascript
import React from 'react'
import MovingHighlight from './components/MovingHighlight'

const App = () => {
  return (
    <div>
      <MovingHighlight />
    </div>
  )
}

export default App
```
#
And then add the import for the CSS:
#
```bash
import styled from 'styled-components'
```
#
Create a **Styled Component** called **AppContainer** with the following **CSS** rules. Then apply the **AppContainer** to the div we created earlier.
#
```javascript
import React from 'react'
import MovingHighlight from './components/MovingHighlight'
import styled from 'styled-components'

const AppContainer = styled.div`
  min-height: 100vh;
  background: rgb(0, 0, 0);
  padding: 1.25rem;
`
const App = () => {
  return (
    <AppContainer>
      <MovingHighlight />
    </AppContainer>
  )
}

export default App
```
#
Next, let's get down to the nitty-gritty of adding logic and style to our component.
#
Let's start with **CSS.** Our outermost container should be the following and don't forget imports:
#
```javascript
import styled from 'styled-components'
import { FontAwesomeIcon } from '@fortawesome/react-fontawesome'
import { faReact } from '@fortawesome/free-brands-svg-icons'
const Box = styled.div`
  color: rgb(255, 255, 255);
  border: 1px solid rgba(255, 255, 255, 0.7);
  border-radius: 0.5rem;
  padding: 0.75rem;
  cursor: default;
  max-height: 18rem;
`
```
#
Then for the icon, the following:
#
```javascript
const StyledIcon = styled(FontAwesomeIcon)`
  opacity: 0.7;
`
```
#
And finally, for the paragraph:
#
```javascript
const StyledText = styled.p`
  opacity: 0.7;
`
```
#
Use the **Styled Components** and add the icon:
#
```javascript
return (
    <Box>
      <StyledIcon icon={faReact} size="5x" />
      <h3>Moving highlight</h3>
      <StyledText>
        Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
        quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
      </StyledText>
    </Box>
)
```
#
#### **Here comes the magic**
For Box, we will need a **useRef,** which will be a reference value and an **onMouseMove** event, which calls a function when moving the mouse pointer over our Box element, and an **onMouseLeave** event, which calls a function when moving the mouse pointer out of our **Box.**
#
These will require the following imports:
#
```bash
import { useState, useRef, MouseEvent } from 'react'
```
#
**useRef:** we need this to determine the position of the mouse inside the Box.
#
```javascript
const boxRef = useRef<HTMLInputElement>(null)
```
#
For the two events, define the following 3 **useState:** 
#
- The **bgColor** is the heart of it all, as we want to manipulate the background of the **Box** as we move the mouse over it. 
- And **left** and **top** will be useful to define the position of the cursor.
#
```bash
const [bgColor, setBgColor] = useState<string>('rgb(0, 0, 0)')
const [left, setLeft] = useState<number>(0)
const [top, setTop] = useState<number>(0)
```
#
**onMouseMove:** when you move the mouse inside the **Box,** it will call a function.
#
Define the following variables:
#
- **originalColor:** the original background color, in this case black.
- **gradientColor:** the Highlight color.
- **gradientSize:** the size of the Highlight.
- **x:** the value of left will be the number of pixels the upper left corner of the Box element is offset to the left. Then subtract this left value from the X (horizontal) coordinate (in pixels) at which the mouse was clicked, relative to the left edge of the entire document.
- **y:** the value of the top will be the distance of the outer border of the Box element relative to the inner border of the top of the offsetParent, the closest positioned ancestor element. Then subtract this left value from the Y (vertical) coordinate in pixels of the event relative to the whole document.
- **xy:** and from the last two we get the exact position of the cursor.
#
Finally, change the background of the **Box** depending on the cursor position, for this, we will use a radial gradient.
#
```javascript
const onMouseMoveHandler = (e: MouseEvent<HTMLDivElement>) => {
    const originalColor = 'rgb(0, 0, 0)'
    const lightColor = 'rgb(0,163,255)'
    const gradientSize = 150

    setLeft(boxRef.current?.offsetLeft ?? 0)
    const x = e.pageX - left

    setTop(boxRef.current?.offsetTop ?? 0)
    const y = e.pageY - top

    const xy = x + ' ' + y

    setBgColor(
      '-webkit-gradient(radial, ' + xy + ', 0, ' + xy + ', ' + gradientSize + ', from(' + lightColor + '), to(rgba(255,255,255,0.0))), ' + originalColor
    )
}
```
#
**onMouseLeave:** when the mouse leaves the **Box,** the highlight should be removed. This is very simple, just change the background color back to its original color.
#
```javascript
const onMouseLeaveHandler = () => {
    setBgColor('rgb(0, 0, 0)')
}
```
#
Add the attributes and events to the component: 
#
- The background css rule for **style** attribute, which will be set to bgColor state. 
- The **ref** attribute to the previously defined **boxRef.** 
- The **onMouseMove** event to the **onMouseMoveHandler.** 
- And for the **onMouseLeave** event, **onMouseLeaveHandler.**
#
```javascript
return (
    <Box style={{ background: bgColor }} ref={boxRef} onMouseMove={(e: MouseEvent<HTMLDivElement>) => onMouseMoveHandler(e)} onMouseLeave={onMouseLeaveHandler}>
        <StyledIcon icon={faReact} size="5x" />
        <h3>Moving highlight</h3>
        <StyledText>
            Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
            quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
        </StyledText>
    </Box>
)
```
#
#### **We're (almost) done!**
#
![First.gif](https://tis-tis-io-asset-prd.s3.eu-central-1.amazonaws.com/First_751a9b6b4a.gif)
#
Make our application responsive by making the following changes in **App.tsx:**
#
```javascript
const AppContainer = styled.div`
  min-height: 100vh;
  background: rgb(0, 0, 0);
  display: grid;
  grid-template-columns: repeat(auto-fit, minmax(18.75rem, 1fr));
  gap: 1.25rem;
  padding: 1.25rem;
`
```
#
Plus add three more times our component:
#
```javascript
return (
    <AppContainer>
      <MovingHighlight />
      <MovingHighlight />
      <MovingHighlight />
      <MovingHighlight />
    </AppContainer>
)
```
#
#### **The final result**
![new.gif](https://tis-tis-io-asset-prd.s3.eu-central-1.amazonaws.com/new_4f87fb8cfd.gif)
#
#### **Links and references:**
#
[https://www.jetbrains.com/space](https://www.jetbrains.com/space)
#
[https://github.com/kristoferdei/react-moving-highlight](https://github.com/kristoferdei/react-moving-highlight)

React 1.png

Once when I was on the JetBrains site, I noticed a hover effect that caught my eye. How can we create one in React? Let's find out.

Mastering Animations in React: Building a Moving Highlight Component


Reading [/r/golang](https://reddit.com/r/golang) topics which post code, there are a few recurring bugs that not just newbies make.
#
One such bug is in the handling of HTTP handlers. Can you spot it in this toy example that's for demonstration purposes only?
#
```go
package main

import (
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
)

type whateverJson map[string]any

func unmarshalRequest(req *http.Request, target any) error {
	body, err := io.ReadAll(req.Body)
	if err != nil {
		return fmt.Errorf("failed to read body: %w", err)
	}

	err = json.Unmarshal(body, target)
	if err != nil {
		return fmt.Errorf("failed to unmarshal json: %w, body was: %s", err, string(body))
	}

	return nil
}

func main() {
	http.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
		t := whateverJson{}
		err := unmarshalRequest(req, &t)
		if err != nil {
			http.Error(w, err.Error(), 400)
			return
		}

		fmt.Fprintf(w, "got: %#v\n", t)
	})

	log.Fatal(http.ListenAndServe(":8080", nil))
}
```
#
Knowledge of the HTTP protocol when writing HTTP handlers is crucial.
The key to the bug is knowing that request bodies can be arbitrarily big, so we must specify the maximum amount of data that we want to handle.
The bug is not using [MaxBytesReader](https://pkg.go.dev/net/http#MaxBytesReader) to do so.
An adversary could send us a multi-gigabyte request, and we would buffer it all in-memory, possibly causing a Denial Of Service issue.
There are multiple other issues with this code as well, lets go through them:
- Do we really need to buffer the request body in memory?  
  Apart from helping with debugging, there can also be requirements that mean we do indeed need to buffer it all, but in all other cases we should use the [streaming decoder](https://pkg.go.dev/encoding/json#example-Decoder.Decode-Stream).  
  Since we are not really interested in the JSON "as a whole", but the data it encodes, we can optimize the decoding this way.
#
- Decoding JSON into `map[string]any` is an antipattern and leads to ugly code. It rarely happens that the JSON data we want to support is so generic that we can only represent it this way.  
  [Maybe we could partially decode the JSON first, to see what type we should unmarshal it into.](https://eagain.net/articles/go-dynamic-json/)
#
- We didn't customize the HTTP server's timeouts, and we probably should depending on our usecase.  
  The defaults are:
  - no [ReadTimeout](https://cs.opensource.google/go/go/+/refs/tags/go1.20.2:src/net/http/server.go;l=2633) meaning our handler can take as much time as it needs to process the request before reading the request body
  - no [ReadHeaderTimeout](https://cs.opensource.google/go/go/+/refs/tags/go1.20.2:src/net/http/server.go;l=2641) meaning the client can be infinitely slow in sending us the HTTP headers
  - no [WriteTimeout](https://cs.opensource.google/go/go/+/refs/tags/go1.20.2:src/net/http/server.go;l=2648) so our handler can be infinitely slow in giving a response
  - no [IdleTimeout](https://cs.opensource.google/go/go/+/refs/tags/go1.20.2:src/net/http/server.go;l=2654) so we will keep the TCP connection open indefinitely when keep-alives are enabled
#
A marginally better version of the code above is:
#
```go
package main

import (
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"time"
)

type whateverJson map[string]any

const requestBodyLimit = 2 * 1024 * 1024

func unmarshalRequest(r io.Reader, target any) error {
	dec := json.NewDecoder(r)

	err := dec.Decode(target)
	if err != nil {
		return fmt.Errorf("failed to unmarshal json: %w", err)
	}

	return nil
}

func main() {
	srv := http.Server{
		Addr:              ":8080",
		ReadHeaderTimeout: time.Duration(30 * time.Second),
		IdleTimeout:       time.Duration(30 * time.Second),
	}

	http.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
		t := whateverJson{}
		r := http.MaxBytesReader(w, req.Body, requestBodyLimit)
		err := unmarshalRequest(r, &t)
		if err != nil {
			http.Error(w, err.Error(), 400)
			return
		}

		fmt.Fprintf(w, "got: %#v\n", t)
	})

	log.Fatal(srv.ListenAndServe())
}

```
#
Sadly the defaults are now impossible to change, as that would be a backward-compatibility break, [which is a big no-no](https://go.dev/doc/go1compat).
#
The compatibility promise is crucial to the health of the Go ecosystem so the only thing to do is to be aware of these issues.
#
If you would like some additional information with regards to exposing your HTTP server on the net, gopheracademy has some very useful information. 
#
Link: [https://blog.gopheracademy.com/advent-2016/exposing-go-on-the-internet/](https://blog.gopheracademy.com/advent-2016/exposing-go-on-the-internet/)







Go article v2.png

Reading GoLang topics which post code, there are a few recurring bugs that not just newbies make.

The Art of Handling Infinite Input in GO Web Handlers

Nowadays, developers have multiple options to **add styling** to a project. They can write Vanilla CSS or use pre-processors like SASS or LESS and code at a higher level. Writing CSS in JavaScript is another method. Utility classes or UI toolkits can also be used if writing the least amount of CSS is the goal.
#
#### **The "traditional" way**
#
When I started web development the first JavaScript framework I got to know was Angular. It is based on this approach. You have a template file for the HTML, a component file for the JavaScript and a dedicated CSS file for the styling.
#
Let's say we have a button we would like to style.
#
HTML
#
```bash
<button class="my-button" onclick="handleOnClick()">Click me</button>
```
#
JavaScript
#
```bash
function handleOnClick() {
 console.log('You clicked the button.');
}
 ```
 #
 CSS
 #
 ```bash
 .my-button {
  color: white;
  border-width: 0;
  border-radius: 8px;
  padding: 8px 16px;
  background-color: #F7941F;
 }
  ```
  #
  **Pros**
  #
  It is a structured approach. The code is **easy to read and maintain**. We can also reuse the CSS effortlessly.
  #
  **Cons**
  #
  Dynamic styles cannot be implemented in CSS files, as JavaScript is in a separate place.
  #
  #
  #### **CSS-in-JS**
  #
I learned the "CSS-in-JS" pattern when I got to know with React. In this case you have the styling and the component in the same file.
  #
```javascript
const useStyles = createUseStyles({
 myButton: {
   color: 'white',
   borderWidht: 0,
   borderRadius: '8px',
   padding: '8px 16px',
   backgroundColor: '#F7941F'
  }
});

export function Button(props) {
 const classes = useStyles();

 const onClick = () => {
   console.log('You clicked the button.');
 };

 return (
   <div className="container">
     <button className={classes.myButton} onClick={onClick}>
       My button
     </button>
   </div>
 )
}
 
```
#
**Pros**
#
Here, CSS is closer to the component than in the first method. Additionally, it's also **more dynamic** when it comes to adding classes to elements. Besides, there's less chance to leave unused classes in the code.
#
**Cons**
#
It's more like JavaScript. If you are not a big fan of this programming language, it will be hard working with it. Rewriting an existing CSS codebase to CSS-in-JS syntax is time-consuming. You must use an external library to add this functionality to your project.
#
#
#### **"Zen Mode" CSS**
#
I'm relatively new to Tailwind. I started using it for one of my hobby projects. It's a utility-first CSS framework which contains built-in classes.
#
```javascript
export function Button(props) {
 const onClick = () => {
   console.log('You clicked the button.')
 }

 return (
   <div className="container">
     <button className="text-white border-0 rounded-lg py-2 px-4 bg-[#F7941F]" onClick={onClick}>
       My button
     </button>
   </div>
 )
}
 
```
#
**Pros**
#
Here the logic is separated from the styling. It means if we need to write CSS, we only have to focus on the JSX part of the component. That's great because we won't lose focus. We don't have to spend time figuring out class names as Tailwind has built-in classes. Overall, it **gives a better developer experience.**
#
**Cons**
#
As it has built-in classes, it takes time to learn. Tailwind is not a component library. In most cases, we have to style a button, input, or select from scratch.
#
#### **Conclusion**
#

The steps above were our journey to find the most productive way of writing CSS. Although Tailwind provides an excellent solution, it may not be optimal for everyone. Of course, each method has pros and cons, and developers are different. The most important is to find the best-fit solution for the project and yourself.
#
#



 










Blog cover CSS.png

In this article, we aim to look at the "traditional" way of writing CSS, the CSS-in-JS method, and the "Zen Mode" and list the pros and cons of each.

CSS stands for Cascading Style Sheets. It describes how HTML elements are to be displayed on screen, paper, or in other media and allows us to create great-looking web pages. There are three ways of inserting a style sheet: inline, internal (embedded), and external CSS. In this article, we aim to look at the "traditional" way of writing CSS, the CSS-in-JS method, and the "Zen Mode" and list pros and cons of each.

Inner Peace With Zen Mode CSS

#### How did your career start?
#
I started my career as a teacher and taught in secondary grammar and vocational schools, mostly programming, electronics, and electrical engineering. Among the programming languages I taught were C, C++, and Java. Later, I became more interested in Java, and during this time, I had the opportunity to work on small Java projects. 
#
In 2005 we started to form a Java community and held mini-conferences for community members to discuss and help each other with current Java project-related issues. In the Java community, I made a lot of contacts and got several job offers, so I moved to Budapest in 2007 and started working full-time with Java.
#
#### What major Java projects have you worked on as a developer?
#
My first job was at CIB Bank, where we worked on a massive Java system. There, I worked as a Senior Java Developer. My responsibilities were the secure implementation of IT systems, technical management of internal developers, support of IT operations in live environments, optimization and development of software systems, design and development of internal frameworks, and introduction of relevant technologies. 
#
Later, I was involved in developing the magyarorszag.hu website at the National Infocommunications Service Company Ltd. Here, for example, I created the server-side interface for uploading the ÁNYK form (General Form Filling Framework Program). Later, I returned to CIB Bank for a short period and worked my way up to Senior Java Architect.
#
#### When did you become a freelancer?
#
After working at CIB Bank, I started working for smaller companies and with the Android and Kotlin platforms in addition to Java.
#
#### What do you do now?
#
Java projects make up about a third of my work at the moment. I also specialize in general and DevOps consulting, Kubernetes implementation, and creating CI/CD systems.
#
![Gábor Auth.png](https://tis-tis-io-asset-prd.s3.eu-central-1.amazonaws.com/Gabor_Auth_8e4c597432.png)
#
#### What technology do companies need besides Java?
#
Most recently, I've been helping companies with Kubernetes-related projects. I mainly work with companies that have developers and DevOps professionals and want to build a small automated system to simplify their day-to-day operations. I think the companies I work with must have information about Kubernetes. I also help companies determine what services they should and shouldn't put into Kubernetes.
#
#### How do you see technologies changing in Java? What trends do you expect to see in the next few years?
#
With Java, I see big banking and insurance companies using IBM or Oracle. In contrast, smaller startups often use Spring. However, there are also companies running a Kotlin backend. I don't think Java will decline in the next few years, but as we can see, Kotlin is already gaining popularity and is unlikely to decrease soon.
#
#### Is it easy to set up a Java team for a project?
#
Well, it always depends on the project. As I said, large enterprises such as banks and insurance companies use Java. It is because both technologies and skilled developers are expensive. Small companies generally cannot afford to use Java. I think there are fewer Java professionals on the market actively looking for work. 
#
By comparison, for example, it is much quicker to find a PHP expert than a Java specialist. Developers with more knowledge are either already working on projects or costing a lot of money. In addition, highly skilled Java professionals are often lured away by the banking and insurance sectors.
#
#### When do you recommend Java-based solutions to a client?
#
The first question I ask clients is whether they need a Java-based solution. I recommend Java when building a high-performance and high-traffic system with transactions between different services. And secondly, if there is already a Java specialist working at the company. If a company has never used Java, I usually do not recommend it.
#
#### You have also been active in the organization of the local Java community for many years. How did it start?
#
It all started around 2005 when we organized Java meetings for the first time. I founded the javaforum.hu professional forum, where users could ask Java-related questions. There was no such thing in Hungary at that time. 
#
Later, I started to organize Java meetings on the Meetup platform. A lot of members of the Java community came to these meetings. It was great because we had the chance to ask each other questions and the opportunity to develop professional contacts and thus building the local Java community. Often the speakers were also members of the community. We always tried to find a topic that many people were interested in and to choose a speaker who had practical experience in the field. These two factors ensured the success of these events.
#
#### What advice would you give young developers? What skills should they acquire that will help them in their career?
#
I see two fundamental problems for early-career developers. One is teamwork, and the other is problem-solving. The first is perhaps also a fault of education, as young graduates don't know how to work in a team. The second is that when they encounter a problem, they don't ask their more experienced colleagues and don't know how to solve it. I think these are two areas in which young developers need to improve. 
#
In the workplace, we never work alone but in a team with our teammates, so teamwork is critically important. In my view, this is even more crucial than the new colleagues' professional skills. In the case of professional knowledge, it is perhaps most vital that a novice developer has basic programming knowledge and is familiar with the functioning of a platform.
#


Auth Gabor interview v2.png

What trends do we expect in the next few years in Java? What technology do companies need besides Java? Is it easy to set up a Java team for a project? In this interview, we asked Gábor Auth.

In this series, we want to interview Java experts and ask them how their professional careers started. We also want to inquire them about the recent Java and software development trends. This time our interview partner was the Hungarian Java expert Gábor Auth.

Interview With Java Expert Gábor Auth 

#### Practice
#
Practice is one of the most fundamental parts of **leveling up** your coding skills. The more you code, the more familiar you'll become with the given programming language and the more confident you'll be. 
#
First, start with small projects and gradually work your way up to more complex ones. You should be consistent in your practice. Over time this will help you build your coding skills and develop your portfolio.
#
#### Learn a new programming language
Learning a new programming language can **broaden** your skillset and help you understand different programming paradigms. It can also help you see problems from **different angles** and find new solutions.
#
#### Read code 
Reading code written by others is a great way to learn new techniques and approaches to solving problems. You can find **open-source code** on websites like GitHub, and studying the code of experienced programmers can help you improve your coding. 
#
You need to pay attention to the design patterns, algorithms, and best practices used by other coders and try to incorporate them into your coding.
#
#### Challenge yourself
Participating in **coding contests** is a great way to challenge yourself and improve your skills. You can participate in online coding contests and hackathons to get **hands-on experience** and feedback from fellow coders.
#
It is a superb opportunity to work on projects with others, do networking, and learn from them.
#
#### Contribute to projects
Find open-source projects and **contribute** to them. It is a fantastic way to **give back** to the coding community and improve your skills. 
#
You may start by fixing bugs, adding new features, or writing documentation. Taking part in such projects helps you build your portfolio, enables you to network with other coders, and you can gain experience by working on **real projects**.
#
#### Follow experts
One easy way to **stay up-to-date** with new technologies and trends is to follow experts in the field. 
#
As technology constantly evolves, we must keep up with new developments. You can read **blogs** of well-known developers, attend tech **conferences**, and take online **courses** to stay updated.


Blog level up your coding v2.png

Whether you're just starting or have been coding for years, leveling up your coding is crucial. How to do it? We show you six ways to improve your coding and take it to the next level.

Coding is constantly evolving, so for coders, it's crucial to improve their skills continuously. Whether you're just starting or have been coding for years, leveling up your coding can pave the way to expertise, better teamwork, and greater job satisfaction in the long run. We collected six things you can do to level up your coding.

6 Ways to Take Your Coding to the Next Level

#### **The Problem**
#
In our scenario, one of our applications needed an **export-data-to-excel** feature. Probably many of us faced a similar demand in the past. The idea was to get a batch of data, transform it, and dump it into an Excel spreadsheet. 
#
The obvious solution is to implement this service as a timed one into your application. This method worked well with a small amount of data. However, once the dataset was **large enough**, the **application crashed**. Someone tried to export too much data at once, which resulted in a memory issue, which brought down the application.
#
#### What is the solution then?
#
Could we separate the service from the rest of the application? Where would you host such an app? Do you expand your current environment with another service? Do you set up a separate environment? Should it be serverless? Which technology should you use?
#
####  What if you decide to go serverless?
#
If you decide to go serverless with a service, the most crucial consideration will be the **cost**. AWS provides a popular hosting base, and costs are calculated by **resource usage** mostly. 
#
It fundamentally means the lower your CPU/RAM usage and the execution time is, the less you pay for the same service. Choosing the **right technology** is critical to optimize your Lambda execution times. Of course, you can go the traditional way and opt for Java, Python, or Node. There is, however, another alternative.
#
#### Is GoLang an option?
#
GoLang advertises itself as a language **built for the cloud**. Does this claim stand? We wanted to learn what the actual resource usage would look like for this specific **excel export** use case we had.
#
#### **The Use Case**
We received a bunch of data in JSON format and had to dump that in an Excel spreadsheet. Our previous solution was in Java, and once the input data **exceeded** a given threshold, the **application crashed**.
#
Our investigations concluded that it was a **memory issue**. If we had thrown a bunch of RAM into the configuration or optimized the solution, we could have most likely avoided the application crash.
#
We did not want to do that, so we considered moving toward a **serverless solution**.
#
#### The testing methodology
#
We generated an approximately 70Mb-large **JSON file** as an input (It is more than the maximum amount of data our service would ever receive) and wrote two sample pieces of code with roughly the same logic.
#
- Parse the input into a native JSON object
- Loop through the data
- Create an Excel file and a sheet
- Write the rows
- Write the file to disk
#
We wanted to make the playing ground somewhat even, so both services were **Dockerized**, and we measured the resource usage with docker stats. 
#
#### **Results**
As we see on the graphs, on average, the memory and CPU usage of GoLang was **half** of Java's.
![doland vs java 1.png](https://tis-tis-io-asset-prd.s3.eu-central-1.amazonaws.com/doland_vs_java_1_cb2a702b02.png)
#
![doland vs java 2.png](https://tis-tis-io-asset-prd.s3.eu-central-1.amazonaws.com/doland_vs_java_2_28522609ab.png)
#
Of course, the pattern of one programming language might not be the best for another. Sometimes language-native solutions work better for certain scenarios.
#
If your goal is to **reduce** your AWS Fargate or Lambda costs, we advise you to look at **GoLang**.


Blog cover Golang vs Java.png

What would you do when you need an external service for your cloud application? Which one would you choose that is capable of handling lots of data? Let's find out!

What would you do when you need an external service for your cloud application? Which one would you choose that is capable of handling lots of data? Could GoLang be an option? These are the questions we wanted to find answers to in our article.

Should You Use GoLang Instead of Java?

#### Used technologies
**Prisma**
#
It is a **next-generation ORM** for Node.JS with TypeScript support out of the box. It has large feature sets such as:
- migrating tool (Prisma Migrate)
- seeding support
- unique schema-driven data modelling (Prisma Schema)
- type-safe query builder with type generation (Prisma Client)
- database management tool (Prisma Studio)
- wide support of database management systems (Postgres, MySQL, MongoDB, AzureSQL, SQLite, etc.)
#
**Next.JS**
#
It is a **React framework** for building user interfaces. Nowadays, Next is one of the most popular frontend frameworks in the market due to its wide variety of tooling options including:
- internationalization
- image optimization
- server-side rendering (SSR) or static-site generation (SSG) for rendering pages
- built-in routing with file system
- API routes for writing server-side logic
- Middleware

#### Initialize the application
To **start the development**, we need to run a few important commands. First, we will set up a basic Next.JS app with Typescript, install the Prisma CLI and finally initialize a basic Prisma setup. If you like to skip these steps, please check the results in the repository. Please check the sources section at the end of the article for the link.
#
```bash
npx create-next-app@latest –typescript 
npm install prisma –save-dev 
npx prisma init 
```
#
The **npx prisma init** command created two files:
- schema.prisma: Created inside the prisma directory. We will cover its purpose later.
- .env: Here we have to provide a database connection string for our database.
#
#### The Prisma Schema
The prisma.schema is the **main configuration file** for our Prisma project. It consists of three main parts:
1. **Data sources:** Specify the details of the data sources Prisma should connect to (e.g. a PostgreSQL database)
2. **Generators:** They specify what clients should generate based on the data model (e.g. Prisma Client)
3. **Data models:** Specifies your application models (the shape of the data per data source) and their relations
#
Since we are building a small CRUD application to handle personal goals per user, the next step is to create the User and Goal models for it.
#
```javascript
generator client { 
  provider = "prisma-client-js" 
} 

datasource db { 
  provider = "postgresql" 
  url      = env("DATABASE_URL") 
} 

model User { 
  id        Int    @id @default(autoincrement()) 
  email     String @unique 
  firstName String @map("first_name") 
  lastName  String @map("last_name") 
  goals     Goal[] 
  
  @@map("user") // table name in the database 
} 

model Goal { 
  id          Int      @id @default(autoincrement()) 
  name        String 
  description String   @db.VarChar(255) 
  priority    Priority 
  user        User?    @relation(fields: [userId], references: [id]) 
  userId      Int?     @map("user_id") 
  
  @@map("goal") // table name in the database 
} 

enum Priority { 
  LOW 
  MEDIUM 
  HIGH 
} 
```
#
For further details about Prisma models, please, check the official Prisma site, where you will find detailed documentation about data modelling.
#
The only thing missing is to run the following command:
#
```bash
npx prisma migrate dev 
```
#
This will generate a migration file and update our database.
#
#### Client-server communication
Our tables have been created. Now we have to fill them with actual data. The **Next.JS built-in API routing system** will help with that because, with it, we can easily write code that’s running on the server. The only thing remaining is to use the query builders. For that, we need to install and instantiate a Prisma Client with the following command and code snippet:
#
```bash
npm install @prisma/client
```
#
```javascript
import { PrismaClient } from '@prisma/client' 

export const prisma = new PrismaClient() 
```
#
Important note: The name of the PrismaClient is a bit misleading since we cannot use it on the client side. It must run on the server. Please avoid calling it directly inside lifecycle methods or side effects.
#
Let’s create the **API endpoints** on the server by creating the following files under the api directory and use the prisma provided query builders for CRUD operations inside them. If you don’t want to add an extra API layer, it will be fine to use the query builders with server-side rendering (SSR) and static-site generation (SSG).
#
-	POST /api/goals/create (create.ts):
#
```javascript
const { name, description, priority } = req.body 
const user = await prisma.user.findFirst() 

const result = await prisma.goal.create({ 
  data: { 
    name, 
    description, 
    priority, 
    user: { connect: { id: user?.id } } 
  } 
}) 
```
#
-	GET /api/goals (goals.ts):
#
```javascript
const goals = await prisma.goal.findMany()
```
#
-	GET /api/goals/{id} ([id].ts):
#
```javascript
const goalId = parseInt(req.query.id as string) 

const goal = await prisma.goal.findUnique({ 
  where: { id: goalId } 
}) 
```
#
-	PUT /api/goals/{id} ([id].ts):
#
```javascript
const goalId = parseInt(req.query.id as string) 

const { name, description, priority } = req.body 
const goal = await prisma.goal.update({ 
  where: { id: goalId }, 
  data: { name, description, priority } 
}) 
```
#
-	DELETE /api/goals/{id} ([id].ts):
#
```javascript
const goalId = parseInt(req.query.id as string) 

await prisma.goal.delete({ 
  where: { id: goalId } 
}) 
```
#
Note: Please check the repository for the full code
#
Last, we have to call these **endpoints** on the pages. We will use server-side rendering (SSR) for fetching goals and client-side logic for deleting one, but the choice is up to you since Next.JS supports various rendering options. Create a goals.tsx file under the pages folder and write the followings there:
#
```javascript
interface GoalsProps { 
  goals: Goal[] 
} 

const Goals: NextPage<GoalsProps> = ({ goals }) => { 
  const router = useRouter() 

  const handleDelete = useCallback(async (goalId: number) => { 
    try { 
      const res = await fetch(`/api/goals/${goalId}`, { 
        method: 'DELETE', 
        headers: { 
          'Content-Type': 'application/json' 
        } 
      }) 

      if (res.ok) { 
        router.replace(router.asPath) 
      } 
    } catch (e) { 
      console.error(e) 
    } 
  }, []) 

  return ( 
    <LayoutBase> 
      <Grid container direction="column" spacing={2} sx={{ my: 4 }}> 
        {goals.map((goal, index) => ( 
          <GoalItem goal={goal} key={index} onDelete={handleDelete} /> 
        ))} 
      </Grid> 
    </LayoutBase> 
  ) 
} 


export const getServerSideProps: GetServerSideProps = async () => { 
  const response = await fetch(`${process.env.NEXT_PUBLIC_API_URL}/api/goals`) 
  const data = await response.json() 

  return { 
    props: { 
      goals: data 
    } 
  } 
} 
```
Note: Check the repository for the other pages and components.
#
#### Conclusion
Now we have a **fully functioning full-stack Next.JS application** using Prisma for database operations. 
Next.JS & Prisma stack is a perfect option if you need a relatively small full-stack application without any complex logic, with minimum configuration, and using the same language for the server and client.
However, if you need a more complex application, you should look for a better and more battle-hardened alternative.

#### Sources
-	GitHub repository: [https://github.com/olahz96/next-with-prisma](link)
-	Prisma: [https://www.prisma.io/](link)
-	Next.JS: [https://nextjs.org/](link)

Blog cover Next js & Prisma v2.png

Do you want to create a full-stack web application by applying minimum configuration and using only one language, TypeScript? If your answer is yes, please read on!

Have you ever had trouble choosing the right tools for your full-stack web application? Well, you are not alone. In this blog post, we will show you how to build a full-stack web application with minimum configuration and using only one language, TypeScript. We will create a simple CRUD app using Next.JS for frontend/backend and Prisma ORM with PostgreSQL for database operations.

Build Full Stack Apps With Next.JS and Prisma


#### The Reason
#
The **main reason** we wanted to change was that Postgres had **better support** for handling geographical data, such as coordinates, polygons, and distance calculations. Because of our CI/CD pipeline, some parts of the code had already been released to production, and a lot of data (more than three million addresses) had been created. That's why we couldn't just change the database engine and continue the work on the features.
#
#### The Problems
#
The **first issue** was with Postgres, which uses strict types. It means the BOOLEAN is a boolean, not a TINYINT. So during the data migration, we faced a lot of incompatible data types that we had to fix. In Postgres, we have no autoincrement ID, we need to use sequences. Which is about the same. We can use more sequences in one table or the same sequences in several tables. This can be a huge benefit.
#
The other side effect of being strict is that trying to modify tables that have view defined for them cannot automatically be done. Postgres will give a "cannot alter the type of a column used by a view or rule" error, while MySQL will automatically modify the dependent view. The solution was to drop the view before the change and re-add it after.
#
The **second issue** we faced was that in many tables, we use enums to limit the number of choices a value can take. In MySQL, there is no enum type. It employs constraints to limit the values. When using the same enum in more than one place and we have to change the enum values (add or remove values) during development, we will also have to touch every table with the constraint. In Postgres, we can create our own ENUM types such as CREATE TYPE mood AS ENUM ('sad', 'ok', 'happy'), and after that, we can use them in every place where we need them. If we need to expand them, we can do it in one place only.
# 
The **third issue** was not related to Postgres itself but to Doctrine. As we mentioned earlier, Postgres uses strict types. However, with the default Doctrine settings, we cannot use the same queries without converting the parameters to the right type. For example, if we want to make a search query with LIKE, we cannot search for a string in an int column. We need to cast it manually. There are several packages available that we can use to solve this. During the process, we used the following one: https://github.com/opsway/doctrine-dbal-postgresql
# 
The **last issue** we would like to touch on is collation. On many pages, we have search functionality, and of course, we use LIKE in the query to be able to search. In Postgres, however, special characters are not normalized. Let's see an example. If we search for an address on Rue d'Amérique and our search term is Amerique, Postgres can't find it. In MySQL, it wasn't a problem at all. The engine could do normalization out of the box. To solve this issue, we had to use the officially bundled unaccent extension and the UNACCENT function in the queries.
#
#### The Conclusion
# 
Fortunately, Postgres is an **excellent tool**. The issues we faced weren't huge problems. However, we may experience different behaviours compared to MySQL if we have no or only limited experience with Postgres. It is also true when we use raw queries instead of an ORM. If we compare the two, Postgres has much more flexibility and because of the strict types is a little bit safer than MySQL.


Blog cover MySql vs Postgres.png

Why did we switch from MySQL to Postgres? What challanges did we face during the process? Please click the button bellow and find out more.

Usually, when we start working on new software development, we determine the technologies and tools we use during the requirement phase based on business logic. 
#
Sometimes, however, we must replace or change one or more of the tools during development. It's because the requirement changes or for some other reason.
#
In this short post, we want to point out some issues we faced in one of our projects when we switched the database engine from MySQL to Postgres.

Challenges of Switching From MySQL to Postgres

#### So, Norbert, what do you do at the company exactly?

I'm mainly working on the backend side integrating different kinds of cloud-based solutions and external systems to our custom solutions and also managing projects.



#### Let's talk about some personal things first and get you to know better. If you could have a superpower, what would you choose?

It would be definitely speed. We all experience sometimes that we don't have enough time for all the things we like or we can't stop to enjoy all the little things more. So I would choose the speed to do my tasks in half a day and spend the rest of the time enjoying other things.



#### What are these things that make you happy and would like to spend more time at?

For example, cooking. I love creating meals and of course, eating them! The whole process of doing the dish and tasting can always improve my mood. My favorite dish is cheesy chicken pasta.



#### Let's move to your professional side. What are the best sides of your job?

Software development is like playing lego. Imagine that you put all the blocks together, you get one big object and you see that it looks like you expected. Software development is just like this and it's the best part of it for me. When you put the whole system together and you see how much value it generates for the customers, how much complexity it has, how easily it can solve different problems without any kind of manual intervention. After weeks of work, everything comes together and you see the whole picture, it's thrilling.

#### What is your language of choice?

I've been mostly working in Java for the past five years and what I like the most is how simply you can create an application. All the community projects behind it made it so easy that you can just spin out an application in 5 minutes and start working on what actually matters, not just the stuff behind the scenes.



#### And what is your favorite framework and why?

I have some experience with different frameworks like the Java Enterprise known as Jakarta and I've worked with OSGi as well. However, for me, the Spring framework is the one I like the most because of how extensive it is and how simply you can do both basic and more complex things as well. It's integrated into almost every major framework or external system.
#
In case you need a newly established database connection, the community will have some kind of development of it in a short time and you will have an experimental version of that specific connector.



#### What tips do you have for someone who wants to become a software developer?

Always try to understand the problem. Once you do it, you know what the solution will be. If the issue just gets resolved, you cannot be sure that it actually works properly.

Norbi Blog Post 2.png

Norbert joined us almost a year ago as a Java developer. Now he shared his thoughts about this past year and some interesting personal details as well.

In our TIS talks series, we introduce our team members and give you some insights into their personal and professional lives!

Norbert joined us almost a year ago as a Java developer. During this year he's been working on numerous projects in different roles and now he shared some detailss about his professional and personal life as well.

TIStalks #1

In this article, I assume that you (the reader) have some background knowledge about NodeJS, React, and Typescript.
The goal of this blog is to show how we can kick off GraphQL using these technologies without deep-diving into them.
#
To keep it simple we only focus on the App and Server communication which is created using GraphQL instead of REST.
GraphQL is able to send data through HTTP too, but it is not mandatory. As you’ve already figured it out we will 
leave the classical database part out and in our case, this is an in-memory solution. 
Just note that it will reset on every server rerun. Let’s begin.
#
_Side note: You can jump over all the explanations and run the finished app that can be found at the end of the article._

### What is GraphQL?

Your first thought must be **“What is GraphQL?”**. GraphQL is a query language for APIs which provides a complete and understandable description of the data. It has the ability to give the clients the power to ask for all the data they want and nothing more.
#
I was not telling the full story when I stated that it is used instead of REST. However, in my implementation
this is true but not in many other cases. For real, GraphQL is a new layer in your architecture that can hide
many data sources like REST APIs, MongoDb or PostgreSQL connections, etc. behind a single point of truth: one endpoint.
The client can get all the data it needs in a single request.
#
GraphQL APIs are organized in terms of types and fields, not endpoints. So it uses types to ensure clients only ask for
what’s possible and they provide clear and helpful errors. Apps can use types to avoid writing parsing code manually.
#
Okay, now you get the idea. We will use a GraphQL library for the server and for the app. It’s called **Apollo**.

### The Server
#
This backend is easy and can be implemented in one single **index.js** file. To start the project just create a
directory with your preferred name and run the following commands:
#
```bash
mkdir into-graphql-server
cd ./into-graphql-server
npm init -y
npm i --save apollo-server graphql nanoid
```
#

#### Type definitions and database
#
To begin with, we have to define what kind of data-, query- and mutation types can be provided by the server. The data
type is clear. But the other two will need some explanation. GraphQL calls any request that asks data from the backend a **query**. 
And **mutations** are used as the rest of the operations from the CRUD, these are the requests that create, update or delete resources.
#
```javascript
const typeDefs = gql`
  enum TodoItemStatus {
    IN_PROGRESS
    DONE
  }

  type TodoItem {
    id: String
    value: String
    status: TodoItemStatus
  }

  type Query {
    items: [TodoItem]
  }

  type Mutation {
    createTodoItem(value: String!, status: TodoItemStatus!): TodoItem
    updateTodoItem(id: String!, status: TodoItemStatus!): TodoItem
    deleteTodoItem(id: String!): TodoItem
  }
`
```
#
For example, our database is just a javascript array with values. It is built-in and knows CRUD out-of-the-box.
#
```javascript
const todoItems = [
 {
   id: nanoid(),
   value: 'Test todo item 1',
   status: 'IN_PROGRESS',
 },
 {
   id: nanoid(),
   value: 'Test todo item 2',
   status: 'DONE',
 },
]
```

#### Resolvers

Type definitions tell us and the IDE information but they don't exactly explain how they should work.
This is why resolvers exist. They include how to *query* and *mutate* the data and where the data can be found.
#
```javascript
const resolvers = {
  Query: {
    items: () => todoItems,
  },
  Mutation: {
    createTodoItem: (parent, { value, status }) => {
      const newTodoItem = {
        id: nanoid(),
        value: value,
        status: status,
      }
      todoItems.push(newTodoItem)
      return newTodoItem
    },
    updateTodoItem: (parent, { id, status }) => {
      const updatedTodoItem = todoItems.find((item) => item.id === id)
      updatedTodoItem.status = status
      return updatedTodoItem
    },
    deleteTodoItem: (parent, { id }) => {
      const deletedTodoItemIndex = todoItems.findIndex((item) => item.id === id)
      const deletedTodoItemCopy = { ...todoItems[deletedTodoItemIndex] }
      todoItems.splice(deletedTodoItemIndex, 1)
      return deletedTodoItemCopy
    },
  },
}
```

#### Setup and start
Last but not least, we have everything to boot the server up with some configuration and a method call.
#
```javascript
const server = new ApolloServer({
  typeDefs,
  resolvers,
  csrfPrevention: true,
  cache: 'bounded',
})

server.listen().then(({ url }) => {
  console.log(`🚀  Server ready at ${url}`)
})
```

### The App
To finish our application let’s talk about the other side of the HTTP, the React application that we will create to be
the UI to show to-do list items, and it lets us interact with them. With these few commands to run you’ve got a base
skeleton of the app:
#
```bash
npx create-react-app into-graphql-app --template typescript
cd ./into-graphql-app
npm i --save apollo-client graphql
```

#### Type definitions
This may be familiar from the server. We have written some type definitions for the GraphQL that are actually needed
here too. It can be shared via some library or monorepo but as I mentioned I chose an easy-to-create but
more-difficult-to-maintain way. I copied those types.
#
```typescript
 const typeDefs = gql`` // Same as the Server
```

#### Apollo Client

Similarly to the Apollo server, the client has to be configured the following way:
#
```typescript
const client = new ApolloClient({
    uri: 'http://localhost:4000',
    cache: new InMemoryCache(),
    typeDefs,
})
```

#### Provider
Because this is a React app we should let React know about the Apollo Client that was configured above through the help of a provider.
#
```typescript jsx
root.render(
  <React.StrictMode>
    <ApolloProvider client={client}>
      <App />
    </ApolloProvider>
  </React.StrictMode>
)
```

#### The CRUD

And here is the fun part. We’ve arrived at where we are able to run queries and mutations _(and subscriptions but we skip those this time)_ against that single endpoint. We will use React hooks from the Apollo Client library called useQuery for the queries and useMutation for the mutations. These hooks take two parameters, one GraphQL query, or mutation and one configuration object. UseQuery gives back an object containing the data or error and a loading boolean value. At the same time, useMutation gives back an array that contains the mutation function that we need to call with parameters, and a similar object to useQuery's returned value as the second value of the array.
Let me show you how:

#### Create
```typescript
const [createTodoItem] = useMutation<TodoItem>(
    gql`
      mutation CreateTodoItem($value: String!, $status: TodoItemStatus!) {
        createTodoItem(value: $value, status: $status) {
          id
          value
          status
        }
      }
    `,
    {
      refetchQueries: ['GetTodoItems'],
    }
  )
```

```typescript
await createTodoItem({ variables: { value: trim(value), status: TodoItemStatus.IN_PROGRESS } })
```

#### Read
```typescript
const { loading, error, data } = useQuery<{ items: TodoItem[] }>(gql`
    query GetTodoItems {
      items {
        id
        value
        status
      }
    }
  `)
```

#### Update
```typescript
const [updateTodoItem] = useMutation<TodoItem>(
    gql`
      mutation UpdateTodoItem($id: String!, $status: TodoItemStatus!) {
        updateTodoItem(id: $id, status: $status) {
          id
          value
          status
        }
      }
    `,
    {
      refetchQueries: ['GetTodoItems'],
    }
  )
```

```typescript
await updateTodoItem({
    variables: { id: item.id, status: item.status === TodoItemStatus.DONE ? TodoItemStatus.IN_PROGRESS : TodoItemStatus.DONE },
})
```

#### Delete

```typescript
const [deleteTodoItem] = useMutation<TodoItem>(
    gql`
      mutation DeleteTodoItem($id: String!) {
        deleteTodoItem(id: $id) {
          id
          value
          status
        }
      }
    `,
    {
      refetchQueries: ['GetTodoItems'],
    }
  )
```

```typescript
await deleteTodoItem({ variables: { id: item.id } })
```
#
You may notice that configurational object with one property in mutations. RefetchQueries is an array of objects referencing queries 
_(DocumentNode objects parsed with the gql function)_ or an array of names as strings of queries you've previously executed. 
By including this, it lets your app refetching certain queries after a particular mutation. **GraphQL does not do refetching by default.**


### Experiences
GraphQL is different in many aspects of the way we use REST APIs. For example, the use of only one endpoint would seem strange instead of many, and that we have type definitions instead of a swagger document.
#
Requests are specified in a specific language in contrast to REST’s query parameters, path variables, and JSON objects in their body. And we have not talked about the responses yet. Responses via HTTP using GraphQL always gives back HTTP 200 status code _(and sometimes not but this is not GraphQL's fault)_. These other status codes may indicate other problems with the server or the communication channel.
#
What if GraphQL gives an error? It sends an error property within a JSON object that clearly explains what exception
occurred. So it doesn’t rely on HTTP, and it is not as verbose in that way but in every system, it always works the same.
Which is good, to be honest.

#### Conclusion
At the end of the day it doesn't matter if your system will use GraphQL or REST APIs. They can serve the same purpose.
Both have advantages and disadvantages that can help you vote for one or the other. However, I can tell that it was quite
easy to pick up GraphQL to start a new project with it. Of course the Apollo libraries were handy and they boosted the
implementation. Let's be honest, when was the last time we created something purely using the feature set of the
languages?
#
GraphQL is different from REST, and it can be unusual for those who have never used it before. But every tech stack
has its own rules that we can learn and understand. If we are able to abstract its rule set from REST’s then GraphQL
could be a pretty great tool in our arsenal.

#### Finally*

*References

[https://github.com/gabemiller/into-graphql-app](https://github.com/gabemiller/into-graphql-app)

[https://github.com/gabemiller/into-graphql-server](https://github.com/gabemiller/into-graphql-server)

GraphQL.png

What do we need when we want to create a simple web app in 2022? How can GraphQL help us in this?

What do we need when we want to create a simple web app in 2022? We need a client side application, a server and some kind of database. Quite simple, right? Nowadays, these layers are essential to provide a marvelous experience to all the people who will become users of our app. What's the app actually? I will go as classic as possible. Yes, it will be a To Do app!

How to Use GraphQL With React

#### Business problem: How to Manage Data Efficiently?

One of our clients needed a way to manage their sales process efficiently. What does this exactly mean?
#
First and foremost, they needed a platform that enabled them to enter data into a form with the option to leave things and continue them later. Second, there are numerous external data sources that the agents used to look up data manually for the customers. Integrating these could help them work faster, hence increasing productivity. These integrations rely on the data entered by the user, so data consistency during the process is a must-have.
#
#### Goals and Requirements
#
The business problem clearly described that we needed a **sales workflow**. Each step had to be executed in a specific order. If a previous step is edited, the data entered afterward could not be trusted anymore. But how do we store this?
#
Mixing partially completed and consistent data in persistent storage is not the best idea because it is hard to differentiate them. Managing and maintaining these from the data and code perspective is both uncomfortable and unreliable. 
#
We had to look at what the industry had to offer. The main issue with the available workflow engines that are currently on the market is the ability to adapt to changing software. Even a minor change in the flow itself can cause data loss, technical debt, or inefficient development in the longer term.
#
The **requirements** were collected:
- The solution needs to be resilient and easy to scale to match the load that is on the system.
- The sales process has to be flexible: if they are interrupted, they can be picked up where there were left off.
- If an external data source is not available, any automated step needs to have the option to be retried at a later point without data loss.
- Implementing changes needs to be supported.
#
#### Solution: Uber's Cadence
#
This is how [Uber’s](https://www.uber.com/) solution, [Cadence](https://cadenceworkflow.io/) came into the picture. As their food delivery service relies on this, it has been proven to be working on a large scale.
#
The engine is implemented in Go which is famous for its speed and reliability. It does not require a lot of resources. During mealtime, they are experiencing similar usage peaks to what we can expect in our application. The company was kind enough to make the code publicly available and free to use, even commercially. They are also offering SDKs in Go and Java. This later turned out to be a great candidate.
#
##### **But I hear you ask: “How does this work?”**
#
The core concept is how your application can communicate with the workflow. As a part of your workflow implementation, you can create custom **signals**, which can change the state of the workflow, and process any data that can be represented in JSON format. The only point of storing data somewhere is if you can access them. **This is what queries are for.** The queries in a workflow can access the workflow state, read, transform and return the data stored in it.
How to get started with Cadence?
The SDK provides the following things to implement to interact with your workflow implementation: 
#
##### Workers
#
A Cadence worker is responsible for executing the workflow and storing its data in memory. It does not have to be publicly available; it only needs access to Cadence. If you register multiple workers, the workflow engine will act like a broker and delegate tasks to a preferred worker host. 
#
##### Client
#
A workflow client can expose the workflow for your application and it can send signals and queries to the workflow.
#
##### Activity
#
A chunk of code that can wrap the integration of external data sources, rapidly changing data or any part of the system where deterministic execution cannot be guaranteed.
Once a workflow is started, its state is stored in the worker process’ memory, hence it is quick to access. Any active workflow can be stored in the memory, their data can be retrieved from there. To achieve this, the workflow engine needs to have a sticky execution policy, and a workflow instance needs to be tied to a worker host. 
#
##### But what happens when a usage peak ends and the worker process is terminated?
#
As I have mentioned previously any kind of data that is represented as a JSON document is something Cadence can cope with. The workflow engine notices that the worker has gone offline and looks for another available worker. For every so-called **side-effect **(collective phrase for signals and activities which can alter the workflow state), the parameters are serialized and stored in the Cadence workflow history. When a worker gets an existing but unknown workflow execution, it takes the whole history and reiterates it, replaying every signal that happened previously. To achieve this, the workflow must be deterministic. Every external integration needs to be persisted in the workflow history so a replay can restore the workflow state. The parameters and the result of every activity are also stored and the activity implementation is not invoked during the replay. The same goes for every side effect.
#
#### Our solution
#
We have created a Spring Boot-based application, integrated with Cadence. A sales flow is started by an agent, a snapshot is made of the prices stored in the application. This way, no data change in the system will affect the running workflows. Every field for the agent is required to fill in and ends up in a signal, which can trigger activities in the background if needed. The result is presented to the user, indicating a successful operation.
#
#### Drawbacks
#
There is no perfect solution, Cadence does not come with a caveat either.
As the base concept of Cadence is that its workflows need to be deterministic and reproducible, every change made in the implementation needs to support this concept. Cadence has the tool to create a version flag and run a different code branch in case of a new version is executed. Once the old executions are terminated/completed, these branches can be removed. This creates a technical debt; the legacy code needs to be maintained and rolled out later. The developer also needs to keep in mind if a change is backward compatible, as it may break existing flows.
#
#### The future of Cadence
#
There is an improved version of Cadence, which is maintained as a separate project, called [Temporal](https://temporal.io/). The concept is the same, although there are some major internal differences. Here is one of Temporal co-founder's thoughts on this topic: https://stackoverflow.com/a/61281435. Upgrading from Cadence to Temporal is almost like a version upgrade of Cadence for your codebase. Changing the engine itself is a more radical change, there is no way to migrate data from Cadence. If you need to support the existing flows, you need to consider your options.
#
#### Summary
#
Despite the flaws, Cadence brings to the table, working with it turned out to be effective both for the developer team and the end customer. Automating the collection of data, so the agents can see these all at once, increased their productvitity. The time of creating one sale with this tool has been reduced from almost 1 hour to 10 minutes.



Cadence 469x224.png

Struggling with creating a sales tool? Don't know how to create resilient and scalable solutions? Here's how we managed these!

The market is full of workflow engines that are perfect for specific systems, either because they are tightly integrated into it or because they are designed for one specific use case. There is no universal solution that fits all needs. Of course, building something from scratch is not always an option either. Here is how we managed to overcome this challenge at The IT Solutions.

How to Make a Sales Tool?

**Patrik, how long have you been programming in PHP?**
#
I've been programming in PHP for about 20 years. 
#
**And what do you think of the current status of PHP compared to other programming languages?**
#
It is often said that the PHP programming language is dead and it's a relic of a bygone era. There was a time when I didn't think I would use it on new greenfield projects anymore for a number of reasons, such as its speed and lack of language tools. Since then, however, it has changed a lot for the better and, although, like all languages it has its downsides, it has now become quite obsolete.
#
**You mentioned that there was a time when you though that you might never use it on new projects. When was this?**
#
Yes, there was a time when I was burying it and planning to switch to another language with whole large systems. This was around 2018 during the time of version 5.6, which was crowned by the finally unborn version 6 (there is an article about this version if someone hasn't come across the story: [https://phil.tech/2013/php-6-pissing-in-the-wind/](https://phil.tech/2013/php-6-pissing-in-the-wind/) ). 
After that a big positive change happened with PHP. Starting with version 7 they fixed the performance issues which was a major milestone. Many companies have continued to develop in this language because of this.
#
![php version benchmarks.png](https://tis-tis-io-asset-prd.s3.eu-central-1.amazonaws.com/php_version_benchmarks_6bbc6bc2b2.png)

#
**If the new versions became way better, what are the properties that still withhold programmers from learning or using this language?**
#
A common accusation against PHP is the quality of applications. The ease of use of the language is a double-edged sword. Unfortunately, as we are talking about the easy-to-use, dynamic language, in the wrong hands this does indeed give room for poor quality, but it doesn't have to be that way. Today, quite a few even large projects take code quality seriously and thanks to new versions of PHP, it is now possible to work both professionally and comfortably. More and more people are getting familiar with the language elements introduced by the new versions, which allow to work efficiently but cleanly, such as type hints, typed properties, return type declarations, enums, etc.
#
**How do you think the attitude towards PHP could be improved?**
#
I think it is important to renew the community. The old CMS-like "hacked" developments like WordPress, Drupal are increasingly being replaced by framework-based work, with Laravel being the most important flagship of the moment. Laravel's developers have not only created a modern and convenient framework but have also used its popularity to put pressure on the PHP world to upgrade to newer versions. This pressure has led to an extraordinary pace of development in the PHP ecosystem, which is still visible today.
#
**So, in conclusion, what would you say about PHP as it is now?**
#
It is undeniable that PHP has its drawbacks, but this is true for any programming language. After all, we need to know what to use it for. What is certain, however, is that today it is a language that can be used for professional work, and that comes with a thriving ecosystem and community.
#
If you are interested in the history of PHP, check out this [25th anniversary page](https://www.jetbrains.com/lp/php-25/) courtesy of JetBrains.


PHP.png

According to the worldwide ranking of programming languages, PHP is taking the sixth place. If it's the case, why most of developers prefer other languages to it?

Oftentimes we hear that PHP is outdated and software developers prefer other languages to it. 
#
Is this true? 
#
Can a programming language become outdated?
#
To find answers to these questions, we interviewed one of our experienced PHP developers Patrik Rozgonyi.

PHP in 2022: Outdated or Reloaded?

#### Background

In one of our current projects we are working on building a complex application used for optimizing district heating networks using AI. These heating networks cover areas of various sizes in a given city and can serve thousands or even more end-users with hot water supply.
#
The main goal of the application is to optimize these large networks to save energy and thus save money for the energy companies and the end-users as well. It also presents a bird’s-eye view of the network’s status for the operators through a nice web interface. 
#
**In this post, you can read about a couple of tips and tricks that we used in our backend application to improve performance.** This is a Spring Boot application, mainly using PostgreSQL DB, but the mentioned ideas can be used with other technologies as well.


#### The challenge

We set up the following goals for the project:
- AI optimization;
- showing the network live.
#
Reaching these is only possible when a **large amount of data** is available. The optimization also needs to happen live, because it has to react to current circumstances as soon as they change (e.g. weather).
#
To achieve this, there are a lot of sensors set up throughout the network, which transmit live data about temperature, pressure, flow, etc. The frequency of the data depends on the network,  but it can range from hundreds of data points to hundreds of thousands of points every minute.
#
Storing this data efficiently and serving them to the various consumers (the frontend, the AI services) can be challenging.


#### Proof of concept and the first problems

The application was **initially created as a POC** (Proof of Concept). The purpose of this was to demonstrate that the various ideas and technologies can work together as imagined and it is worth continuing the efforts towards building the application.
#
By nature, a POC is usually not a very well-optimized solution, but rather something that does the minimum that is required to prove that the concept works. Our team managed to deliver this POC on time, but due to tight deadlines, there was not enough time to do many optimizations.
#
Initially, this was not an issue, because the networks were relatively small and the amount of data flowing into the application was rather small. However, as bigger networks came, more data started to flow. When mdata collected through several months started to rack up in the database, we started to experience performance problems.


#### The Tale of the Boiling Frog

**Performance issues that are getting worse over time can be very sneaky.** In the beginning, you might not even notice them, because it’s hard to tell the difference between for example 1.5 and 1.8 seconds of response time for a certain page or API call.
#
If you are lucky, after some time you start noticing that the app feels sluggish and requires some attention, but in other cases, it can manifest itself in more extreme ways.
#
Our application uses WebSocket messages to send updates from the Backend to the Frontend. These updates in certain cases can happen fairly often (e.g. every 5 seconds). If the Backend takes less than 5 seconds to serve the data, then everything is fine. In our case, however, as more and more data were stored in badly-indexed tables, querying the required data started to take more than 5 seconds. This resulted in queries overlapping and slowing each other and eventually overloading the database when our application was heavily used.
#
Besides this, there were other smaller impact performance problems throughout the application that also made it uncomfortable to use.
#
We quickly realized that performance required some serious attention.
#
I also hope, that the title can start to make some sense now: https://en.wikipedia.org/wiki/Boiling_frog.
#
#### **So how to avoid these kinds of problems and improve performance?**


#### Tip 1: Set up proper monitoring

One of the most important things that we did wrong was not having **proper monitoring** in place for our application, so we were basically flying blind.
#
We had basic alarms provided by AWS for our instances, but during these performance issues, the CPU / memory / etc. usage might not climb high enough for these to be triggered.
#
It is very important to **set up proper monitoring** (e.g. with Grafana) for any application that represents a lot of business value. Without monitoring it’s often very hard to notice if performance starts to degrade and actions should be taken. If there isn’t a lot of time for implementing monitoring, then at least some basic scenarios should be covered, making sure that we can at least notice the serious issues.

#### Tip 2: Use database indexes

When working with large amounts of data, it is very important to use **proper indexes** on the database tables. Unfortunately, we were missing some and it resulted in many extra hours of work a few months later.
#
You might not feel the need for indexes when your tables are small and have only a couple of thousands of records. However, adding proper index(es) to tables for the more common use cases is almost always a good idea. It might not matter in the beginning, because it only saves a couple of milliseconds, but as the table grows to the millions of records it will become essential.
#
Adding an index initially is always much easier than adding the index later. In our project, we needed to add indexes to 50GB+ tables across 10-20 databases. It required significant preparation to have minimal impact on the production environments and to make sure that the DB can handle the creation of these (in our case, small instances ran out of temporary storage needed for it). In contrast to this, if we would have added the indexes in the beginning, we could have saved a lot of time.

#### Tip 3: Examine concurrent job executions

We are relying heavily on scheduled jobs in our backend. These provide data to the AI modules, and also these serve the updates to the users’ screens via WebSocket communication.
#
When setting up the scheduling of jobs, always make sure to examine if they should be allowed to run concurrently or not.
#
Let’s say you schedule a job to run every 5 seconds, but the job takes 15 seconds to execute, because of unexpected performance degradation. If you allow it to start parallelly, you will have around 8 instances of the job running after 1 minute.
#
There are different ways of preventing this, depending on the technology. For example in the Quartz Java library, we can use the [DisallowConcurrentExecution annotation](https://www.quartz-scheduler.org/api/2.3.0/org/quartz/DisallowConcurrentExecution.html).

#### Tip 4: Build a dynamic data aggregation solution

In our application we needed to display various charts over various timeframes. If you have a large enough timeframe, you can easily reach a point where it is not practical to display each data point.
#
Let’s think about a simple time-series chart that displays the temperature for the last week. If we are getting sensor readings every minute, that would mean that we have 10080 data points for that chart. It makes no sense to try to cram that many points on a single chart, because no user would be able to differentiate that many. Also, transferring that many data points takes a lot of time and slows down the application.
#
**To solve this, we have built a dynamic data aggregation solution.** When we are receiving data, we are not just storing it, but also calculating/updating aggregates for various time periods. Thanks to these aggregates, when large charts are populated, we don’t need to query thousands of data points from the original data, but can just use much fewer data points from these aggregates. We have also implemented an easy to use JSON configuration for this, so we can adjust the aggregation based on the situation easily.
#
By the way, aggregation here can mean several things depending on the situation. It can be average, summary, etc. of the data points.

#### Summary

As you can see, there are several ways to speed up your applications. Of course, this is not a complete list, but these were actual solutions that we implemented in our project and they made the performance and quality of our application much better.
#
Of course, we should not lay back and stop here, because there are many more improvements we can make in the future. For example:
- Use data archival to keep the active data sets small.
- Use a standard real-time streaming solution for streaming and aggregation.
- Use data compression.
- For very large networks, only load data that is in the user's current view.
#
**When setting up a new project, always think about the possible future performance issues** that can happen due to increased traffic, data, or usage. By implementing some small improvements, you can save a ton of time in the long run. But of course, also make sure that you are not spending too much time on premature optimization when it is not needed. 


Boiling Frog.png

Building applications that contain large amounts of data is always challenging. How to act when such applications become slower and performance problems occur?

Building applications that contain large amounts of data is always challenging. Such applications tend to become slower when huge amounts of data flow in, and also performance problems can occur. 
#
If you are wondering what to do to avoid these, we have a few tips down below!

The Tale of the Boiling Frog or How to Improve Performance in a Data-Heavy Application

Well, unless someone wants to apply for a university program, one of the ways to start exploring this profession is by doing **online courses**. Due to the growing number of these, learning how to program has never been easier. Udemy, Coursera, Skillshare, and other online platforms offer different courses on programming languages, both frontend and backend.
#
Based on recent GitHub statistics, **nearly 300 different programming languages** are available to developers today. Of course, many of these can be excluded due to their lower number of users, but there are still plenty of them left such as Java, Javascript, Node JS, PHP, C, C ++, Python, etc. Considering this, a beginner has quite a large lake for fishing. With this in mind, you may wonder why so many have appeared, but first let's see what a programming language is.

#### What is a programming language?
A **programming language** is a set of commands, instructions, and other syntax rules used to create a program. Due to the rapid technological developments, not only the hardware on which our software runs has improved extremely, but the languages have also been significantly improved and in some cases even completely replaced.

#### Why do so many languages exist?
The first viable explanation for the creation of new languages is the **evolving needs of the industry**. Despite the desire to have a universal language for all projects, for the moment this is not possible and therefore we must compromise between productivity, generality, and performance. Due to this, as new technologies appear in the industry, new languages are created which are better tailored to specific technologies, e.g. the public emergence of machine learning and data science. This newly adopted technology has called for languages such as R to be developed specifically for this type of product.
#
Not only do new technologies bring new languages but new **companies have the same effect.** As the various tech giants continue to compete for more customer attention, they push their own languages into the market to draw consumers away from other companies. To see this, we don't need look further than the largest mobile OS-oriented languages Swift and Kotlin. Apple, as the best example, in its quest to restrict their buyers to their products, created their own objective-C-based language which can only be used on their products and has disallowed most others from being used on IOS.
#
**New programming techniques** harbor the same effect. Think of the for loop. It used to be a while loop with a counter but then someone realized it would be better to just create a new type of loop. The same happens with every paradigm. Another example is object-oriented programming. We often see that some languages are referred to as “object-oriented” while some are not. Whenever we think of a new method for solving a problem, it creates an opening for a language adapted to this method.
#
The next reason is the **evolution of hardware**. As hardware evolves, new languages are developed because old ones will need to be completely rewritten to meet industry standards. An example of this was the switch to C from B which took place in the 1970s, and although we cannot see much of this happening today, it is something that will happen eventually, especially with the projected developments in quantum computing. As we improve, we get a better idea of the tools we need and can build from there.
#
An important reason for choosing a specific programming language is the **speed** at which you can enter the market with your new product or service to be developed. With the introduction of agile product development where "Proof Of Concepts" and "MVP's" are often built in the beginning, speed seems to be more important than quality in order to test the idea with customers and convince investors to step in. This often results later in a rebuild with a more mature language in the scale-up phase.
#
Furthermore, when we realize that there is a major problem with an already widely used language, it is **nearly impossible to repair entirely** and cleanly as we would have to change the language fundamentally and would therefore ruin multiple codebases. The only major language which seemingly does this is Swift, for which, with every update, Apple seems to make major changes. This, however, has drawn mass criticism as many frustrated developers are consistently having to rewrite large portions of their code that previously worked flawlessly.
#
As the industry opens up to a wider public, **the demand for more readable languages for beginners grows** until it opens the door for new languages as is the case for Go and Kotlin, which gained their popularity through their simple nature and easy development. As opposed to this, Scala is widely criticized for its complex features, driving many developers away.

#### Conclusion
Resulting of the above, we live in a world with countless languages to choose from. Many of them are great, just as many of them are not so much. However, what's certain is that the industry is always changing and therefore, in 10 years most of them will not look the same, and some of them will be replaced by more modern, productive languages.
#
**With an understanding of where all these languages are coming from, we can proceed in deciding which one to use.** The first, and most important step in this is deciding what our final goal is. If it is to be able to develop a good-looking, professional website, you should definitely go for HTML, CSS, and JavaScript. However, if your objective is game development, you should be looking at C# and Java. Many large corporations are now using Java for their back-end. The biggest players in machine learning are Python and R. Mobile development depends on the OS but it is great to take a look at Swift, Kotlin and Java as well as potentially frameworks like ReactNative based on JavaScript and Flutter.
#
For the next step, it is always good to have a bit of **introspection**. If you are a complete beginner, you should go entirely for the productivity and generality line. Choices such as Python dominate this area and this is a great place to start understanding concepts for its ease of use and readability. However, if you are experienced and looking to create a large project with much more control over development, Java-related languages are a great choice.

Programming languages.png

How to start learning software development in 2022? How not to get lost in the maze of programming languages?

Software Engineers are one of the top in-demand professionals in the current job market. Numerous job opportunities, the ability to work from anywhere in the world, and flexible working hours are only a few benefits of this profession.
#
#
But where to start in 2022? How to choose which programming language to learn?


How to Choose a Programming Language

#### What is nearshoring?
#
**Nearshoring** is when a team or additional capacity is based geographically close to the company’s headquarters. An important factor is that both the organization buying nearshoring and the solution provider are in the **same region or time zone**.
In contrast, **offshoring**, a term that is often more familiar to us, is outsourcing to a solution provider in a location that is geographically far from the company’s headquarters. 

#### Advantages

Although the main reasons for companies to outsource were and probably still are lower rates and availability of talents, or better said, the lack of talent in the region the company is in, there are some other interesting benefits of nearshoring.

#####	**• Core values and culture**
Countries in the same region often have similar core values or cultures that at least fit the one the company has itself. This means that working together is often quite easy. However, this should not be taken for granted. A lot of time and effort needs to be put into this to make sure that eventually, the operations run smoothly. _(More about this topic in the challenges section of this blog)._
 
##### **• Reduced Travel Time & Costs**

Even though the idea is to outsource to a third-party solution provider and depend on this supplier to solve the challenges related to capacity and knowledge, it is still nice to know that within a couple of hours both parties are able to meet in one of the offices, in the same time zone and lower costs, and discuss vision, architecture, planning, and other business issues face to face.

##### **• Talent**

Talent is difficult to find, especially within one city. There are many schools and universities with high-quality education in all parts of Europe that are focusing on the tech market. Today’s technology gives us the opportunity to hire talents also outside of our own “city walls” and opens a bigger market to find talent.

 
#### Challenges

Let's say a company finds a solution provider that has:
  - a great culture;
  - flexible capacity;
  - delivers high-quality software development services against lower costs.

If this is the case, why doesn't nearshoring become a more common practice?
#
There are some reasons for this, but luckily there are also good solutions to them. Let's see these.
#
Many companies that try to nearshore their software development have tried **other options** before. Hiring contractors, consultancy firms, attracting new talents, hiring interns, starting mentorship programs, and maybe even outsourcing offshore. In the end, if an organization is not a good fit to run software development projects, the result will always be the same. With introducing more capacity that is not at the same location and has different culture and mentality, the problems will not be solved, they will even get worse.

##### **• Unclear goals**
Having unclear goals will lead to **miscommunication** and **inadequate solutions**. Developers that understand the need, the vision, and goals of the organization that they work for will create much better solutions. This is the same for nearshore teams and in-house teams. Having the right people on board that can translate the customer need into a vision and clear backlog is crucial for the success of every development out there.



##### **• Culture**
Before choosing a solution provider make sure to **investigate the culture** in the area the solution provider is in. Trust is important, but only believing the salespeople everything they state about the company is not enough. Make sure to have a clear picture of things like working hours, working ethic, communication styles, hierarchy, and other factors that are important for your company.
#
**Let's take Dutch culture as an example**. Dutch people always have their own opinion that they are not afraid to share with anyone. This is not common in many other countries. The Dutch think that expressing themselves freely means they are transparent. However, this directness could lead to bad interpretations of messages on the side of the solution provider. 
#
Some companies don't have hierarchal structures and assume their solution provider understands how this works. It can lead to miscommunication if the solution provider's culture consists of people that are used to hierarchy, that have been raised in a way that they have to listen to elderly and more experienced people. 
#
Working with a solution provider means the company must invest in cooperation and that starts with understanding the mentality. Nearshoring solution providers are usually experienced in working with companies from other countries, but make sure you are aligned on all important points.

##### **• Perspective**

Once upon a time, the work was divided into 2 categories: cool and challenging assignments and the leftovers or less important and interesting tasks. The in-house people needed perspective on cool tasks, so the leftovers were pushed to the outsourcing team. **This is bad**. 
#
Building a successful team depends on the amount of perspective the company offers to everyone. Companies who want to work with nearshore teams should realize the team members on the other side of the monitor still believe perspective is more valuable than money, which means that these people should be treated as part of the organization. **The cool thing is that they will pay back the trust!**

#### Conclusion

When it comes to increasing productivity, saving costs, or finding talents and knowledge, nearshoring is a great option. Nowadays technology makes communication easier and there are numerous examples of how nearshoring is really helping companies to achieve their goals.

In order to make nearshoring a success, a company should:
- invest in setting up a good structure;
- make sure that visions and customer needs are clear;
- properly document processes;
- working a standardized way.

Nowadays scrum and kanban are known by every well-organized software development organization and could help reach good cooperation between companies and solution providers. Combining this with old-fashioned team building and focusing on team dynamics in your way of working will lead to success!






Nearshoring.png

What is nearshoring? When is it a good solution? What are the challenges and benefits?

Does nearshoring still make a difference? How can you make it a successful business model?
#
We all know that finding the right people for software development projects is a big challenge. However, in recent years, it appeared that we all had exceptional financial opportunities to find and retain talent. Even today, we still experience solid competition regarding talent. As a result, salaries increase, and costs to keep our precious professionals happy rise.
#
Will these times, where IT leaders have to fight to get the right talent, come to an end? That remains the question, but I don’t think so. As we continue to anticipate a shortage of software engineers in the coming years, the only thing that could alleviate the scarcity of talent is a complete economic downturn.
#
Now we see—and many IT leaders are currently experiencing—the first signals of an economic decline. Economists and political leaders debate whether companies should limit their spending or increase their investments. Often, their first reaction is to reduce budgets. Either way, the need for high-quality software solutions will remain and probably increase in the upcoming years.
#
For companies, the necessity to automate processes is increasing. It is due to a lack of personnel, the high cost of employment, and the changes in business models.
#
What could we do when we face lower budgets and higher costs of finding and keeping talent? Some of us (look at my business model) will say nearshoring.
#
In this article, we will dive deeper into nearshoring. We will discuss how to make nearshoring successful for organizations.


Nearshoring: Benefits and Challenges

In simpler words, code refactoring means **restructuring** but keeping the functionality at the same time. Refactoring is needed when
software engineers need more **abstraction** or when the **business logic has changed** and the code which worked well in the past won't fit or won't be optimal/effective anymore.
#
Project managers, project owners, and non-technical people often ask developers: "Why do we need to spend time and money to refactor the existing code which perfectly works if we get the same functionality at the end?". Well, actually, **developers spend every day at least 20% of their coding time refactoring** the existing codebase! Whenever developers implement a new feature or fix bugs, they need to touch those part of the code that does not directly belong to the original domain. Saying this, doing refactoring is part of the everyday work for a developer. 

#### The Payment API Project

One of our clients entrusted us with moving forward with their existing application. The application is an API, a _payment gateway_ between many-many payment providers like PayPal, Sofort, Apple Pay, etc. The scope of the project was to add new functionalities for fixing bugs and maintaining the infrastructure.
#
The **technology scope** is PHP 7.1 backend with Symfony 3.4, MySQL database, and Redis, in AWS EC2 cluster with 4 instances and a load balancer. The application had to serve a **couple of thousands transactions per day**.

#### The challenges and the solutions

When our development team took ownership of the application, they realized there are some gaps in the logic:
- it used event bubbling which was not the best for the performance; 
- missing indexes in the database;
- bad code structure with lots of unused/deprecated code fragments. 

The **first idea** was to do the refactoring in small pieces. Meanwhile, the number of incoming requests has started to grow because of the new clients and merchants lots of payment data that has been migrated into the database from the other systems. All these happenings with the bad structure of the database and code caused more and more issues. They made harder not just the feature development but the stability of the application as well. We couldn’t get reports from the database in a proper amount of time because of the slow queries. 

#
Whenever we had **issues**, it was **hard to identify** them because of the bad logging. Long response time with third party services and bad design caused transaction failing and when we started to fix an issue and dig deeper into the domain, we found more and more bad logic and implementation into the codebase.
#
First, we tried to **scale up the infrastructure** just to save some time, but we achieve a point soon when it could not work anymore. So we started to talk about these issues with the client to help them understand what the problem is and how it can evolve.  We created a **time and effort estimation** to show how much time it could take to update the PHP/Symfony version, refactor the data model, etc. We also compared it to the time and effort of creating the same application from scratch. We collected all the pros and cons and calculated a lot of stuff, e.g. how much time it takes to add a new provider to the old app compared to the new one, how long it takes to find a bug in the code in the new structure, etc. While the management was discussing the financial side of the work and was trying to choose the best option for the long term, we created the architectural plan for the new application.
#
The plan was not just to rewrite the application as it is, but we had to be able to scale it up vertically and horizontally as well. We decided to **separate the application from the services**.  Every service has its task, the gateway had to process the incoming requests, communicate the database, do all the authentication/authorization work, call the 3rd party fraud service to check whether the payment can happen or not, collect the merchant data for the provider authentication, and then only pass the necessary information to the provider service. This service transforms the given data to the specified format for the payment provider, calls it, and then transforms the response to a common format and returns it back to the gateway for further work. The scheduled tasks service for report generation and all the background tasks and non-time-sensitive processes have their own separated service. Like the front end with the dashboard for the managers and the user manager part as well.

#
One of the **largest changes** was the **database** and **data model.** In the old system, we stored the data in bad normalization way. Sometimes we had the same data twice or more in different tables. So, we created a normalized database structure, eliminated the non-used attributes/duplications, and added the proper indexes, foreign keys into the tables. As a result, we got back the power. The queries are now fast, the access of the data is also fast, and the load of the database has been deceased. The other important change was that we i**ncreased the usage of the Redis** to store as much data as we can in the cache to avoid unnecessary database queries.
#

#### Refactoring - Is It Worth It or Not?

In our case yes, definitely, but it's not always this easy. Most of the time deciding whether a project needs full refactoring or rewriting rather than moving forward with fixing a ton of smaller pieces to achieve better performance is hard because it **depends on a lot of parameters**. Measuring the refactoring of a huge project like this is not always accurate.
#
Sometimes it may seem easier to write everything from scratch, but it has a lot of side effects. 
When the database changes, old data has to be migrated. When the API endpoints change it causes extra effort from the client-side to implement the new version. However, there are cases when this is the only solution.
#
So, **our advice is the following**: before saying that you need to start again from scratch, step back and start investing all possible options. What if you take out a critical part from the code and put it into a separated service? Does scaling up the infrastructure help? What about buying an application from the market and personalizing it? 
#
These are just a few topics that are worth thinking of before rewriting an application as well as before creating a totally new one. 


Refactoring.png

Refactoring or starting everything from scratch - which is the best decision?

Every project development consists of different stages. In software development, the business practices of building applications are referred to as a life cycle. The **software development life cycle (SDLC)** consists of different stages, usually, 6 to 8, like planning, setting up requirements, creating a design, building, documenting, testing, deploying, and maintaining. 
#


However,  every project in its lifecycle gets to the point when **refactoring** is needed. But what is refactoring and what are the pros and cons of it?

Refactoring - Is It Worth It or Not?

### Business problem

Our client has multiple business opportunities to run interactive content in various locations. They already had a few of them running in environments where internet access was limited.
#
As the number of opportunities has raised, our client asked us to help build a platform that is capable to speed up their content creation and distribution process and implement a reusable solution.
#
Based on the initial discussions, the constraints of the possible locations and the desire of handling content were clarified, but the actual content modeling was a grey area for everybody.

### Goals

We have aimed to provide a specialized content management platform with a built-in preview, separated web-based preview, and content distribution sub-systems.
#
We have formulated our constraints toward technical solutions:

-  the solution needs to be flexible to support sharp changes in the content management domain without major development effort
-  the interactive content needs to be usable offline
-  the business logic needs to be shared between multiple components
-  the content management and preview components need to be available online for our client only

### Solution

It was obvious that the content editor and display were web frontend heavy, where the developers would spend their time the most.
By adding a heavyweight backend for sharing the business logic we would have slowed down the team by introducing unnecessary dependency between frontend and backend work.
#
This was the main motivator to let the frontend development flow without blockers, we just need to find the correct tool for supporting it from the backend side.
#
This tool was [Hasura's GraphQL Engine](https://hasura.io/), which allowed us to just model our database, and it was exposing it as a GraphQL API.
#
We took advantage of the GraphQL Engine features like
#
- Role-Based Authorization using OAuth 2 JWT tokens
- Custom REST actions to control Digital Asset Management integrations
- Schema Migrations to do database refactoring
- GraphQL Subscriptions to provide a better content management user experience by displaying real-time changes from the database
- The Admin console where every developer could change the database or other settings

As the GraphQL Engine provided a solution for all data access needs of the web applications, our __backend efforts have been freed up__ to cope with the tasks from the problem domain.

## Drawbacks

Having close relationship between GraphQL schema and the database schema, every change in the database can possibly introduce updates to multiple web applications. In more traditional systems a backend hides the data storage complexities from the clients by having a separate interface. Without this interface, the _risk of overcomplicating frontend code_ in the web application rose, and possibly destroying the sustainable pace of development.
#
The business logic has been also pushed into the web applications, thus additional effort was needed to _keep logic in multiple applications in-sync_ with each other.
#
Unfortunately, we had to create and roll out our _own content management user interface_, because GraphQL Engine is not a CMS system. In the end, this was the only drawback that we had to solve by coding ourselves.

### Win against the drawbacks

We have placed _shared logic into libraries_, which multiple web applications could use later. These libraries helped to reduce the maintenance cost of keeping logic in sync across multiple web applications. This is a simple, but effective software design trick.
#
Using a _monorepo_ for storing all components code allowed us to _validate the GraphQL queries against the actual database_ and GraphQL Schema in a build pipeline. This prevented lots of bugs and investigation time.

### Advantages

The GraphQL Engine has _boosted our development_, frontend developers could easily modify database structure and progress with their tasks without relying on somebody.
#
This shows that this tool is excellent for rapid validation of experiments. Basically, this is what we were searching for as our first goal.
#
To support offline available interactive content, we used _Jamstack_ and implemented with _Next.js as the site generator and GraphQL Engine as "Headless CMS"_. This duo is working nicely together, also using Typescript, the build time validation of GraphQL queries was extremely easy.
#
I also would like to emphasize the _Hasura's documentation_, which helped a lot in integration with Auth0 and setting up the production deployment. The GraphQL Engine is lightweight, it needs _minimal resources_ under the load we have and scales well when needed, and it has free and open-source variants.

### Conclusion

Overall we had allocated 3 frontend developers and 0.5 backend developers to this project. 
To show the time gained using Hasura, let me share that the backend developer also prepared the cloud infrastructure and implemented the majority of the content delivery solution while working only half-time on the project. Without the GraphQL Engine, there would have been several weeks of development just for getting the data from the database to the frontends.
#
I am glad that we found and used this tool, and I also suggest for everybody who has a similar situation as we had, give it a try.


IOP.png

Developing a flexible and interactive content-management platform without a heavyweight backend logic is not myth, it's reality!

Content management is not always easy. Limited internet access, slow distribution processes, and restricted offline usage are influencing interactive content creation and running. Our software engineers had to develop a platform that not only eliminates these but also works fast and efficiently without a complicated backend logic. The solution for this was Hasura's GraphQL Engine.

Saving Backend Development Time in a Complex Project - Hasura GraphQL Engine

Atlassian has hosted its annual **Atlassian Summit of 2022** (called Team 22) at the beginning of April.
#
![MicrosoftTeams-image (10).png](https://tis-tis-io-asset-prd.s3.eu-central-1.amazonaws.com/Microsoft_Teams_image_10_9f9b59a11d.png)
#
The Atlassian toolchain has been defining the "software development / CI/CD / service management support" market for years now. It's a well-built foundation that has a lot of the bases covered if you plan on being in the "software development for hire" business. Right up to the point where, if you are running a small team for yourself (or for an external company), chances are, you can get up and running with their toolchain with very little effort.

### Why is it good to attend conferences like this...?

...You might ask. Well, there are many good reasons, but here are just a couple. I'd say if you want to keep up with industry trends, you might want to take a look at what the big players are doing. And in this regard, the **Keynotes** are the best source of information.
For example, in 2019, they promised to focus more on the Cloud version of their infrastructure. In 2020, they announced they will not be selling standalone server licenses for their products anymore and will be focusing on the Data-Center editions, (recommending also to run them in a multi-node configuration, also making it possible to run them in containers).
In 2022 the software development best practices start with running your application in a container and run in the cloud.
I'm not saying they are the one and only vision to be followed, but it **gives a pretty good sense of where trends are going**.
#
When I started working with JIRA around 10 years ago, we were using the application a bit differently than it was intended. Not for software development, but for work management, and work intake automation.
At that time, the Atlassian Marketplace was crawling with new apps, vendors, and with new ideas and functionalities. There was a need for developing custom plugins to make sure they do everything that you want in the exact way you want it.
#
One of the key changes in this year's Conference was that **the number of plugin developers**, who were strictly in the business of plugin development was far less, and the number of "Solution Providers" have risen.
When discussing this finding with one other attendee, he said: "All the good software has already been written. We now need to teach people to use it."
#

### Why was this event special?

They usually host an event like this every year. Then... COVID happened. For everyone.
#
But the past 2,5 years have changed a lot of things. Hybrid work schedules and working from home have become the **new standard for employment**, as companies who wanted to stay afloat adjusted to the needs of their employees and the needs of the market.
#
This has also influenced the way people work together, and the way people interact with their productivity software as well. Everybody is available online.
Daily stand-ups, quick catch-up meetings, end-of-day statuses, virtual coffee times, and online team buildings have become a new standard of "hanging out" with colleagues.
And companies have started to invest in software to make these happen. But doing so, there was **a new phenomenon** that the companies had to deal with: **an average software team uses 25 apps to support collaboration.**
#
 ![Géza Kép 1.png](https://tis-tis-io-asset-prd.s3.eu-central-1.amazonaws.com/Geza_Kep_1_629b728a52.png)
#
So this year's biggest focus was **INTEGRATION**.
#
Atlassian has published **over 50 integrations** with third-party apps. Integration, because everybody has their own expertise. Every tool has its own way of working. And the platforms have to adapt to that to make sure that these applications have the ability to communicate with one another.
#
This is actually a pretty important and valuable trend to follow. We're gone from a vendor providing their own solution in every single space you want to making sure the software you already use collaborates perfectly. Because **why not use the best tools for the job you have, rather than always reinventing the wheel.**
#
And the biggest takeaway that should apply to every software developer in 2022...
**Today's software is not written, it's assembled...**
#
Having that in mind, **stay tuned for next week's post** about how we used a standard GraphQL engine instead of developing a custom backend for our customers.

Atlassian.png

Is today's software only assembled, not written? Is it still worth attending conferences?

Conferences, workshops, and networking events have all been part of our lives. However, since COVID happened, it has changed the way we live and collaborate irreversibly. Is it still worth attending these or have they been replaced by online events?

Atlassian Team '22

### About the project

We started the collaboration on this project in the **early phase** of the actual development, even though some of the **base logic** like authentication, roles, some placeholder API endpoints were **already implemented**. 

The team at that time consisted of 3 people working on the client’s side, and 3 people joined gradually from our side. 

The **technical background** of the application is a PHP backend with Symfony framework, MySQL database, Redis cluster, a RabbitMQ for the messaging and some other small services running in a Kubernetes environment. It’s always fun to start working on a project like this, because on one hand we can use a lot of different types of technologies, and on the other hand it is a huge challenge to keep it fast, secure, and well-designed until the end of the development.
 
### Challenges – the good ones
 
The scope of this project and the **technology stack is exciting** for a developer, especially handling different types of data sources, processing huge data files in the required time frame. These challenges need non-standard or out of the box complex solutions.
 
 
### Challenges – the not so good ones
 
The **first challenge** is not a huge one, but it can be a pain sometimes: when the team started to grow, we had to design and agree on **branching strategy** to be able to manage the source code properly. It was needed to avoid a lot of merge conflicts and “cherry picking” features during the development to save time. When a smaller team was working on this project with 1 or 2 developers, it was not a problem, but after we joined the team and the number of the merge requests started to increase, the tech lead had no time to review these on time. As a result, it started to cause a lot of extra work because of the **dependency between the requests.**

The **solution** is to **delegate** some of the responsibilities, so that no one would be too busy. We had the trust of the client, so now we are reviewing each other’s changes, so the development can go faster, and the tech lead could work on what is most important: **understanding the requirements**.

The **second challenge** is much bigger, and it has a lot of side effects, that cause other challenges. As I mentioned, this project is now in the **prototyping phase**. It means that a lot of requirements are not done, missing, or constantly changing.

We can say that it is totally fine, because as software developers, we are used to it, and this is the core of the Agile method, but changing the data model takes too much time, because it affects the entire application.
Unfortunately, we have no time to step back and finalize the whole data-model/architecture, so we always need to refactor a bunch of business logic.

The other side effect of this type of development is that many times when a requirement has changed, for the small issues we said, “we will fix it later” and the list of these “fix it later” issues are getting larger and larger. Unfortunately, we faced such problems in the past: everyone thought that a feature has already been implemented, and when we wanted to use that feature, we realized it wasn’t.
We do not currently have a silver bullet solution for this issue. Dedicating more time to understand the requirements and working with the end clients much more closely to clarify that constant functional changes affect not just the deadline, but the software stability as well.
 
 
### Summary
 
The velocity of the development could improve, but we are steadily making progress and we definitely see, that the team members are doing their best to complete the project successfully and avoid as much pain as possible. But in the end the most important thing is to bring some golden value to the clients.
 
So the conclusion is: **Software development is hard but we enjoy it.**


Project.png

Prototyping a project is both challenging and exciting at the same time. Would you agree with this? 

Prototyping a project is both challenging and exciting at the same time. Would you agree with this? And what if there is already a team that has laid the base and you have to pick up the work from there? 

Well, this is what we had to do for one of our clients recently while developing an application for a telecommunication company. The goal of the application is to be able to manage the administration, data integration, data merge from different types of sources, and user data management.

Prototyping a New Project: Challenges and Solutions

While Strapi's own [documentation](https://docs.strapi.io/developer-docs/latest/plugins/graphql.html) is good for adding GraphQL support, it also confusing **what customizations are available** when somebody wants to use GraphQL. As our project is using Strapi v4, we had to learn how to create such queries, compared to v3.
#
The first example under the official GraphQL documentation's [Customization section](https://docs.strapi.io/developer-docs/latest/plugins/graphql.html#customization) is a showcase of the capabilities without providing much context. That example - next to some ShadowCRUD settings - creates two object types (Book and Article), a custom [Nexus](https://nexusjs.org/) plugin, overrides a query resolver for an existing content type (address) and disables authentication for the same content type (Query.address).
#
For me, it was hard to see **how to set up a new query,** **define new types** and **how to re-use already existing types** from other content-types. As our project is using Strapi v4, we had to learn how to create such queries, compared to v3.
#
Eventually, we could explore the documentation, the Strapi codebase and the examples of official plugins (like users and permissions plugin) and conclude a way to **effectively add GraphQL customizations**.
#
**This post is showing the results of our findings and aims to help the developers who need to achieve similar goals with Strapi v4.**

## The domain for the example

Let's assume that we are developing an e-commerce site where we sell products. One day we would like to add a feature to track popularity of each product using a third party solution. To keep the API keys secret at the server side, we are planning to define a new GraphQL query to the existing GraphQL schema provided by Strapi.
#
This query will handle the integration to the 3rd party API and optionally return the product data if requested.

##  Initialize the project

For the sake of simplicity, we are setting up a new Strapi project for this example using the official guide, thus using npx from command line: 

```bash
 npx create-strapi-app@latest graphql-example --quickstart
```

After creating the initial administration account, we can use another terminal window to proceed.

###  Define the Product content type

In order to add a `Product` content type with an API and a single attribute called `name`, you can use the command line interface or the started admin web interface.

I will use the CLI so I can include its output. 

```bash
 npm run strapi generate content-type
```

```bash
? Content type display name Product
? Content type singular name product
? Content type plural name products
? Please choose the model type Collection Type
? Use draft and publish? No
? Do you want to add attributes? Yes
? Name of attribute name
? What type of attribute string
? Do you want to add another attribute? No
? Where do you want to add this model? Add model to new API
? Name of the new API? product
? Bootstrap API related files? Yes
✔  ++ /api/product/content-types/product/schema.json
✔  +- /api/product/content-types/product/schema.json
✔  ++ /api/product/controllers/product.js
✔  ++ /api/product/services/product.js
✔  ++ /api/product/routes/product.js
```

###  Add GraphQL plugin

The Strapi quick start project does not contain the GraphQL plugin, so we have to install it. You can follow the [plugin's documentation](https://docs.strapi.io/developer-docs/latest/plugins/graphql.html), however, it is just as easy that running this command:

```bash
 npm run strapi install graphql
```

When your Strapi application restarts, you can access the GraphQL playground at http://localhost:1337/graphql

Let's check the Product query which was created for the content type with the following query:

```graphql
query Products {
  products {
    data {
      id
      attributes {
        name
        createdAt
        updatedAt
      }
    }
  }
}
```
 
For the first try it fails because there is no permission set up for unauthenticated users.
#
After adding the `find` and `findOne` permissions of `Product` content type to the `Public` role in the admin `Settings` / `Users & Permissions Plugin` / `Roles` / `Public` location in the admin web interface, the above query should return empty list.

If you would like to see some results, then add a new product manually or (after providing the `create` permission for the `Public` role) with this GraphQL mutation:

```graphql
mutation CreateProduct {
  createProduct(data: {
    name: "The product"
  }) {
    data {
      id
    }
  }
}
```

###  Prepare to add custom GraphQL query

We can add customizations to the GraphQL plugin in Strapi's `register` lifecycle hook, which is in `./src/index.js`.
In a reasonably large project this file can contain lots of code, so to make it obvious where GraphQL related code is defined, we will create another file at `./src/graphql.js`. This will be responsible to collect the custom GraphQL queries and mutations and add them to Strapi.

After our changes the files look like this.

```bash
./src/index.js
```

```javascript
'use strict';

const graphql = require('./graphql')

module.exports = {

  register({ strapi }) {
    graphql(strapi) // externalize all graphql related code to ./src/graphql.js
  },
  
  bootstrap(/*{ strapi }*/) {},
}
```

```bash
./src/graphql.js
```

```javascript
'use strict';

const noop = (strapi) => ({nexus}) => ({})

const extensions = [noop]

module.exports = (strapi) => {
  const extensionService = strapi.plugin('graphql').service('extension')

  for (const extension of extensions) {
    extensionService.use(extension(strapi))
  }
}
```
##### 
Later we will replace the noop extension with the `popularity` extension, which will also be similar to `noop`, ie: it will be a function taking `strapi` as parameter, returns another function with a parameter which has a `nexus` field and returns the extension definition.

This complicated function is helping in the long run, as `strapi` is provided by our code, but `nexus` is provided by the GraphQL plugin's `extension` service. Both can be useful in our extension code to reach other Strapi services, plugins and use [nexus api](https://nexusjs.org/docs/api/introduction).

###  Use Nexus API

It is time to define our `popularity` extension. I will copy the `noop` extension into the `.src/api/popularity/graphql.js` file and include this non-working definition to the extensions.


```bash
./src/api/popularity/graphql.js
```

```javascript
'use strict';

module.exports = (strapi) => ({nexus}) => ({})
```

```bash
./src/graphql.js
```

```javascript
'use strict';

const popularity = require('./api/popularity/graphql')
const extensions = [popularity]

module.exports = (strapi) => {
  const extensionService = strapi.plugin('graphql').service('extension')

  for (const extension of extensions) {
    extensionService.use(extension(strapi))
  }
}
```
##### 
As you can see I have chosen to import the new module and add it to the extensions list. The drawback is that whenever we add another GraphQL query, we have to manually add it to the extension list, otherwise it won't be recognized.
##### 
Let's continue with the actual extension, fill in the `popularity` GraphQL definition. Our first approach is to use [nexus api](https://nexusjs.org/docs/api/introduction).
##### 

```bash
.src/api/popularity/graphql.js
```

```javascript
'use strict';

module.exports = (strapi) => ({nexus}) => ({
  types: [
    nexus.extendType({
      type: 'Query', // extending Query
      definition(t) {
        t.field('popularity', { // with this field
          type: 'PopularityResponse', // which has this custom type (defined below)
          args: {
            product: nexus.nonNull('ID') // and accepts a product id as argument
          },
          resolve: async (parent, args, context) => ({ // and resolves to the 3rd party popularity service logic
            stars: Math.floor(Math.random() * 5) + 1, // a simple mocked response
            product: args.product
          })
        })
      }
    }),
    nexus.objectType({
      name: 'PopularityResponse', // this is our custom object type
      definition(t) {
        t.nonNull.int('stars') // with a result of the 3rd party popularity service response

        t.field('product', { // and if requested, a field to query the product content type
          type: 'ProductEntityResponse',
          resolve: async (parent, args) => ({ // where we provide the resolver as Strapi does not know about relations of our new PopularityResponse type
            value: await strapi.entityService.findOne('api::product.product', parent.product, args)
          }) // but relations, components and dynamic zones of the Product will be handled by built-in resolvers
        })
      }
    }),
  ],
  resolversConfig: {
    'Query.popularity': {
      auth: {
        scope: ['api::product.product.findOne'] // we give permission to use the new query for those who has findOne permission of Product content type
      }
    }
  }
})
```
##### 
I have included a mocked response for the 3rd party call, and let the reader elaborate on how to continue the implementation regarding the integration with any 3rd parties or custom logic.
##### 
Now you can check the results in the GraphQL Playground using the below query.
##### 
```graphql
query GetPopularity {
  popularity(product: "1") {
    stars
    product {
      data {
        id
        attributes {
          name
        }
      }
    }
  }
}
```

This gives the result:

```json
{
  "data": {
    "popularity": {
      "stars": 3,
      "product": {
        "data": {
          "id": "1",
          "attributes": {
            "name": "The product"
          }
        }
      }
    }
  }
}
```

So our implementation works as we expect.

For us the **hardest problem** was to **link the custom response type** (`PopularityResponse`) and the **Product content type's resolvers**. The final trick was to provide a resolver for the immediate relations (`product` field in the example), and return the result in a format what Strapi's graphql plugin accepts (an object with `value` field). This information came from the [graphql plugin source code](https://github.com/strapi/strapi/blob/v4.1.1/packages/plugins/graphql/server/services/format/return-types.js), which implies that using this trick is considered a dependency on graphql plugin internals and can break during upgrades.

###  Use GraphQL Schema

Since Strapi v4.0.8, the `ProductResponseEntity` can be referenced from GraphQL SDL type definitions in Strapi. If you are interested, here is the same definition, but using GraphQL schema and avoiding nexus API.
 
```bash
.src/api/popularity/graphql.js
```

```javascript
'use strict';

module.exports = (strapi) => ({nexus}) => ({
  typeDefs: `
    type PopularityResponse {
      stars: Int!
      product: ProductEntityResponse
    }

    extend type Query {
      popularity(product: ID!): PopularityResponse
    }
  `,
  resolvers: {
    Query: {
      popularity: {
        resolve: async (parent, args, context) => ({
          stars: Math.floor(Math.random() * 5) + 1,
          product: args.product
        })
      }
    },
    PopularityResponse: {
      product: {
        resolve: async (parent, args) => ({
          value: await strapi.entityService.findOne('api::product.product', parent.product, args)
        })
      }
    }
  },
  resolversConfig: {
    'Query.popularity': {
      auth: {
        scope: ['api::product.product.findOne']
      }
    }
  }
})
```

#
Personally, I prefer the GraphQL SDL variant as it is more compact, and it is familiar to most developers. In case we make a mistake in the SDL definition, it is failing at starting up Strapi, which is usually the same when we use Nexus API.
#
For both cases the `resolversConfig` can add configuration for authorization, middlewares and policies. While it is possible to override existing queries and mutation's `resolversConfig`, you should keep in mind that the active `resolversConfig` would be result of merging Strapi's default resolvers configuration and your settings. This makes the resolvers' configuration overrides dependent on the original settings and the merging process (which both can change with Strapi upgrades). 

##  Conclusions

#
As we can see, it is not that hard to add customized queries to Strapi. However, there are major differences between Strapi v3 and v4 regarding GraphQL.

I hope the above example saves you the time we have spent to find out the ways to implement GraphQL queries in Strapi v4.


Strapi.jpg

Have you ever had difficulties with setting up a new query, defining new types, or re-using already existing types from other content-types in Strapi V4?  If your answer is yes, check out this blog post!

Have you ever had difficulties with setting up a new query, defining new types, or re-using already existing types from other content-types in Strapi V4? Did you feel confused about the available customizations when using GraphQL? Let us help you and show how we solved this in one of our projects!

How to Add Custom GraphQL Query to Strapi V4

"As a developer, I'm always looking for challenges during the work time and after it too, and the challenges always find me as well. Last year I participated in a contest organized by the IThon.info. Every year they organize this seven-week long event where in the first 4 weeks participants have one full week to finish the tests made by the partners of the organizers. In the last 3 weeks, the tests are being launched on a fixed date with a fixed amount of time to use to complete. First I attended this competition in 2019 and registered for different categories like Java EE, Spring and language-independent programming and in 2020 I did the same.The tests were based on very broad topics from basic to the advanced Java stuff and of course, as their names state Java EE and Spring. To my surprise, I finished at 7th place in the Spring category which was organized by the Epam Systems. They mostly focused on advanced Java and Spring related questions, which in the last 3 weeks required a lot of technical skills to finish in time. But the biggest surprise was that I won the JAVA EE category, this category was organized by the IBM and they were mostly focusing on the core Java EE stuff like:_

Servlets
JSONB and JSONP and JAXB
Bean Validation
CDI
JPA and some JDBC questions
EJB
JAX-RS

_All of the Java EE specification related topics were there and I would say each test held some tricky questions which required some practice and real-life experience from the past. The time for the tests were typically small and you could only rely on your skills - this is what it made so much fun. I'm thankful for the opportunity and I hope I will see more familiar names and faces in this year."_

We are really proud of the dedication and performance of Nandi. He is a great example of the fact that it is never enough of challenges.

winner-takes-it-all.png

Guys at The IT Solutions are always looking for extra challenges besides daily challenges at work.

Guys at The IT Solutions are always looking for extra challenges besides daily challenges at work. One of our developers, Nandor Holozsnyak has won the 1st prize at a Java EE category competition. Please see his experiences about the competition.

The Winner Takes It All

Windows users can use the options given by the Office family, the PowerPoint, Linux users can use both LibreOffice or OpenOffice solutions like Impress.
We, of course, do have online alternatives like Prezi, Google Slides, there are tons out there, but as a developer, we may be attracted to something more minimal and something which can be versioned by ourself may be in a repository, and of course, we would not like to deal with power-hungry tools or we do not want to go to a website where we can edit our presentation.

In this article, we would like to introduce a tool that can come in handy in creating presentations that are meant to be easy to create, and because we are more into code, and code-related stuff, we may prefer to create creative stuff via code. Most of the developers are familiar with languages that are being used for documentation or tutorials, for example, AsciiDoc or Markdown, and what if we can make and design our presentations in Markdown with some minimal CSS and HTML knowledge?

For this problem Marp gives us a fairly simple solution. With this tool, we can convert Markdown files to:

HTML with an interactive presentation toolkit 
PDF
PPT

Sounds cool right? How can I start using it? It's easy.

**Marp** is a product based on multiple modules/extensions, let's take a look at those first:

**Marpit**
skinny framework based on the markdown-it parser
supports CommonMark specification of Markdown
Mostly written in JavaScript
**Marp-core**
Based on the Marpit module/package (don't be confused with the name core), it extendes the Marpit framework with additional features
Mostly written in TypeScript
Built-in official themes (CSS)
Emoji support
Math support
Auto-scaling features
**Marp CLI**
Command line interface for which depends on the Marp-core
Installation guide (multiple ways):
With NPM package manager (npm install -g @marp-team/marp-cli)
Standalone binary (can be downloaded from the GitHub repository)
With Windows package manager tools (Chocolatey or Scoop)
Gives the user the power to convert .md files to .html, .ppt, .pdf
Supports watch and server mode

If you are willing to create the next Markdown presenter tool then the Marpit framework is a good start, you can import it to your project and use the power of the framework, but right now we want to talk about the end product itself, **Marp**, which uses all the mentioned tools/modules above, and based on these tools you are able to create the most beautiful and minimalistic presentations.

To write your very first presentation using this tool, first install the Marp CLI and you are good to go. Let's make some slides, with some cool background, make sure every page has page numbers and try out some directives.

To start the CLI in watch mode just run the following: marp prezi.md -w (if we would like to enable HTML tags then use the -html flag too)

Check out the [Marp](https://marpit.marp.app/) website to know more.

Marp has a lot of potential being a cool and handy tool in our hand, if we are much more into the Markdown world, we can bring fantastic presentations to the audience with ease.



---

# TIS Presentation

We can use the typical Markdown syntax and every time we would like to create a new slide we just have to insert the 3 dashed **'`---`'** at the end of our slide.

In the header comment section we are able to configure global and local directives which can control:

- pagination

- background color

- text color

- enable HTML tags in our presentation

- header and footer content

---









Slide 1
# Second slide

We can customize slides individually from the global scope, we can use local scope directives, to use the local scope just start the property name with a '_', for example:

  - pagination can be turned off on slides (_paginate: false)

  - header and footer content can be changed (_header and _footer)

  - background related color or image

  - font color

  - custom directives written in Javascript

---

# CSS support

Marp has a wide variety of CSS support which can be found [here](https://marpit.marp.app/theme-css)

---

# And many more

The markdown code above can be checked out here as the 'final' presentation and the all the final assets (PDF, PPT) can be found here. The pictures are taken from the presentation too.
Have fun making awesome minimalistic slides with Marp! \o/

creating-presentation-developer-approach.png

If Infrastructure as Code exists, then does Presentation as Code exist too?

If Infrastructure as Code exists, then does Presentation as Code exist too? As a developer sometimes we are wondering how should we make a presentation for the next big event like knowledge share sessions, conferences, demos and we find a lot of stuff out there.

Creating Presentation – The Developer Approach

#### **The World of Multis**
I wanted to **escape the multis** since I was tied up with lots of unproductive processes. Slow decision-making was one of them. It is a culture where everyone wants to show their value in a cramped way. I think that makes the whole culture unproductive and weird. 
#
I enjoyed the parts of my career when I got real empowerment and true responsibility to build something new, a new development site, a new product, or a new process. I love solving problems from end to end since it requires understanding the needs, then planning, getting the buy-in, and finally executing. So why should I join a multi again and be responsible for a specific part only?
#
##### **The Beginning**
So, I met with Meindert and Quincy with these things in my mind. They were very sympathetic because they were open, honest, and direct. Their **vision and value matched** very well with mine. I trusted them. I left the discussions with a positive mind. I felt motivated and excited again after a long time. 
#
My brain started to think about how I would approach their goals and what I would do first to make them successful. I could not stop thinking about these. Joining a new company involves some risk. Of course, it is not comparable to the huge opportunities it brings. We agreed quickly then I left work for a vacation, full of motivation, excitement, and happiness. 
#
##### **The First Step**
The start was **full of energy.** It was even more energetic than I expected. And when I say “the start” then I mean the next day right after I accepted the offer. I counted 58 email conversations with Meindert while I was on my holiday in Malta. 
#
The interview process of the first team was already in progress while we were opting for the best environment, equipment, and infrastructure for the team. 
#
#### **The Start**
"The **first team** will start in one and a half months". – said Meindert. "Wow, what a challenge!" – I said. Well, if you had known the lead time of getting lease line internet in downtown Debrecen then you would have said it’s impossible. Another example is the average delivery time of high-end laptops, finding a team who can start immediately and rebuild a few things in the new office, and buying furniture. We wanted everything ready by 1st September when the first team of five started. 
#
Finally, we did it on time, with a **fantastic result!** I enjoyed every single minute of this period. We got to know each other better and better, and we resonated at the same frequency. 
#

looking-back-last-two-years.jpg

How I met the founders of The IT Solutions? What did I think then? Why did I join the company? What was my expectation? In this article, I try to answer all of these questions.

Looking Back for the Last Two Years

**Why customers move to the cloud?**

**These applications that provide services like emailing, writing contracts and POs, invoicing or financial management are all hosted in the cloud today and you pay-as-you-use. You don’t need a server, switch, router and other IT infrastructure that would bother your time, attention and cash flow. You don’t even need to hire an IT technician to be able to use these applications. Very cool, isn’t it?  **

Later, you will need a tailor-made software as you are settled down and found out your own way of working that best suited to your needs. You find us, a solution developer company. We work together to understand your needs, how and what this software can help you to realize more value. Further on the road, we start the development and want to show you the results week by week, give it to you to play with and confirm it is really the thing that you need.

However, the complications come in this step: **where should we install this application for you to use?** Should we ask you to go to the shop and buy a server and all related things that needs to run it? Should we ask you to hire an IT guy to build it and maintain it regularly? Should you start learning new IT things like what is server backup and why it is important; why should I pay for this; what is security, disaster recovery, performance issues, load balancing and thousands of other things? No, you definitely want to focus on your own business.  

The answer is the cloud computing. We can use a credit card to buy the right-size resources within seconds, deploy the software to there and let you use it. The price includes all necessary things to run the software. You don’t even need to know what kind of magic the provider (AWS for instance) does in every minute to let you use the service.  

Are you growing and having more users that may slow down the software? Just go and ask to increase the capacity as needed. Done. You don’t need something anymore? Just go and ask to remove it and done. 

**What business challenges do customers face? What do customer’s technology and IT infrastructure look like? Where do customers host their technology? **

The analysis depends on what size of company and in what maturity state we are meeting with the customers. For instance, we can find these typical signs at our customer

Startups

starting from zero to something from day one to next day
too much things to focus on in the same time
focus on cash flow, short term goals
having individual, separated infrastructure
wide range of technology, mostly free or open source

Scaleups

increase speed and agility
performance, scaling is important
integration, automation, efficiency is key
mid to long term goals

Established companies

offer services to international markets
long term goals
reduce infrastructure cost
planning to move from private or hybrid cloud to public cloud
consolidating technology
focus on high availability, efficient monitoring, automation

Let’s dig deeper and see why customers are moving to cloud in the next blog post, what is the cloud adoption journey and what is the role of the Amazon Partner Network in this journey. 

digital-transformation-aws-1.jpg

A business case – consider you start a new, small business. When you start a new business then there are too many things in the same time at the beginning to be distracted easily and you need to manage your cash flow carefully as well. Most of the applications you will use as a service at the beginning because it’s easy to start with and enough at the beginning.

Java vs. Golang: Limitations in Custom Software Solutions

Introduction

Java

Golang

Conclusion

Blog Posts

View more

modernc.org/sqlite with Go

Graceful termination of Nginx in K8s

React Native vs. React Web: What's the Difference and When to Use Them