Technology stacks: the current scenario

Technology evolves faster than any business sector. In the blink of an eye, something new arrived to become the darling of companies around the world. Take containers, for example.

Before container technology (and especially Kubernetes), companies relied on monolithic application stacks to deploy applications and services. A great example of a monolithic stack is LAMP (Linux, Apache, MySQL, PHP). This stack has helped power businesses for decades.

But, as we said, evolution happens very quickly.

These days, fully realized technology stacks appear as quickly as simple applications. And developers are taking bits and pieces and putting them together in increasingly creative ways until the market is flooded with new and different stacks.

This, of course, raises our first question.

What is a technology stack?

Simply put, a technology stack is a combination of programming languages, frameworks, and tools that come together to enable developers to create web or mobile applications and services.

Let's take the LAMP stack as an example. This very popular stack includes:

• A programming language (specifically, one for CGI scripts) – PHP
• A web server – Apache
• One operating system – Linux
• A database – MySQL or MariaDB

With this stack, you can deploy powerful and dynamic applications for a variety of purposes. However, this combination is not the de facto standard by which all stacks are constructed.

This is especially true in the modern, mobile era. Today, software engineers need the ability to develop and deploy their applications much faster than a LAMP stack offers. This is where structure comes into play. When a framework is added to the mix, work is more efficient and less redundant.

A more modern stack can be divided into 7 different categories. Each stack or service can be stacked on top of other stacks/services to create a robust and complete application or service.

Operating systems/programming languages

This would be the base stack from which everything else is built. For this stack, you must choose an operating system and programming languages ​​needed for the project. The operating system you choose will mostly depend on your comfort level or the requirements of the other stacks you will be using. In many cases, the most popular operating system for technology stacks is Linux.

The programming language, on the other hand, will be determined by the project. You can use Java, JavaScript, .NET, C++, Ruby, Python or any language that allows the development of the application or service.

Servers and load balancing

Here we have the category involving servers, as well as hardware/software for content delivery networks, routing, caching services, resource management, RBAC, fundamental services (such as compute, storage and networking). This specific stack allows applications and services to receive requests from users and applications, run smoothly, and scale as demand increases. An example of this is AzureStack, which includes a load balancing component.

Data storage and data query

At this level, you'll find a stack consisting of relational and non-relational databases, as well as data warehouses, data lakes, and data pipelines. Without this stack, your applications cannot be dynamic in nature, nor can they store data for querying or later use.

The data stack relies on input from data sources, which can come from various services like Facebook, Twitter, user input, Google Analytics, Salesforce, and (of course) databases. Once the data stack receives input, it can generate information for business analysis.

Server-side stack

The server-side (or backend) stack adds much of the basic functionality needed to build applications to the backend of your application stack. This will provide the necessary components for things like database communication, handling user requests, and password resets. This stack is invisible to end users and provides the backbone of the application.

The most common components of the server-side stack include programming languages ​​like Python and Ruby, frameworks like Django and Ruby on Rails, and the Node.js JavaScript runtime environment. The server-side stack can also include databases (such as MySQL) and web servers (such as Apache).

Client-side stack

The client-side stack (also known as the front-end stack) is what end users see displayed on their screens. This stack includes all the components needed to build GUIs for your applications, such as HTML, CSS, and JavaScript, as well as the React and Angular frameworks. Some developers prefer to be full-stack developers, which means they can do both server-side and client-side development.

API Stack

This isn't so much a stack in and of itself, but it's an absolutely crucial component of putting together stacks that can actually work. The API Stack allows you to connect all the tools across your entire technology stack. Many of these API Stacks consist of thousands of pre-built APIs and are divided into 2 layers, one for services and one for infrastructure.

Monitoring tools and services

When building your stack (or using a pre-built one), you will also need the tools and services necessary to monitor the health and performance of these components and services. And you may believe that you can just monitor the performance of the application as a whole, but you may find it necessary (depending on how you built your application or service) to monitor some of the individual stacks. You may need to place a specific monitor on the server stack, data storage stack, or operating system stack.

Making your monitoring very granular allows you to optimize the stack as a whole more consistently and reliably. Additionally, the data you receive from monitoring these individual stacks can be invaluable for tuning the performance of each individual part. In the end, this granularity allows you to tune your stack for the best possible performance.

Which technology stack should you choose?

The answer to this question is complicated because it absolutely depends on the nature of your project. But it's critical to choose the right technology stack from the start. If you go the wrong way, you may have to start over halfway through the building process. And wasted time is wasted money.

It is also critical to select a technology stack that is capable of scaling to meet your needs. For example, if you add a relational database to a stack that will be used for an application that will handle millions of requests per hour, your stack cannot scale to meet that demand. Instead, you should use a NoSQL database for this stack.

There are several very popular technology stacks to choose from. Let's take a look at some of the most popular ones.

TO MEAN

The MEAN stack is one of the most popular stacks for building dynamic websites and web applications. This stack is JavaScript-centric and is comprised of:

• MongoDB – database
• Express.js – backend framework
• Angular.js – front-end framework
• Node.js – cross-platform server

The main reason MEAN is so popular is its JavaScript-centric nature. This means your developers only need to focus on a single language (instead of bringing together multiple languages ​​for a single project). This makes it possible to quickly build applications and services, such as:

• Tools for Workflow Management
• Expense Tracking Apps
• News aggregation sites
• Mapping and location apps
• To-Do and Calendar Apps
• Interactive forums

The reason MEAN is so important is that it allows you to create scalable, cloud-native applications with a simplified development lifecycle using a single language. With the help of MongoDB, your MEAN-based applications can work with large amounts of data, so they are perfectly suited for enterprises. Finally, since MEAN has an integrated web server, deployment is quite simple.

