Get started

Get started

Bring yourself up to speed with our introductory content.

• What is a data type?

  In software programming, a data type refers to the type of value a variable has and what type of mathematical, relational or logical operations can be applied on it without causing an error. Continue Reading

• 4 pseudocode examples: Python, Java, JavaScript and C++

  Successful pseudocode conversion goes beyond simply making the code work. It's about creating implementations that respect each language's conventions. Continue Reading

• My first attempt at vibe coding

  Can you teach an old programming dog a new trick? Continue Reading

• Distributed tracing vs. logging: Uses and how they differ

  Distributed tracing and logging help IT teams identify performance issues in systems in different ways. But they also complement each other to pinpoint problems. Continue Reading

• 16 REST API design best practices and guidelines

  Common guidelines for API design lead to better functionality and flexibility. Follow these REST API design best practices to help you tend to your burgeoning API garden. Continue Reading

• Definitions to Get Started

  • What is a data type?
  • What is an application architecture?
  • What is dependency injection in object-oriented programming (OOP)?
  • What is a software stack?

  • What is an API (application programming interface)?
  • What is API testing? Everything you need to know
  • What is REpresentational State Transfer (REST)
  • What is an API endpoint?

  View All Definitions

• How to write pseudocode: A guided tutorial

  Writing pseudocode might feel like an extra step, but its value becomes clear in complex projects. Focus on the logic without getting tangled in language-specific syntax.Continue Reading

• What is the strangler fig pattern, and how does it work?

  Imagine owning a motorcycle that needs fixing up. Instead of disassembling it and spending months rebuilding, what-if you replaced one part at a time so you could keep using it?Continue Reading

• Introduction to JavaFX tutorial for beginners

  Did you think desktop development in Java was dead? Far from it. Here's how JavaFX has brought desktop programming in Java back to life.Continue Reading

• 13 API security best practices to protect your business

  APIs are the backbone of most modern applications, and companies must build in API security from the start. Follow these guidelines to design, deploy and protect your APIs.Continue Reading

• APM vs. distributed tracing: How they differ

  Application performance monitoring and distributed tracing help IT teams identify performance problems in different but complementary ways, as explained here.Continue Reading

• Difference between a statement vs. expression in programming

  The decision between statement-centric and expression-oriented languages can influence an individual's programming style and the code's length, complexity and security.Continue Reading

• The basics of working with pseudocode

  Writing pseudocode is a great way to practice problem-solving skills, a crucial aspect in programming. It helps developers conceptualize and communicate their ideas.Continue Reading

• Harnessing space-based architecture for high performance

  Space-based architecture offers the modularity of a distributed microservices architecture but with submillisecond data access times. Unsurprisingly, it comes with tradeoffs.Continue Reading

• What are the types of APIs and their differences?

  Enterprises increasingly rely on APIs to interact with customers and partners. It all starts with knowing which type of API is right for your needs.Continue Reading

• Webhook vs. API: Which mechanism is better?

  Moving data in one direction? Choose a webhook. Need applications to communicate with each other? Use an API. But first, compare both methods in function, cost, security and more.Continue Reading

• 13 application performance metrics and how to measure them

  You've deployed your application, now what? Keep your application performing well by tracking metrics. Take a look at these 13 critical KPIs.Continue Reading

• What is an application architecture?

  An application architecture is a structural map of how a software application is assembled and how applications interact with each other to meet business or user requirements.Continue Reading

• Webhooks explained simply, with examples

  Webhooks make significant use of basic API call mechanisms and set event triggers in a few clicks of a button -- all without the overhead of heavy request-response structures.Continue Reading

• Managing complexity: Event-driven architecture explained

  Event-driven architecture is complex, but so are today's data challenges. Discover ways to manage dynamic and distributed interactions in this EDA explainer.Continue Reading

• 8 microservices best practices to remember

  From integrating domain-driven design to securing APIs, explore a range of microservices best practices for building a resilient and scalable application.Continue Reading

• Rust vs. Python: Strengths, challenges and use cases

  This Rust vs. Python faceoff breaks down how the two programming languages stack up against each other in terms of performance, speed, memory management and more.Continue Reading

• Rust vs. C++: Differences and use cases explained

  C++ was mature before Rust even existed. Does that mean developers should switch from C++ to Rust? Not always.Continue Reading

• An introduction to TypeSpec, a new API definition language

  Standardizing API descriptions and converting API definitions into different formats can be challenging. TypeSpec, a new API definition language, aims to solve that.Continue Reading

