It has come to our attention that our company was highlighted on the leaders’ list on Clutch as one of Illinois’ top software development companies.

For context, Clutch is a B2B reviews and ratings platform based in Washington, DC. They evaluate solutions companies based on the quality of their work and client reviews. Their review process is reliable and transparent, and we are grateful to those of our clients who have taken the time to provide feedback.

Take a look below at what they had to say about our services:

“Their response time is amazing. They get back to us right away and resolve any issues immediately. If they don’t know the answer right away, they look into it and get back to me as soon as possible.” – Project Manager, Medical Certification Company

“The team works within their timelines and delivers great, high-quality products. One contact from my side works with the developers, and she loves them.” – Founder & CEO, A07 Online Media LLC

The team at Loadsys Solutions is extremely grateful for this amazing award. We are especially thankful to our clients for their support and trust. This recognition and the wonderful reviews are the yardsticks of our success and we will continue to work hard to provide top-notch services to our clients.

To learn more about our company, you can visit our Clutch profile. We have a lot to offer to make sure your next project goes smoothly and as planned. Send us a message today!

Every year, Clutch recognizes their Leader Award winners, the highest-ranking companies according to geographic location and service line. We are thrilled to announce that Clutch has named Loadsys Solutions a top B2B company in Illinois in the development category!

Clutch is a B2B market research firm based in Washington, DC. The platform is a company resource that features verified reviews from the former clients of B2B companies. This direct feedback ensures that all of their ratings and rankings are fair and transparent.

“It is a great honor yet again to be honored by Clutch as a Top Web Developer for 2020. Clutch has been a great partner to showcase our past work and unbiased reviews from our clients.” – Lee Forkenbrock, CEO

We are grateful for each and every one of our customers, especially those that took the time to leave us a review on Clutch! Here’s what they had to say about working with us.

“The highlight of our partnership is our communication. We’ve worked with other companies before where that was a challenge. Loadsys Solutions is very transparent and is always available..” – Project Manager, Medical Certification Company

This award and our 4.9-star rating on Clutch are all thanks to you, our amazing clients!

To learn more about us and our past work, read our reviews on Clutch. Contact us to get started on your next project today!

Setting up Redux with React could feel like a very confusing and complicated process. There are many packages to install and writing quite a bit of boiler plate code is needed to get redux to do anything. That’s where Redux Toolkit steps in.

Redux Toolkit very is simple to setup, it provides immutable update logic and warnings if your state mutates outside the state. The toolkit allows to merge the state object many levels deep through a proxy by just assigning a value to an object. You no longer need to use spread operator to merge the objects:

Before:

