News Aggregator

Code Review: A Comprehensive Checklist

Aggregated on: Tue Nov 09 2021 15:05:53 GMT+0000 (Coordinated Universal Time)

A code review is a helpful tool for teams to improve code quality besides many other benefits to reviewing code. Not to mention the reduced development cost when catching bugs early in the development lifecycle, sharing knowledge, and improving the team's estimation skills. In the last section of this article, you can find a code review checklist to use when implementing a code review process in your developer workflow.

SQL JOINs Tutorial With Examples

Aggregated on: Tue Nov 09 2021 13:35:53 GMT+0000 (Coordinated Universal Time)

Introduction to SQL JOINs As we all know, table data is the core of any SQL database. Naturally, SQL Server databases store tons and tons of table data. To use the table data effectively, database administrators need to extract records from several tables based on certain conditions regularly. And that’s exactly what SQL JOINs are for. JOIN is an SQL clause used to retrieve data from two or more tables based on logical relationships between the tables. Joins indicate how SQL Server should use data from one table to select the rows in another table.

11 Best Selenium Alternatives for Testers

Aggregated on: Tue Nov 09 2021 12:50:53 GMT+0000 (Coordinated Universal Time)

Selenium is a free and open-source tool for automated testing. It can test web applications for functional, regression, and load across a variety of browsers and systems. Selenium is an excellent tool, however, it does have certain disadvantages. The following is a selected list of Selenium alternatives that have been thoroughly tested.

Smart Dependency Injection With Spring - Generics (Part 3/3)

Aggregated on: Tue Nov 09 2021 12:05:53 GMT+0000 (Coordinated Universal Time)

Preface The Spring framework is a powerful framework that provides first-class support for dependency injection (DI). This article is the last one in my mini-series dedicated to dependency injection with Spring Framework. This series is split into three articles:

Top Reasons for Hiring QA Analysts

Aggregated on: Tue Nov 09 2021 11:50:53 GMT+0000 (Coordinated Universal Time)

We know software testing services play an integral part in every business to be successful. Quality assurance (QA) testers are essential for any company, they avoid untidy coding and offer excellent user interaction. If you think it’s time to improve your software quality, you need to hire a quality assurance team. There may be times when the development team becomes painfully apparent and get nervous about a new feature, or the customer support gets flooded. It means it's time you hire a software tester to make your system function well. Let’s understand the streamlined process with understanding the ways to hire QA analysts.

Who Makes a Better DevOps Engineer? | Developer Vs. Sysadmin

Aggregated on: Tue Nov 09 2021 11:05:53 GMT+0000 (Coordinated Universal Time)

Who makes a better DevOps engineer? What’s the outcome of developer vs. sysadmin? This article will provide you with the answers to these questions and even more. What’s the Difference? Before getting into details, let’s see what is the difference between a software developer and a system administrator?

Smart Leaders are Good Listeners Who act Wisely

Aggregated on: Tue Nov 09 2021 11:05:53 GMT+0000 (Coordinated Universal Time)

Leadership might be one of the interesting topics in the IT industry where having smart leaders can make a lot of difference. Leader’s decisions in the IT industry not only impact on the employees but also this would impact on the products are being produced and therefore the end-users will be impacted as well. This is how leadership in this area is quite critical and as the software industry is moving forward with advanced technologies, leadership is developing to get adapted to the new generations of engineers and new ways of working. Leader Story One day I got a message from one of the developers that something in design for the migration is not right. I did not know anything about the context that’s why I scheduled a quick call for the day after to understand it. The day after when I understood the context of the issue, I also noticed that developer has a lot of experience with the context and he is also passionate about implementing the new solution for that issue. I was listening to his complaints and he was emphasizing that he has been shouting at people that they are not right about the approach they take for this issue. This situation immediately reminded me many years ago when I was complaining all the time without doing anything. Even though I was right, no one was listening or understanding what I was saying.

Upgrading to .Net 6

Aggregated on: Tue Nov 09 2021 10:35:53 GMT+0000 (Coordinated Universal Time)

.Net 6 SDK was just released by Microsoft, and apparently it's a really kick ass upgrade. It significantly optimises Stream, reduces memory footprint, and contains tons of new cool features. Probably the most important code improvement change for me personally, is the mutable DOM classes for System.Text.Json, which over time will allow me to completely replace Newtonsoft.JSON with the builtin libraries, reducing dependencies in my core. Dependencies is a big thing for me in Magic, which I'm trying to reduce to a minimum. In fact, dependency reduction is arguably my single most important axiom for improving code quality and modularity, something I guess the fact that Magic contains 30+ projects is a testimonial towards. My experience with updating Magic to use version 6 was almost 100% painless. Basically, I did a search and replace through my .csproj file replacing "net5.0" with "net6.0", and everything (almost) immediately worked. 1,000+ unit tests are green, 125+ integration tests are green, and while manually quality assuring features in Magic after updating, I was not able to find any breaking changes at all for me personally. Of course, I am trying as much as possible to use .Net Standard as much as I can in most of these projects, but still there were 20+ .csproj files that were updated during this process.

From TDD to PBT via Kotest

Aggregated on: Tue Nov 09 2021 06:05:54 GMT+0000 (Coordinated Universal Time)

In this post, we see how to integrate PBT into your Kotlin tests. Introduction I’ve been a big fan of Property Based Testing for a number of years, based on my experiences with ScalaCheck. It’s always been an annoyance that Kotlin did not support this testing style, at least to the same extent. There was some functionality in Kotest (formerly KotlinTest), but it paled in comparison to what was available in Scala, F# and Python.