• The basics, benefits and risks of cell-based architecture

  Cell-based architecture adds a new twist to enterprise infrastructure by speeding deploys, improving uptime and maybe even reducing the test effort.Continue Reading

• What is dependency injection in object-oriented programming (OOP)?

  Dependency injection is a technique used in object-oriented programming (OOP) to reduce the hardcoded dependencies between objects.Continue Reading

• Dependency injection and inversion of control in Spring

  At the heart of every Spring project, be it Spring AI, Spring MVC or Spring Data, lies a powerful dependency injection and inversion of control container. Here's how it works.Continue Reading

• What is a software stack?

  A software stack is a collection of independent components that work together to support the execution of an application.Continue Reading

• Difference between the Spring Framework and Spring Boot

  You can use the Spring Framework to build microservices without using Spring Boot, but should you? To answer that, you must know the difference between Spring and Spring Boot.Continue Reading

• What is an API (application programming interface)?

  An application programming interface (API) is code that enables two software programs to communicate.Continue Reading

• What is API testing? Everything you need to know

  API testing is a type of software testing that analyzes an application programming interface (API) to verify that it fulfills its expected functionality, security, performance and reliability.Continue Reading

• Java tic-tac-toe game coding tutorial

  What's the best way to learn how to program? Code up some of your favorite childhood games. Here, we'll show you how to code a tic-tac-toe game in Java.Continue Reading

• What is REpresentational State Transfer (REST)

  REST (REpresentational State Transfer) is an architectural style for developing web services and systems that can easily communicate with each other.Continue Reading

• What is an API endpoint?

  An API endpoint is a point at which an application programming interface -- the code that enables two software programs to communicate with each other -- connects with the software program.Continue Reading

• reactive programming

  Reactive programming is a programming paradigm, or model, that centers around the concept of reacting to changes in data and events as opposed to waiting for an event to happen.Continue Reading

• object-oriented programming (OOP)

  Object-oriented programming (OOP) is a computer programming model that organizes software design around data, or objects, rather than functions and logic. An object can be defined as a data field that has unique attributes and behavior.Continue Reading

• software

  Software is a set of instructions, data or programs used to operate computers and execute specific tasks.Continue Reading

• CQRS (command query responsibility segregation)

  CQRS (command query responsibility segregation) is a programming design and architectural pattern that treats retrieving data and changing data differently.Continue Reading

• Remote Procedure Call (RPC)

  A Remote Procedure Call (RPC) is a software communication protocol that one program uses to request a service from another program located on a different computer and network, without having to understand the network's details.Continue Reading

• An introduction to the RESTful API Modeling Language (RAML)

  The RESTful API Modeling Language, or RAML, can be a powerful tool for developers looking to create an efficient, standardized API management strategy.Continue Reading

• RESTful API

  A RESTful API is an architectural style for an application programming interface that uses HTTP requests to access and use data.Continue Reading

• user interface (UI)

  The user interface (UI) is the point of human-computer interaction and communication in a device.Continue Reading

• OAuth (Open Authorization)

  OAuth (Open Authorization) is an open standard authorization framework for token-based authorization on the internet.Continue Reading

• middleware

  Middleware is software that bridges the gap between applications and operating systems by providing a method for communication and data management.Continue Reading

• Spring Framework (Spring)

  The Spring Framework (Spring) is an open source software development framework that provides infrastructure support for building Java-based applications on any deployment platform.Continue Reading

• web services

  Web services are a type of internet software that use standardized messaging protocols and are made available from an application service provider's web server for a client or other web-based programs to use.Continue Reading

• EAI (enterprise application integration)

  Enterprise application integration (EAI) is the process of connecting an organization's business applications, services, databases and other systems into an integrating framework that facilitates communications and interoperability.Continue Reading

• event handler

  In programming, an event handler is a callback routine that operates asynchronously once an event takes place.Continue Reading

• Using bounded context for effective domain-driven design

  Domain-driven design helps organizations develop software focused on key business needs. But to do so, architects need to understand the fundamentals of bounded context.Continue Reading

• state management

  Application state management is the process of maintaining knowledge of an application's inputs across multiple related data flows that form a complete business transaction -- or a session -- to understand the condition of the app at any given ...Continue Reading

• API management

  API management is the process by which an organization creates, oversees and controls application programming interfaces (APIs) in a secure, scalable environment.Continue Reading