MEVN

MEVN is similar to MEAN, but swaps Angular.js for Vue.js. Why? Vue.js is considered a great option for front and back development and makes deploying dynamic user-facing web applications very easy. MEVN means:

• MongoDB – database
• Express.js – backend framework
• Vue.js – front-end framework
• Node.js – cross-platform server

For any developer who wants to deploy front-end web applications with lightning speed, MEVN is the stack to use. And thanks to Vue.js' ability to work with third-party services, it is quite flexible and can provide the best of both the Angular and React worlds. With the addition of Vue.js. your web applications will enjoy remarkable performance.

The two main advantages of the MEVN stack are that it uses JavaScript throughout the development lifecycle and has a clearer client-side versus server-side construction. And since Vue.js is easier to use than Angular, it will be easier for your developers to get comfortable with this stack.

MERN

This is another stack similar to MEAN, but it replaces the Angular.js front-end framework with React. Since React is one of the most popular frameworks for building single-page mobile apps, you can rest assured that MERN is one of the top frameworks for building in the mobile space.

MERN means:

• MongoDB – database
• Express.js – backend framework
• React – front-end framework
• Node.js – cross-platform server

MERN offers a similar advantage to MEAN because it uses JavaScript throughout the development lifecycle. And because MERN uses the MVC (Model-View-Controller) architecture, the development process should be quite familiar to your engineers. Thanks to React and its asynchronous behavior, it is possible to have incredible performance in front-end applications. Finally, React is used by some of the most popular websites in the world, like Facebook and Dropbox, so it's highly capable of meeting the needs of businesses of any size.

LIGHT BULB

We've already mentioned the LAMP stack, but it should be included on this list because of how widespread and crucial this stack is. The LAMP stack consists of:

• Linux – operating system
• Apache – web server
• MySQL (or MariaDB) – database
• PHP – CGI language

The LAMP stack is often the base stack used for WordPress website deployments. It is also possible to exchange several components. For example, you can swap Linux for Windows to create a WAMP stack or macOS to create a MAMP stack. You can put Perl or Python in place of PHP. But no matter how you build this stack, it's one of the most popular web server stacks on the market and is used by millions of websites around the world.

Meteor.js stack

This is another open source web development stack. Meteor.js focuses entirely on JavaScript to make app development much more efficient. With Meteor.js you can develop applications for desktop, mobile and web and even integrate with various frameworks and tools. The only downside to Meteor.js is that it only works with the MongoDB NoSQL database, so your developers must know this tool to successfully build with this stack.

The advantage of Meteor.js is that you can write applications with significantly less code than other stacks. Meteor.js also allows you to build highly scalable applications. Other advantages include:

• Incredibly simple to use
• Seamless communication between client and server
• Real-time testing tools
• Excellent debugging capabilities
• Lots of packages and libraries to work with

Serverless

You might think this isn't a stack, but it is. But what is serverless? Basically, it's not about managing servers. Cloud platforms like AWS, Google Cloud, and Azure offer serverless solutions. And all of these third-party hosts offer full stacks, which will include everything you need to build and deploy.

There are three main advantages to not using a server:

• It's economical
• You don't need to worry about hardware provisioning
• Offers massive scalability

The Serverless Stack is an extension to the AWS CDK and features an active Lambda development environment, support for setting breakpoints and debugging in VS Code, supports deployment across multiple regions and environments, includes higher-level builds, and uses support from Zero configuration for JavaScript, TypeScript, Go, Python, C# and F#.

JAMstack

JAMstack isn't as popular as the other stacks on the list, but it's becoming increasingly useful for modern web development.

JAM means:

• JavaScript
• APIs
• Marking

JAMstack is specifically aimed at website development. What's important to understand with JAMstack is that development is completely disconnected from hosting. Because of this, you can build websites in the environment of your choice and then any changes you make to the build will be deployed to a static site generator or CDN. After the build is deployed, the new site will be generated.

JAMstack is a great option for building fast static websites and even automating the process (in a similar way to CI/CD). It's important to understand that you can select the components you prefer for each section (such as React for JavaScript, Elastic for API, and Gatsby for Markup). This makes JAMstack quite flexible.

do it yourself

Here's one of the best things about technology stacks. You may not find a current stack that meets your project needs. You know exactly what you're building, but none of the stacks offer everything you need.

This is where the Do It Yourself mentality comes into play. With so much technology available, you can build a whole new stack to create exactly what your project needs. Maybe this project needs a LAMA stack: Linux, Apache, MongoDB, Angular. Or maybe it's all about the JAN (JavaScript, Apache, Node.js) stack. You may even need to base your project on a LAN stack (Linux, NGINX, Node.js).

The beauty of technology stacks is that they are not set in stone. In fact, there is no limit to the stacks you can create. But if you go this route, it's absolutely critical that you know what you need the stack to do, what the constituent parts can communicate with each other, and what the stack can deliver in terms of reliability, uptime, scalability, and flexibility.

If you built your own stack and discovered halfway through the project that it wouldn't work, you'd be back to square one. In the world of modern computing, retreat is akin to implosion. Your developers and your company must always be moving forward. If you go the DIY stack route, do it correctly and it will serve your needs well.

Conclusion

Tech stacks have been around for a long time. But over the years they have evolved into very specialized tools to help make your developers' jobs easier while also enabling your company to deploy extremely scalable, easy-to-use applications that the public can use to interact with your company. .

The most important thing you must understand, however, is that technology stacks make it possible for your developers to make use of pre-built software, so they don't have to reinvent the wheel every time they start a new project.

With all this technology available, app development is experiencing one of the biggest and fastest periods of growth in history. Thanks to the development of cloud-native, container, web, and mobile applications, technology stacks are now more important than ever.