Using Prism for API Mocking and Contract Testing

Aggregated on: Tue Nov 09 2021 06:05:54 GMT+0000 (Coordinated Universal Time)

What is API mocking? In short, it’s about creating a simplified version of an API that works at a mechanical level, even though it’s not implementing the logic of the API. Such an “API mock” then can be used by consumers of an API to start developing applications that use the API. This means that it’s possible to get feedback from consumers earlier in the development cycle, making it faster and more effective to gather early feedback and improve the API design. Prism is an open software tool maintained and used by Stoplight for their API tooling that’s providing API mocking. It’s specifically for REST/HTTP APIs and is using the OpenAPI specification as its description language for APIs.

Reducing Costs and Improving Efficiencies of Your Log Management Investment

Aggregated on: Tue Nov 09 2021 03:35:55 GMT+0000 (Coordinated Universal Time)

People’s involvement has been inevitable with log management despite advancements in ITOps. Log management at a high level collects and indexes all your application and system log files so that you can search through them quickly. It also lets you define rules based on log patterns so that you can get alerts when an anomaly occurs. Log management analytics solution leveraging Robotic Data Automation(RDA) has been able to detect anomalies and aid predictive models over a machine learning layer. This has demonstrated improved efficiencies and a direct reduction in costs.

Installing and Debugging an Apereo Cas Application

Aggregated on: Tue Nov 09 2021 03:35:54 GMT+0000 (Coordinated Universal Time)

The Central Authentication Service (CAS) is a single sign-on software application protocol. The duty of the CAS is to permit a user to access multiple applications while providing their credentials only once to a centralized CAS Server. It also allows web applications to authenticate users without gaining access to a user's security credentials, such as a password. Apereo CAS Apereo CAS is an open-source implementation of above mentioned CAS protocol by the Yale University laboratory. Apero CAS is not only a simply authentication software but also it has got some versatile features such as:

Boost throughput with RESTEasy Reactive in Quarkus 2.2

Aggregated on: Tue Nov 09 2021 03:35:54 GMT+0000 (Coordinated Universal Time)

Quarkus has, from its beginning, provided core features for coding Java programs in both imperative and reactive styles. With the new 2.2 release, Quarkus continues to improve in terms of network-related features, reactive programming, and integration with the Eclipse Vert.x event bus. For example, RESTEasy Reactive in Quarkus is a new JAX-RS implementation based on the Vert.x layer that achieves much higher throughput by handling reactive events on the non-blocking I/O thread. The Red Hat build of Quarkus 2.2 provides production support for the RestEasy Reactive extensions, with additional features:

How to Use SingleStore With Spark ML for Fraud Detection

Aggregated on: Tue Nov 09 2021 02:50:53 GMT+0000 (Coordinated Universal Time)

Abstract SingleStore is a database technology that can easily integrate with a wide range of big data tools and services. One such tool is Apache Spark™. In this 3-part series of articles, we’ll see how easy it is to use the SingleStore Spark Connector and the performance benefits it provides. We’ll also discuss a Credit Card Fraud Detection case study using actual data that we save into SingleStore, and then develop a Machine Learning model using Spark to determine if a Credit Card transaction is fraudulent or not. The notebook files used in this article series are available on GitHub in DBC, HTML, and iPython formats

Advice to My Younger Self as a Software Engineer

Aggregated on: Tue Nov 09 2021 02:50:53 GMT+0000 (Coordinated Universal Time)

A piece of advice to my younger self — “Set all kinds of goals for what you want to achieve in life. No goal is too big with the right plan and vision.” In the past 25 years, I had my fair share of success and failure. I find this journey memorable as it made me understand the importance of failure and success. Every success is close to my heart that constantly provides me a better understanding of team works and a sense of achievement but every failure provided me a new and innovative way to find extraordinary solutions.

Collation Relation, What's Your Translation?

Aggregated on: Tue Nov 09 2021 02:05:53 GMT+0000 (Coordinated Universal Time)

When developers see the infamous black question marks from the cover image in their terminal - they shudder. There is an encoding issue in the system and it's time to dive into a dark corner of the development. Today we will cover collations and character sets in MySQL, two fundamental building blocks to better understand how your database is dealing with non-ascii characters. And, how it isn't.

The Best Programming Languages for AI

Aggregated on: Tue Nov 09 2021 00:50:54 GMT+0000 (Coordinated Universal Time)

Artificial Intelligence has been around since the mid-years of the twentieth century. Still, it's only been in the last ten years or so that it's become accessible to developers looking to build AI into their applications. Programming languages are the backbones of artificial intelligence development projects because they help software developers create innovative AI solutions without learning the highly specialized language that scientists use to communicate with each other.

How To Get Your ML Project Approved

Aggregated on: Tue Nov 09 2021 00:50:53 GMT+0000 (Coordinated Universal Time)

Machine learning projects are high profile, but the tech is still new and still evolving. That makes business decision-makers nervous. If you have a Machine Learning project idea here are three tips to give your machine learning project the best chance of approval. Avoid confusing the audience – don’t talk about the technology Increase interest by making the business outcomes clear Reduce fear by saying how much effort is involved If your idea pitch can do these three things you have a much better chance of getting approval.

Kotlin Coroutine Fundamentals

Aggregated on: Tue Nov 09 2021 00:50:53 GMT+0000 (Coordinated Universal Time)