• API lifecycle management

  API lifecycle management is a part of application programming interface management that supports the design, development and maintenance of APIs, including their transitioning from design and testing to a production environment.Continue Reading

• Object-oriented vs. functional programming explained

  While plenty of developers entertain the idea of adopting a functional programming model, it's important to first know exactly how it differs from the object-oriented approach.Continue Reading

• The 5 SOLID principles of object-oriented design explained

  In this primer on SOLID, we'll examine the five principles this development ideology embodies, the practices they encourage and the reasons these concepts matter.Continue Reading

• How to make a strong business case for software projects

  Every software project proposal requires in-depth research into the technical aspects at play, but the business case for the project should tone down the tech talk.Continue Reading

• The pros and cons of a layered architecture pattern

  Layered architecture patterns provide a consistent and secure way to organize code when implemented correctly. However, the way those layers interact should remain a top concern.Continue Reading

• interoperability

  Interoperability refers to the degree to which a software system, devices, applications or other entity can connect and communicate with other entities in a coordinated manner without effort from the end user.Continue Reading

• Comparing MERN vs. MEAN stacks for web app development

  While MERN and MEAN stacks share many common elements, their respective use of React and Angular is a defining factor in choosing one or the other.Continue Reading

• Elixir vs. Clojure for functional programming at scale

  While they don't have the prestige of JavaScript or Python, Elixir and Clojure are making a name for themselves when it comes to functional programming at scale.Continue Reading

• WSO2

  WSO2 is a middleware vendor that sells open source application program interface (API) management software.Continue Reading

• Prometheus

  Prometheus is an open source monitoring and alerting toolkit for microservices and containers that provides flexible queries and real-time notifications.Continue Reading

• The growing link between microservices and WebAssembly

  The microservices architecture has become popular, but it runs into complexity and cost challenges. Implementing WebAssembly can alleviate those worries.Continue Reading

• Serverless vs. containers: Which one for microservices apps?

  How do you know when microservices should run in containers vs. serverless functions? A big factor is what you plan to do with your microservices.Continue Reading

• What are microservices? Everything you need to know

  Microservices, or microservices architecture, is an approach to the design and implementation of enterprise applications in which a large application is built from modular components or services.Continue Reading

• Understanding the role of polymorphism in OOP

  Polymorphism is used in OOP to allow developers to write more efficient code and redefine methods for derived classes; however, it could raise real-time performance issues.Continue Reading

• Understanding protocol buffers vs. JSON

  Protocol buffers have some compelling advantages over JSON when it comes to sending data between internal services. But is it really a replacement for JSON?Continue Reading

• API economy

  The API economy refers to the set of business models and practices designed around the use of application programming interfaces (APIs) in today's digital economy.Continue Reading

• Scripting vs. programming languages: Where they differ

  Choosing a programming language is often dictated by the problem the programmer wants to solve and the compute goal that a language is designed to achieve.Continue Reading

• Kotlin vs. Scala: Which one is right for your project?

  As general-purpose programming languages, both Scala and Kotlin have a lot to offer. But that doesn't mean their uses cases are the same.Continue Reading

• Architecting beyond microservices and monoliths

  A recent architectural change tied to Amazon's Prime Video service could help enterprise application teams understand their own microservices vs. monolithic architecture choices.Continue Reading

• Business Process Modeling Language (BPML)

  Business Process Modeling Language (BPML) is an XML standard metalanguage used to outline business processes in an easy-to-understand way.Continue Reading

• What to know about building microservices with ASP.NET Core

  It's optimized for containerization, integrates with the cloud and works on multiple platforms. Does ASP.NET Core deserve a place in your development shop?Continue Reading

• 3 critical stops on the back-end developer roadmap

  When it comes to acquiring the skills needed to be a proficient back-end developer, there are no shortcuts. Some of the topics to know will be obvious, others might not be.Continue Reading

• Understanding Roc: Functional and separate from the runtime

  Though it's a newer programming language with a small development community, Roc is meant to be an easy-to-read language that incorporates a pure, functional programming approach.Continue Reading

• The basics of TOGAF certification and some ways to prepare

  TOGAF offers architects a chance to learn the principles behind implementing an enterprise-grade software architecture, including how to align business goals with IT capabilities.Continue Reading

• A quick intro to the MACH architecture strategy

  While not particularly prescriptive, alignment with a MACH architecture strategy can help software teams ensure application designs make proper use of current technologies.Continue Reading