state = {
  user: {
    firstName: 'User',
    lastName: 'Last',
    ...newUser,
  groups: {
    sales: true,
    hr: false,
    admin: false,
    ...newUser.groups
  }
}

After:

state = _.deepMerge(state, newUser);

Redux Toolkit provides a very useful feature that allows to create the whole state management in one call and keep all of the logic and actions in the same place. There is no need to separate actions and reducers into separate files.

Instead of:

const increment = createAction('INCREMENT')
const decrement = createAction('DECREMENT')

const reducer = createReducer(0, {
  [increment]: state => state + 1,
  [decrement]: state => state - 1
})

Now we can do:

const counterSlice = createSlice({
  name: 'counter',
  initialState: 0,
  reducers: {
    increment: state => state + 1,
    decrement: state => state - 1
  }
})

const {
  increment,
  decrement
} = counterSlice.actions;

const reducer = counterSice.reducer;

createSlice allows us to configure all the actions as functions and define actions as functions and control types of passed functions, which is a must when working with Typescript. With Redux Toolkit, we can create  a completely type safe state and actions.

Here is an example:

import { createSlice, PayloadAction } from 'redux-starter-kit';
import { CompanyParams } from '../../schema/company';
import * as StateHelpers from '../../redux/stateHelpers';
import _ from 'lodash';

interface CompaniesState {
  companiesStatus: StateHelpers.StateStatusProps,
  activeCompanyId: string,
  companies: CompanyParams[],
}

const initialState: CompaniesState = {
  companiesStatus: null,
  activeCompanyId: null,
  companies: [],
};

const findIndex = (companies: CompanyParams[], searchId: string) => {
  return _.findIndex(companies, company => {
    return company.id === searchId;
  });
};

const companies = createSlice({
  name: 'companies',
  initialState: initialState,
  reducers: {
    updateStatus(state, action: PayloadAction<Partial<StateHelpers.StateStatusProps>>) {
      state.companiesStatus = StateHelpers.updateStatus(state.companiesStatus, action.payload);
    },

    saveCompanies(state, action: PayloadAction<CompanyParams[]>) {
        state.companies = action.payload;
        state.companiesStatus = StateHelpers.updateStatus(state.companiesStatus, {status: StateHelpers.StateStatuses.FETCHED});
    },

    saveCompany(state, action: PayloadAction<CompanyParams>) {
      const company = action.payload;
      const index = findIndex(state.companies, company.id);
      const companies = _.cloneDeep(state.companies);
      if (index >= 0) {
          if (!_.isEmpty(company.deleted)) {
              companies.splice(index, 1);
          } else {
              companies[index] = company;
          }
          state.companies = companies;
      }
      else if (company.id && _.isEmpty(company.deleted)) {
          companies.unshift(company);
          state.companies = companies;
      }
    },
    updateCompany(state, action: PayloadAction<Partial<CompanyParams>>) {
      const company = action.payload;
      const index = findIndex(state.companies, company.id);
      const companies = _.cloneDeep(state.companies);
      if (index >= 0) {
          companies[index] = {...companies[index], ...company};
          state.companies = companies;
      }
    },
    selectCompany(state, action: any) {
      state.activeCompanyId = action.payload;
    }
  }
});

export const {
  updateStatus,
  saveCompanies,
  saveCompany,
  updateCompany,
  selectCompany,
} = companies.actions

export default companies.reducer;

Redux Toolkit is very opinionated framework forcing developers to follow the guidelines and write the code in a similar manner thus simplifying maintenance and training. The Typescript support helps to minimize errors and testing by enforcing concrete types.

Contact us today for any React, React Native, or Redux support.

Performance

Coders can accomplish goals in a variety of ways with their programming. Inefficient coding might not seem immediately slow, but you see performance degradation as your user base continues to grow. Code that takes a millisecond to run takes much longer when it’s used much more frequently from an increase in customers. Professional programmers write code in a way that keeps performance in mind. Some quality assurance procedures include testing for performance issues.  Poorly performing code can cripple your application just by its inability to process data fast enough. For example, a coder could create a loop that processes a million records. This processing takes a heavy toll on your server resources. In most cases, instead of retrieving a million records and filtering through them on the front-end, it’s better to filter on the database and return a smaller data set to the front-end. This simple tweak dramatically improves performance.

Scalability

There’s a high probability that one day you’ll want to expand your software with more features. Without scalability, the code needs to be completely redesigned and recoded for any significant changes. That means coding time doubles whenever you need to add more complexity to the application. A good coder will keep scalability in mind as they design your software. Scalability while coding does take more time initially, but it can save you money and time in the future. For a user, there is no way to identify if the code is scalable unless you can read it. However, when you find a developer for your application, always specify that you want it to scale with future releases. One way you can ensure scalability is built into your base code is to specify the features that you want to add in the future. It’s typical for MVP applications to include only the very basics for marketability analysis, but the MVP should be able to scale in the future.

Modularity

You shouldn’t have to re-code your application if you want to expand into separate software for different pieces of your business. The code should be modular so that the next project can use current code. For instance, consider a form where users sign up for service. If the structure is modular, then it can be used on other websites that you own. Something as simple as a sign-up form can save your coders time and save you money on each new project.

Readability

Reading a programming language takes practice, but just like literature, code poorly written can be hard to understand. A lot of logic and conditions are set in code, and one not written well can make a broad application challenging to understand. Most companies want to keep the same coder for as long as possible, but it’s inevitable that you’ll need to hire help to come in and help maintain legacy applications. The first step for a programmer is to read the previous programmer’s work to get a feel for how the application works. Without well-written code, the next person to maintain the application could make more mistakes, introduce more bugs, and have a more difficult time making sure that the application runs smoothly. One way to improve readability is to ensure proper documentation of code and including comments. Most programmers will avoid doing either of these tasks, so it’s essential that you at least include documentation in your contract.

Good Code Costs More Initially But Saves Money in the Long-Run

When you shop around for a developer, you’ll note that asking for these quality items costs more. Although the initial investment is high, the quality code will cost you a lot less in the future. The benefits of having good code outweigh the alternative, which is usually ripping apart the code base and redesigning and redeveloping it when you want to expand.

What is a Docker Container?

Before discussing a docker container, it’s important to understand VMs. A VM was the traditional way IT departments would create virtual servers. You could have several VMs on one physical machine, and they would run just like a dedicated server, provided the physical hardware had enough resources to support multiple VMs.

Because applications installed on VMs were tied to the underlying hardware, moving a VM to another machine meant new configurations, increased applications bugs, and usually reinstallation of the entire environment. One main reason for this inefficiency is that VMs virtualize computer hardware. When you install an application, it’s tied to your server’s configurations, including the hardware setup.

VMs are also set up with a specific operating system. The benefit is that you can have any operating system running on one physical machine. For instance, you can run a Linux box on a Windows server and run your open-source SaaS application on it successfully without interfering with any Windows processes.

IT embraced the idea of VMs, and thousands of large and small organizations use them for various services. The issue with a large number of VMs is that they are quite bulky in terms of resource usage. They require a large amount of physical hardware such as storage, memory, and CPU cycles. The amount of resources necessary to run a VM is determined by the bulkiness of the applications running on it, but most VMs automatically expand when new resources are needed. This type of scaling can be a nightmare for IT administrators.

Docker containers solve many issues pertaining to VMs, but mainly they solve a number of performance problems. Not only are they less bulky than VMs, but the applications on docker containers are no longer tied to any single VM, so you can move them between servers seamlessly. Containers share the main operating system on the physical machine and allow you to have portable applications.

Think of a VM as a fully-hosted machine that uses a set amount of resources on a physical machine. It has its own configurations, operating system, and binary files. With a container, the operating system is the same on all dockers; the only change is the main virtualized application.

Advantages of Using Dockers

Imagine just one of your applications is compromised. Usually, this means that all applications running on your server must be checked for malware. Malware writers create backdoors to various resources on a server when they are able to find vulnerabilities. With a container, the application is in its own space, so this type of attack is neutralized. Even if an attacker is able to compromise one application, it doesn’t mean all applications on the physical machine are compromised.

You’ll often hear the term “isolation” when referring to dockers. Isolation is what allows you to run multiple applications on a single server without any of them interfering with each other. Not only does this process protect from malware, but it also prevents each application from overwriting another.

Dockers run almost twice as fast as the same application running on a single virtual machine. They don’t require the resources that a VM requires, because dockers share the underlying operating system that manages hardware. VMs virtualize their own hardware, so it’s similar to a separate machine running an operating system. With a docker, it’s similar to running a small instance on the operating system without pulling resources from the physical machine.

Your programmers will appreciate containers over VMs, because few configurations are needed. Most developers are required to test each application on the network, and a container is a quick and easy way to test your production software.

Because applications are isolated, security risks are also reduced. You still need to protect the physical machine and the operating system, but the application itself is isolated from other applications. If an attacker is able to breach one of your applications, any others on the physical machine are unlikely to be affected.

If you already have virtual machines configured in your organization, you can run containers within them. This isn’t the preferred way to configure applications and network resources, but it can be done if you have no other options and want to take advantage of dockers without retiring your VMs.

One disadvantage of dockers is that you are bound to a specific operating system. You can’t run your application on various distributions of Linux or use Linux and Windows on the same physical machine. Your application is tied to the operating system, which isn’t a major problem if your software was only meant to run on a particular OS in the first place.

Restructuring your IT architecture always involves some hurdles and testing. Most IT administrators don’t want to change anything in an environment that’s running smoothly. It’s important to deploy containers along with the installed application and test it heavily before unleashing it into production — that means you’ll be spending time and money on a project that isn’t always necessary.

If you’re looking for a solution to performance issues, docker containers could be the answer. They are especially useful in organizations that produce a number of applications. If you produce cloud applications, you can give developers and quality assurance (QA) a quick way to test their new code without affecting other containers. Docker containers can aid your process by allowing you to deploy new versions to containers, test them, and keep the original version intact.

Containers aren’t the answer to all of your performance issues, but they can solve many issues with software versioning, testing, deployment to testing environments, and even streamlining your application security. It takes some time to learn the nuances of VMs versus containers, but the change will ultimately make deployment and application performance easier for IT administrators.

Contact us if you want more help or support in docker containers — our team of experts are ready to answer any questions!