Similar to how cross-platform mobile app development is mainstream, technically, asynchronous or non-blocking programming is a new reality. When you’re making server-side, desktop, or mobile applications, it is important to supply Associate in Nursing expertise that’s not solely fluid from the user’s perspective, however scalable once required. Kotlin solves this downside in an exceedingly versatile approach by providing coroutine support at the language level and relegating most of the practicality to libraries.

Spring Boot: Exception Handling [Video]

Aggregated on: Tue Nov 09 2021 00:20:53 GMT+0000 (Coordinated Universal Time)

In the video below, we take a closer look at exception handling in Spring Boot. Let's get started!

Application Security Predictions Over the Next 12 Months

Aggregated on: Tue Nov 09 2021 00:20:53 GMT+0000 (Coordinated Universal Time)

Editor's Note: The following is an article written for and published in DZone's 2021 Application Security Trend Report. Cybersecurity is evolving with companies investing in artificial intelligence (AI) and machine learning (ML) to bolster security capabilities. Hacking incidents are becoming the norm at the enterprise level, and companies are leveraging AI technology in response to these growing cyber threats. From Equifax, Hotel Marriot, NetEase, and Yahoo, these companies suffered major data breaches that exposed personal information and accounts. Social media companies have not been spared from hacking. Facebook, LinkedIn, and Chinese social platform Sina Weibo have come under attack from cyber criminals in the past.

Extending Third-Party APIs in Different Languages

Aggregated on: Mon Nov 08 2021 23:50:53 GMT+0000 (Coordinated Universal Time)

The need for shorter and shorter Time-To-Market requires to integrate more and more third-party libraries. There's no time for the NIH syndrome anymore if it ever was. While most of the time, the library's API is ready to use, it happens that one needs to "adapt" it to the codebase sometimes. How easy the adaptation is depends a lot on the language. For example, in the JVM, there are a couple of Reactive-Programming libraries: RxJava, Project Reactor, Mutiny, and coroutines. You might need a library that uses types of one library, but you based your project on another.

5 Best JetBrains Extensions for Refactoring and Code Quality

Aggregated on: Mon Nov 08 2021 20:05:53 GMT+0000 (Coordinated Universal Time)

If you care about code quality — then these five JetBrains IDEs plugins are for you! They'll help you clean up your code, refactor more easily, report tech debt, and ultimately write quality code faster. 1. Stepsize Stepsize is an editor-first issue tracker for a healthy codebase. It allows you to bookmark and report technical debt and code to refactor. If you come across code that requires refactoring but you don’t have time to do it right away, you can make it visible and raise an issue directly in VS Code.

Spring Boot FreeMarker Tutorial With Example | Spring Boot Tutorial [video]

Aggregated on: Mon Nov 08 2021 19:05:53 GMT+0000 (Coordinated Universal Time)

In the video below, we take a closer look at Spring Boot FreeMarker Tutorial with Example | Spring Boot Tutorial. Let's get started!

4 Resources on Software Team Productivity Everyone Should Know

Aggregated on: Mon Nov 08 2021 17:50:53 GMT+0000 (Coordinated Universal Time)

Throughout my tech career, I've met a multitude of idealistic people who believe following idea X or methodology Y will somehow magically transform a team or an organization. In reality, if you want to make software teams more productive, there are no silver bullets. Every software organization is different. People come from different cultures and circumstances. They have varying levels of experience, motivations, and personalities.

API Security Weekly: Issue 158

Aggregated on: Mon Nov 08 2021 17:50:53 GMT+0000 (Coordinated Universal Time)

This week, we have news on a breach affecting 400 000 users of a popular German school app, and another vulnerability in a popular WordPress plugin. In addition, there’s a thought-provoking opinion piece on the value of GraphQL on public interfaces, and an article featuring nine useful API testing tools. Breach: Sensitive Data of 400 000 German Students Exposed by API Flaw Last week, the news broke of a breach on a popular German student community app, Scoolio, discovered by security researcher Lilith Wittmann. Conservative estimates put the number of affected students to 400 000 students, but how Scoolio creates user accounts throws some uncertainty to the exact figure here.

Create and Import Custom Functions in DataWeave

Aggregated on: Mon Nov 08 2021 17:50:53 GMT+0000 (Coordinated Universal Time)

The article will showcase the creation of a file with custom functions and then show how to import them in DataWeave. Creating a File With Custom Functions A .dwl file for custom functions is created in src/main/resources under a folder called module.

Frustrated With New Data? Vector Database Can Help

Aggregated on: Mon Nov 08 2021 17:20:52 GMT+0000 (Coordinated Universal Time)

In the era of Big Data, what database technologies and applications will come into the limelight? What will be the next game-changer? With unstructured data representing roughly 80-90% of all stored data; what are we supposed to do with these growing data lakes? One might think of using traditional analytical methods, but these fail to pull out useful information if any info at all. To answer this question, this article discusses the design and challenges faced when building a general-purpose vector database system.

Remove Incidents From Camunda Cockpit

Aggregated on: Mon Nov 08 2021 16:20:52 GMT+0000 (Coordinated Universal Time)