• How to maintain polyglot persistence for microservices

  Managing microservice data may be difficult without polyglot persistence in place. Examine how the strategy works, its challenges and some options for polyglot databases.Continue Reading

• 5 noteworthy challenges of automotive software development

  Modern cars are loaded with technology, but creating in-vehicle applications isn't always a cakewalk. Here are five unique challenges developers face with automotive software.Continue Reading

• Breaking down the cornerstone components of OOP

  Object-oriented programming changed the game for those working on complex software systems. But what are the key elements that define this prominent approach to development?Continue Reading

• 5 types of software architecture design worth knowing

  While it's impossible to identify any software design style as the 'most important' to know, there are five major patterns with which all architects should arguably become familiar.Continue Reading

• Microservices vs. headless architecture: A brief breakdown

  Microservices and headless architectures are both techniques capable of providing flexibility and modularity, but how do you make a wise choice between them?Continue Reading

• How to create a smart contract using Ethereum

  Solidity is a powerful language for programming and deploying smart contracts on the Ethereum network. Here's how to get started, with advice on choosing the best tools.Continue Reading

• The past, present and future of AI coding tools

  Though AI-assisted software development has seemingly hit a historical turning point, things like intelligent code completion, static code analysis arguably led the way.Continue Reading

• business capability

  A business capability is the ability of an organization to achieve a specific outcome or objective.Continue Reading

• API security

  Application program interface (API) security refers to policies and procedures that protect APIs against malicious attacks and vulnerabilities.Continue Reading

• state diagram (state machine diagram or statechart diagram)

  A state diagram (also known as a state machine or statechart diagram) is an illustration of all the possible behavioral states a software system component may exhibit and the various state changes it's predicted to undergo over the course of its ...Continue Reading

• Falcor vs. GraphQL: The differences that matter

  While both essentially represent two approaches to a similar end goal, there are some key differences between GraphQL and Falcor that are worth understanding.Continue Reading

• service-oriented architecture (SOA)

  Service-oriented architecture (SOA) is a software development model that makes services reusable and lets them communicate across different platforms and languages to form new applications.Continue Reading

• A quick look at the Carbon programming language

  Carbon is an experimental programming language built to stand on the shoulders of C++ -- but with a new outlook on memory safety, threading and functional programming.Continue Reading

• Ways to get by when Waterfall development reigns

  Against all odds, the Waterfall methodology maintains a tight grip over countless numbers of software development teams. Fortunately, there are a few ways to make the most of it.Continue Reading

• The raw -- yet burgeoning -- potential of coreless banking

  While coreless banking is still a novel concept, it shows strong potential to liberate banks from the rigid software systems that have dominated the industry for decades.Continue Reading

• The fundamentals of achieving high cohesion and low coupling

  It's easy to say, 'high cohesion, low coupling,' but is it as easy to put into practice? We examine some of the basics behind cohesion, coupling and the right balance between them.Continue Reading

• client-side framework

  A client-side framework is a software development framework that focuses on executing application processes on end user devices rather than the application's own server.Continue Reading

• What developers need to know about open banking

  Open banking has made financial transactions easier and more secure for those with multiple banking accounts; however, vulnerabilities within open APIs raise security concerns.Continue Reading

• native code

  Native code is binary data compiled to run on a processor, such as an Intel x86-class processor.Continue Reading

• polyglot persistence

  Polyglot persistence is a conceptual term that refers to the use of different data storage approaches and technologies to support the unique storage requirements of various data types that live within enterprise applications.Continue Reading

• GraphQL

  GraphQL is an open source query language that describes how a client should request information through an API.Continue Reading

• enterprise architecture framework

  An enterprise architecture framework (or simply EA framework) is the collection of processes, templates and tools that software teams use to plan and build large, enterprise-grade application architecture systems.Continue Reading

• componentization (component-based development)

  Componentization is an approach to software development that involves breaking software down into identifiable and reusable pieces that application developers can independently build and deploy.Continue Reading

• 5 ways to survive the challenges of monolithic architectures

  Those unable to make the jump to microservices still need a way to improve architectural reliability. Here are five ways software teams can improve a monolith's reliability.Continue Reading

• How architects can use napkin math to forecast performance

  Although modern software systems can be inordinately complex, architects can still use simple napkin math to glean quick overviews of system performance and architecture alignment.Continue Reading