Today, we are learning how to remove incidents from Camunda Cockpit. Create a Spring Boot project with the embedded Camunda Engine. Use version 7.15.0. Other Requirements: Spring Boot 2.4.3 Camunda 7.15.0 Eclipse or any other IDE Maven Steps Install required dependencies. Now create one simple service task in Camunda Modeler and add the Java Class as Delegate Expression. Use Camunda Modeler to save the below XML content with .bpmn extension to get the process model, which has service tasks as components. XML Flow_1jywq5w Flow_1wvoxke Flow_1jywq5w Flow_1wvoxke Flow_1a8mncl Flow_1a8mncl " data-lang="application/xml"> <?xml version="1.0" encoding="UTF-8"?> <bpmn:definitions xmlns:bpmn="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI" xmlns:dc="http://www.omg.org/spec/DD/20100524/DC" xmlns:camunda="http://camunda.org/schema/1.0/bpmn" xmlns:di="http://www.omg.org/spec/DD/20100524/DI" id="Definitions_17f2lxv" targetNamespace="http://bpmn.io/schema/bpmn" exporter="Camunda Modeler" exporterVersion="4.5.0"> <bpmn:collaboration id="Collaboration_07k12v5"> <bpmn:participant id="Participant_1x8s9fh" name="Start Process" processRef="StartProcess" /> </bpmn:collaboration> <bpmn:process id="StartProcess" isExecutable="true"> <bpmn:startEvent id="StartEvent_1" name="start"> <bpmn:outgoing>Flow_1jywq5w</bpmn:outgoing> </bpmn:startEvent> <bpmn:endEvent id="Event_03t38ul" name="end"> <bpmn:incoming>Flow_1wvoxke</bpmn:incoming> </bpmn:endEvent> <bpmn:sequenceFlow id="Flow_1jywq5w" sourceRef="StartEvent_1" targetRef="Activity_0oy4xym" /> <bpmn:serviceTask id="Activity_0oy4xym" name="Incidents Class" camunda:asyncBefore="true" camunda:delegateExpression="#{checkIncidentsDelegate}"> <bpmn:incoming>Flow_1jywq5w</bpmn:incoming> <bpmn:outgoing>Flow_1wvoxke</bpmn:outgoing> </bpmn:serviceTask> <bpmn:sequenceFlow id="Flow_1wvoxke" sourceRef="Activity_0oy4xym" targetRef="Event_03t38ul" /> <bpmn:endEvent id="Event_07h1zeh"> <bpmn:incoming>Flow_1a8mncl</bpmn:incoming> </bpmn:endEvent> <bpmn:sequenceFlow id="Flow_1a8mncl" sourceRef="Event_00wg3ai" targetRef="Event_07h1zeh" /> <bpmn:boundaryEvent id="Event_00wg3ai" attachedToRef="Activity_0oy4xym"> <bpmn:outgoing>Flow_1a8mncl</bpmn:outgoing> <bpmn:errorEventDefinition id="ErrorEventDefinition_0oqk8gt" errorRef="Error_0jgkptt" /> </bpmn:boundaryEvent> </bpmn:process> <bpmn:error id="Error_0jgkptt" name="ERROR_CATCH" errorCode="ERROR_CATCH" /> <bpmndi:BPMNDiagram id="BPMNDiagram_1"> <bpmndi:BPMNPlane id="BPMNPlane_1" bpmnElement="Collaboration_07k12v5"> <bpmndi:BPMNShape id="Participant_1x8s9fh_di" bpmnElement="Participant_1x8s9fh" isHorizontal="true"> <dc:Bounds x="129" y="60" width="600" height="290" /> </bpmndi:BPMNShape> <bpmndi:BPMNEdge id="Flow_1jywq5w_di" bpmnElement="Flow_1jywq5w"> <di:waypoint x="268" y="190" /> <di:waypoint x="330" y="190" /> </bpmndi:BPMNEdge> <bpmndi:BPMNEdge id="Flow_1wvoxke_di" bpmnElement="Flow_1wvoxke"> <di:waypoint x="430" y="190" /> <di:waypoint x="532" y="190" /> </bpmndi:BPMNEdge> <bpmndi:BPMNEdge id="Flow_1a8mncl_di" bpmnElement="Flow_1a8mncl"> <di:waypoint x="390" y="248" /> <di:waypoint x="390" y="310" /> <di:waypoint x="462" y="310" /> </bpmndi:BPMNEdge> <bpmndi:BPMNShape id="_BPMNShape_StartEvent_2" bpmnElement="StartEvent_1"> <dc:Bounds x="232" y="172" width="36" height="36" /> <bpmndi:BPMNLabel> <dc:Bounds x="239" y="215" width="23" height="14" /> </bpmndi:BPMNLabel> </bpmndi:BPMNShape> <bpmndi:BPMNShape id="Event_03t38ul_di" bpmnElement="Event_03t38ul"> <dc:Bounds x="532" y="172" width="36" height="36" /> <bpmndi:BPMNLabel> <dc:Bounds x="541" y="215" width="19" height="14" /> </bpmndi:BPMNLabel> </bpmndi:BPMNShape> <bpmndi:BPMNShape id="Activity_07zt6e5_di" bpmnElement="Activity_0oy4xym"> <dc:Bounds x="330" y="150" width="100" height="80" /> </bpmndi:BPMNShape> <bpmndi:BPMNShape id="Event_07h1zeh_di" bpmnElement="Event_07h1zeh"> <dc:Bounds x="462" y="292" width="36" height="36" /> </bpmndi:BPMNShape> <bpmndi:BPMNShape id="Event_0z0tiw2_di" bpmnElement="Event_00wg3ai"> <dc:Bounds x="372" y="212" width="36" height="36" /> </bpmndi:BPMNShape> </bpmndi:BPMNPlane> </bpmndi:BPMNDiagram> </bpmn:definitions> 4. Now, try to create one exception inside the Java Class so it will produce an incident in Camunda Cockpit. Create one more BPMN file which contains the time scheduler as in the below XML file. Here, I am creating a time scheduler to remove incidents that are created.

Java and Immutability: Making Predictable Applications

Aggregated on: Mon Nov 08 2021 15:35:52 GMT+0000 (Coordinated Universal Time)

What This Article About Immutability is a broad concept and has many angles. Immutability is a set of practices that potentially might reduce the number of bugs in your application. As a consequence, this subject invokes confusion. Here, we review it from a different perspective. I'll explain the most important immutability aspects in clear language. Mutability Problems Examples Before we start, let's review two examples. They are pretty artificial but explain potential problems with mutable code:

Test-Driven Development With The oclif Testing Library: Part One

Aggregated on: Mon Nov 08 2021 15:05:52 GMT+0000 (Coordinated Universal Time)

While writing a CLI tool can be a lot of fun, the initial setup and boilerplate—parsing arguments and flags, validation, subcommands—is generally the same for every CLI, and it’s a drag. That’s where the oclif framework saves the day. The boilerplate for writing a single-command or multi-command CLI melts away, and you can quickly get into the code that you actually want to write. But wait—there’s more! oclif also has a testing framework that lets you execute your CLI the same way a user would, capturing standard output and errors so that you can test expectations. In this article, I'll show you how to write and test an oclif CLI application with ease.

Technical Sharing: How to Modify Milvus Advanced Configurations

Aggregated on: Mon Nov 08 2021 15:05:52 GMT+0000 (Coordinated Universal Time)

Background While using the Milvus vector database, you will need to modify the default configuration to satisfy the requirements of different scenarios. Previously, a Milvus user shared on How to Modify the Configuration of Milvus Deployed Using Docker Compose. And in this article, I would like to share with you how to modify the configuration of Milvus deployed on Kubernetes. Modify the Configuration of Milvus on Kubernetes You may choose different modification plans according to the configuration parameters you wish to modify. All Milvus configuration files are stored under Milvus/Configs. While installing Milvus on Kubernetes, a Milvus Helm Chart repository will be added locally. By running helm show values milvus/milvus, you can check the parameters that can be modified directly with Chart. For the modifiable parameters with Chart, you can pass the parameter using --values or --set. For more information, see Milvus Helm Chart and Helm.

Monolith vs. Microservices: The Battle of the Century

Aggregated on: Mon Nov 08 2021 13:20:52 GMT+0000 (Coordinated Universal Time)

There are many things beyond coding that need to be done to have a product ready (making a build, running tests, deploying, monitoring, scaling, etc.). All of this needs to be figured out just once for a monolith. However, it needs to be repeated for each of the microservices. In the best case, your microservices are based on a similar technology stack to reuse it. In the worst case, you will need to reinvent the wheel for each of them. (A small note: Some of these pains are gradually solved by tooling, but only some of them).\n\n> Who should wake up at 2 am if your service started to limp? A dedicated Ops team for the monolith usually has enough knowledge to solve the first level of problems (and allow you to handle the rest at 8 am). As soon as you have hundreds of microservices, you end up quite often with a couple of people (or maybe even just one) who know how to keep that specific service alive. It is not fun to be woken up at that 2 am just because some monitoring had a false positive. Also, this incredibly increases operational risks (what happens when that one person who knows some specific microservice is on vacation in someplace without an internet?)\n\n> Moving code within monolith and changing interfaces generally isn’t that bad. Moving code between microservices and changing interfaces (including handling versioning and backward compatibility) is incredibly expensive.\n\n> This interface change story becomes especially painful if you didn’t partition your application perfectly the first time around and find that some pieces of logic belong to the wrong microservice. And I can promise, you didn’t partition it perfectly. It would be naive to assume that initial thinking (which probably was implemented on day one) will be perfectly correct for subsequent years.\n\n> Monolith uses the same language, framework, and so on. As a result, moving people between parts of a monolith is easy. Moving people between different microservices (which may have very different tech stacks) is hard.\n\n> Debugging something across a set of microservices is painful, to say the least. Anybody who had to chase a bug across 4–5 microservices back and forth for days, to find that one of them didn’t do some validation would understand.\n\nI am pretty sure there are a lot of other cons. However, even this list makes me question microservices as a panacea.\n\nOk. Monolith is bad. Microservices are bad… Ahhhh… Everything is bad. There is nowhere to run. What do we do?\n\nThe biggest problem is not monolith per se (or microservices per se), but rather extremes that bring about. And unfortunately, teams/companies may not recognize problems in time and start addressing them until they get completely out of hand.\n\nMonolith becomes big and tends to continue to grow and worsen. When you realize it’s a problem, it’s already so big and hairy that breaking it down becomes an almost impossible task.\n\nMicroservices are often used prematurely, they grow in numbers and complexity of their interactions., And as a result, it brings all the problems which I described above.\n\nMy take on it, you need to have right-size-services © :) First of all, I believe the good idea is to start with reasonably monolithic architecture (one or a couple of services). As they began to grow, look for natural cracks (pieces of code with very different attributes). These is the pieces that could be gradually separated into standalone services.\n\nTo give you an example. I was working on some back-end service, and we found that one part was called way more often than others. It needs to scale horizontally way more aggressively than the rest. Also, we found that the current architecture for this piece was a bit problematic, and it had a reasonably small amount of dependencies on the rest of the backend. Well. Here you have a perfect candidate to be extracted as a separate service.\n\nTwo additional warnings/notes.\n\nIt would help if you kept an eye on the monolith. It’s easy to miss the point when it gets out of hand. It’s better to start separating things a bit premature than doing it too late. My gut feeling is that as soon as you begin spending around 5% of your time fighting monolith problems, it’s time to do something about it.\n\nA lot of companies are very resistant to non-trivial refactoring efforts. It comes from multiple places. Engineers always like to refactor things whether it’s necessary or not. As a result, management is pretty skeptical of this. Additionally, big refactoring or rewrites increase risk (which managers are not fond of). I would recommend you start preparing upfront (taking about benefits, stages, minimization of risks, and so on). This way it allows to build consensus and be ready to execute.\n\nIt’s hard to tell who wins in this fight between monolith and microservices. Pretty much, you have to balance between this too, starting with simple (monolith) and moving towards separating complexities (microservices)\n\nThis story is written for Demando and originally published at https://demando.se on August 25, 2021.\n\nPlease follow me on Medium, subscribe via email and share this article."}">Let me announce contenders. In the red corner is a former title champion in a super heavyweight category — Mr. Monolith. In the blue corner is a young and pumped-up gang of microservices in a featherweight category. There are many things beyond coding that need to be done to have a product ready (making a build, running tests, deploying, monitoring, scaling, etc.). All of this needs to be figured out just once for a monolith. However, it needs to be repeated for each of the microservices. In the best case, your microservices are based on a similar technology stack to reuse it. In the worst case, you will need to reinvent the wheel for each of them. (A small note: Some of these pains are gradually solved by tooling, but only some of them).\n\n> Who should wake up at 2 am if your service started to limp? A dedicated Ops team for the monolith usually has enough knowledge to solve the first level of problems (and allow you to handle the rest at 8 am). As soon as you have hundreds of microservices, you end up quite often with a couple of people (or maybe even just one) who know how to keep that specific service alive. It is not fun to be woken up at that 2 am just because some monitoring had a false positive. Also, this incredibly increases operational risks (what happens when that one person who knows some specific microservice is on vacation in someplace without an internet?)\n\n> Moving code within monolith and changing interfaces generally isn’t that bad. Moving code between microservices and changing interfaces (including handling versioning and backward compatibility) is incredibly expensive.\n\n> This interface change story becomes especially painful if you didn’t partition your application perfectly the first time around and find that some pieces of logic belong to the wrong microservice. And I can promise, you didn’t partition it perfectly. It would be naive to assume that initial thinking (which probably was implemented on day one) will be perfectly correct for subsequent years.\n\n> Monolith uses the same language, framework, and so on. As a result, moving people between parts of a monolith is easy. Moving people between different microservices (which may have very different tech stacks) is hard.\n\n> Debugging something across a set of microservices is painful, to say the least. Anybody who had to chase a bug across 4–5 microservices back and forth for days, to find that one of them didn’t do some validation would understand.\n\nI am pretty sure there are a lot of other cons. However, even this list makes me question microservices as a panacea.\n\nOk. Monolith is bad. Microservices are bad… Ahhhh… Everything is bad. There is nowhere to run. What do we do?\n\nThe biggest problem is not monolith per se (or microservices per se), but rather extremes that bring about. And unfortunately, teams/companies may not recognize problems in time and start addressing them until they get completely out of hand.\n\nMonolith becomes big and tends to continue to grow and worsen. When you realize it’s a problem, it’s already so big and hairy that breaking it down becomes an almost impossible task.\n\nMicroservices are often used prematurely, they grow in numbers and complexity of their interactions., And as a result, it brings all the problems which I described above.\n\nMy take on it, you need to have right-size-services © :) First of all, I believe the good idea is to start with reasonably monolithic architecture (one or a couple of services). As they began to grow, look for natural cracks (pieces of code with very different attributes). These is the pieces that could be gradually separated into standalone services.\n\nTo give you an example. I was working on some back-end service, and we found that one part was called way more often than others. It needs to scale horizontally way more aggressively than the rest. Also, we found that the current architecture for this piece was a bit problematic, and it had a reasonably small amount of dependencies on the rest of the backend. Well. Here you have a perfect candidate to be extracted as a separate service.\n\nTwo additional warnings/notes.\n\nIt would help if you kept an eye on the monolith. It’s easy to miss the point when it gets out of hand. It’s better to start separating things a bit premature than doing it too late. My gut feeling is that as soon as you begin spending around 5% of your time fighting monolith problems, it’s time to do something about it.\n\nA lot of companies are very resistant to non-trivial refactoring efforts. It comes from multiple places. Engineers always like to refactor things whether it’s necessary or not. As a result, management is pretty skeptical of this. Additionally, big refactoring or rewrites increase risk (which managers are not fond of). I would recommend you start preparing upfront (taking about benefits, stages, minimization of risks, and so on). This way it allows to build consensus and be ready to execute.\n\nIt’s hard to tell who wins in this fight between monolith and microservices. Pretty much, you have to balance between this too, starting with simple (monolith) and moving towards separating complexities (microservices)\n\nThis story is written for Demando and originally published at https://demando.se on August 25, 2021.\n\nPlease follow me on Medium, subscribe via email and share this article."}">I saw several serious monoliths in my life. One of them had about 5+ hours of build time, and the company had to build their own CI to keep moving forward.

Why Programs Fail – A Book Review

Aggregated on: Mon Nov 08 2021 12:50:52 GMT+0000 (Coordinated Universal Time)

When I got my new job as a developer advocate, one of the first things I asked for was books. Lots of books. Some of them cover my new job and others talk about debugging. I’ve been debugging for decades, but I feel like the theory around debugging is a bit vague. My goal was to bolster the terminology used by academics and peers. A secondary goal is to see how others teach ideas related to debugging. The first book I received was “Why Programs Fail – a guide to systematic debugging” (second edition) by Andreas Zeller. I think this book is only half of the equation, the other half is Andreas’s wonderful website debuggingbook.org. I liked both even though I’m not exactly in the target demographic for either one. Andreas is a professor at Saarland University and as such has written a book and website both of which are designed as course material. They are still enjoyable without taking a course. I will qualify that both are (for the most part) mostly aimed at beginners.

Everything You Need To Know About the Benefits of Hyperautomation

Aggregated on: Mon Nov 08 2021 08:35:52 GMT+0000 (Coordinated Universal Time)

Automation wasn’t well-received when it was first introduced among the different industry verticals. Most companies were hesitant in employing this new technology simply because they feared what they didn't fully understand. As time went on, automation technology slowly became accepted until it turned into the norm. New trend, especially such as hyperautomation is being pushed forward with a growing number of businesses changing their ways to a more “people-centric” approach.

A Complete Guide to Shift Left Testing

Aggregated on: Mon Nov 08 2021 08:35:52 GMT+0000 (Coordinated Universal Time)

In a conventional software development project, testing happened right before the software was released into production. This meant that if defects or usability concerns were discovered, the launch would be postponed until those issues were resolved. In this approach, testing became a significant bottleneck, making it difficult for projects to be completed by the set deadlines. Because development and quality assurance (QA) were different entities, projects could not adapt to shifting requirements and expectations, resulting in unfavorable business results.

A List of Java Cache Providers

Aggregated on: Sun Nov 07 2021 19:05:52 GMT+0000 (Coordinated Universal Time)

Last week, we described several criteria to look at to choose a cache. This week, it’s time to list Java cache providers based on these criteria. Java Caching System Guava Caffeine Ehcache Infinispan Coherence Community Edition Ignite Geode Hazelcast Java Caching System JCS is a distributed caching system written in Java. It is intended to speed up applications by providing a means to manage cached data of various dynamic natures. Like any caching system, JCS is most useful for high read, low put applications. Latency times drop sharply and bottlenecks move away from the database in an effectively cached system.

Creating Mappers Without Creating Underlying Objects in Java

Aggregated on: Sun Nov 07 2021 18:05:52 GMT+0000 (Coordinated Universal Time)

As most Java developers know, putting values in a Java Map (like a HashMap) involves creating a large number of auxiliary objects under the covers. For example, a HashMap with int keys and long values might, for each entry, create a wrapped Integer, a wrapped Long object, and a Node that holds the former values together with a hash value and a link to other potential Node objects sharing the same hash bucket. Perhaps even more tantalizing is that a wrapped Integer might be created each time the Map is queried! For example, using the Map::get operation. In this short tutorial, we will devise a way of creating an object-creation-free, light-weighted mapper with rudimentary lookup capability that is suitable for a limited number of associations. The mapper is first created and initialized, whereafter it can be queried. Interestingly, these mappers can also be serialized/deserialized and sent over the wire using Chronicle’s open-source libraries without incurring additional object creation.

How to Produce a Spring REST API Following the OpenAPI Specification

Aggregated on: Sun Nov 07 2021 17:35:52 GMT+0000 (Coordinated Universal Time)

The OpenAPI specification defines how to write HTTP APIs that can be consumed by any programming language and provide insight into the APIs’ functionality without access to source code or documentation. In other words, following the specification makes it easier for consumers to understand what it does and how to use it. Tools, such as Swagger, can then be used to display documentation without developers maintaining documentation separate from an API’s code. All these described points translate into happier users while mitigating some of the burdens you’ll face while supporting your APIs.

Nebula Graph: How to Implement Variable-Length Pattern Matching

Aggregated on: Sun Nov 07 2021 16:20:52 GMT+0000 (Coordinated Universal Time)

At the very heart of openCypher, the MATCH clause allows you to specify simple query patterns to retrieve the relationships from a graph database. A variable-length pattern is commonly used to describe paths and it is Nebula Graph’s first try to get nGQL compatible with openCypher in the MATCH clause. As can be seen from the previous articles of this series, an execution plan is composed of physical operators. Each operator is responsible for executing unique computational logic. To implement the MATCH clause, the operators such as GetNeighbors, GetVertices, Join, Project, Filter, and Loop, which have been introduced in the previous articles, are needed. Unlike the tree structure in a relational database, the execution process expressed by an execution plan in Nebula Graph is a cyclic graph. How to transform a variable-length pattern into a physical plan in Nebula Graph is the focus of the Planner. In this article, we will introduce how variable-length pattern matching is implemented in Nebula Graph.

Rewrite Rules in Nginx

Aggregated on: Sun Nov 07 2021 16:20:52 GMT+0000 (Coordinated Universal Time)

Rewrite rules modify a part or whole of a URL. This is done for two reasons. First, to inform clients about the relocation of resources, and second, to control the flow to Nginx. The two general-purpose methods used widely for rewriting URLs are the return directive and the rewrite directive. Of these, the rewrite directive is more powerful. Let's discuss why it is so, as well as how to rewrite the URLs. Having a better understanding of NGINX will make it easier to follow this blog.

Encryption Key Lifecycle Management: Tools and Best Practices

Aggregated on: Sun Nov 07 2021 16:20:52 GMT+0000 (Coordinated Universal Time)

A data protection strategy is only as good as the encryption key security used. A robust cybersecurity management plan helps keep sensitive data protected and prevents data breaches. Implementing good practices and centralized tools helps effectively manage encryption key lifecycles, providing better regulatory compliance and overall security. Encryption Key Lifecycle Management: Best Practices Ensuring the security of cryptographic keys, tokens, and secrets involves different lifecycle management strategies and cybersecurity knowledge. Listed below are ten tips to keep your encryption keys safe and efficient.

Concurrency-Safe Execution Using Ballerina Isolation

Aggregated on: Sun Nov 07 2021 16:20:52 GMT+0000 (Coordinated Universal Time)

The Ballerina language establishes a concurrent friendly approach to programming through light-weighted threads called strands. This is achieved by providing support for both preemptive and cooperative multitasking. When executing a concurrent program in a multi-threaded environment, the safe usage of shared resources is pivotal. This is obtained through a language concept called isolation. In this article, we will take an in-depth look at the concurrent safety support of Ballerina and see how HTTP services can be implemented to provide timely and accurate responses using isolation. Race Condition in Concurrent Programming In order to maintain the dynamic nature of a service, the following two aspects are considered during its implementation.

How to Render Jenkins Build Parameters Dynamically

Aggregated on: Sun Nov 07 2021 16:20:52 GMT+0000 (Coordinated Universal Time)

While working with Jenkins jobs (whether they're declarative or freestyle), we often need to pass some parameters to the code being executed when triggering the job. Jenkins supports this use-case by means of parameters that you can declare and use as Groovy variables in your Jenkins job. However, often you are not aware of all the parameters in the beginning, or sometimes you want to render the parameters dynamically based on the value selected in any other parameter. Given the declarative nature of Jenkins jobs, we cannot achieve the use-case with the native Jenkins parameters available. Here comes the Active Choices parameter plugin to the rescue, which can help us render parameter values dynamically.

Separation of Reactive and Non-Reactive Code

Aggregated on: Sun Nov 07 2021 16:20:52 GMT+0000 (Coordinated Universal Time)

One of the most important distinctions to keep in mind when working with Project Reactor or any other reactive streams implementation is the difference between assembly-time vs. subscription-time in code execution. Regardless of your level of experience with reactive programming, odds are you’ve already encountered the famous:

Understanding Performance Capabilities of Data Warehouses

Aggregated on: Sun Nov 07 2021 15:50:52 GMT+0000 (Coordinated Universal Time)

Don't you really hate latency? Yeah, I hate it too. Today, I want to talk about building applications on top of data warehouses. I want to discuss how to achieve low latency if your app is consuming data from BigQuery, Snowflake, Redshift, or any other cloud-based data warehouse.

Auto_Explain: How to Log Slow Postgres Query Plans Automatically

Aggregated on: Sun Nov 07 2021 15:50:52 GMT+0000 (Coordinated Universal Time)

Do you want to know why a PostgreSQL query is slow? Then EXPLAIN ANALYZE is a great starting point. But query plans can depend on other server activity, can take a while to run, and can change over time, so if you want to see the actual execution plans of your slowest queries, auto_explain is the tool you need. In this post, we’ll look into what it does, how to configure it, and how to use those logs to speed up your queries. What Is Auto_Explain? Auto_explain is a PostgreSQL extension that allows you to log the query plans for queries slower than a (configurable) threshold. This is incredibly useful for debugging slow queries, especially those that are only sometimes problematic. It is one of the contribution modules, so it can be installed and configured easily on regular PostgreSQL.

How to Generate an Execution Plan With Planner

Aggregated on: Sun Nov 07 2021 15:50:52 GMT+0000 (Coordinated Universal Time)

Planner is an execution plan generator. It generates an execution plan based on the semantically valid AST that was validated by Validator and then passes the plan to Optimizer to generate an optimized execution plan. Finally, Executor will execute the optimized plan. An execution plan is composed of a series of nodes (PlanNode). Structure of Source Files Here is the structure of source files for Planner.

Four Metrics Every Mobile Developer Should Care About

Aggregated on: Sun Nov 07 2021 15:50:52 GMT+0000 (Coordinated Universal Time)

Slow apps frustrate users, which leads to bad reviews or customers that swipe left to competition. Unfortunately, seeing and solving performance issues can be a time-consuming struggle. Most developers use profilers within IDEs like Android Studio or Xcode to hunt for bottlenecks and automated performance tests to catch performance regressions in their code during development. However, testing an application before it ships is not enough.

Quick and Easy Client-side JavaScript Search With Lunr.js

Aggregated on: Sun Nov 07 2021 13:50:52 GMT+0000 (Coordinated Universal Time)

Search is a must-have for any website or application. A simple search widget can allow users to comb through your entire blog. Or allow customers to browse your inventory. Building a custom photo gallery? Add a search box. Website search functionality is available from a variety of third-party vendors. Or you can take the DIY approach and build the entire backend to answer search API calls. Lunr.js works on the client-side via JavaScript. Instead of sending calls to a backend, Lunr looks up search terms in an index built on the client-side itself. This avoids expensive back-and-forth network calls between the browser and your server. There are plenty of tutorials online to showcase Lunr’s website search functionality. But you can actually use Lunr.js to search any array of JavaScript objects.