Tips
Tips
-
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
-
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
-
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
-
A review of 7 software architecture visualization tools
Visualization tools like Visio and Draw.io can provide a lot of benefits when it comes to software architecture design and management, but choosing the right one is important. 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
-
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
-
6 common problems with open source code integration
Open source provides its fair share of benefits for businesses that put it to use. However, don't ignore these six hazards that development teams may face along the way. 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
-
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
-
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
-
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
-
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
-
Rust vs. C++: Differences and use cases
C++ was mature before Rust even existed. Does that mean developers should switch from C++ to Rust? Not always. 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
-
What to know about GraphQL vs. REST performance
Both GraphQL and REST aim to simplify API development, but they handle data differently. Carefully consider how those differences might affect performance. Continue Reading
-
Critical API vulnerabilities every IT team should address
Their openness, flexibility and ease of use make APIs beneficial, if not essential, to modern IT. Those same features can make APIs vulnerable to attack. Continue Reading
-
Three-tier vs. microservices architecture: How to choose
The microservices approach is well suited to an app that needs a high level of modularity. When is the added complexity worth it, and how do you make that call? 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 5 essential HTTP methods in RESTful API development
Review these five common RESTful API HTTP methods that developers need to know. Use this guide to understand the differences and uses for each of the methods. Continue Reading
-
A quick breakdown of Postman vs. Insomnia
Does your organization need the fully loaded capabilities of Postman or the lightweight implementation style offered by Insomnia? Read this quick breakdown to get the picture. Continue Reading
-
Webhooks explained simply: What they do and how they work
Webhooks make significant use of basic API call mechanisms, while also setting event triggers in a few clicks of a button without the overhead of heavy request-response structures. Continue Reading
-
Techniques to gain control over unruly API sprawl
A lapse in proper control over large portfolios of internal and external APIs can result in problematic sprawl. Here's what software teams can do to prevent that from happening. 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
-
Haskell vs. PureScript: The difference is complexity
Haskell and PureScript each provide their own unique development advantages, so how should developers choose between these two popular programming languages? 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
-
9 programming languages for smart contract development
There are languages expressly for smart contract development, but you can also use general-purpose languages like C++ and Java. Here's how they differ, and advice on how to choose. 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
-
A healthy perspective on software architecture scalability
It's easy to overlook architecture scalability and focus instead on application performance and cost. But architectural scalability is the basis for some important benefits. Continue Reading
-
4 enterprise architect skills you should never overlook
While there's certainly plenty that goes into being an enterprise architect, what skills are the absolute 'must haves' to stay on top of the job? We examine a few. 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
-
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
-
The enduring link between Conway's Law and microservices
While Conway's Law is a decades-old concept, some would argue that the industry's rush to adopt microservices makes this take on development team structure more relevant than ever. 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
-
How to detect and control the spread of shadow APIs
Now that infiltration via APIs has become a favored method for hackers, IT teams need to take additional steps to safeguard those important interfaces. 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
-
Azure Logic Apps: How it compares to AWS Step Functions
Developers can use Microsoft Azure Logic Apps to build, deploy and connect scalable cloud-based workflows. Learn how it measures up to other cloud platforms and AWS Step Functions. 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
-
Rust vs. Go: A microservices-based language face-off
Rust and Go both offer language features geared toward microservices-based development, but their relative capabilities make them a better fit for some scenarios than others. 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
-
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
-
A primer on core development team structure concepts
To establish the right development team size, managers must look at each member's responsibilities and communication paths, as well as know when to split teams. Continue Reading
-
10 training courses to prep for microservices certification
While it's not necessarily easy to become certified in microservices architecture, there are plenty of courses you can take to prep for certification exams like the S90.MSA. Continue Reading
-
Signs of a Golden Hammer antipattern, and 5 ways to avoid it
The Golden Hammer antipattern can sneak up on a development team, but there are ways to spot it. Learn the signs, as well as some direct steps a team can take to avoid it. Continue Reading
-
Why contract testing can be essential for microservices
Developers face numerous struggles trying to perform traditional, end-to-end integration testing on microservices. Contract testing presents a potential alternative. Continue Reading
-
12 API security best practices to protect your business
As with any software development cycle, API security must be built in from the start. Follow these guidelines to design, deploy and protect your APIs. Continue Reading
-
The basics, benefits and risks of cell-based architecture
Developers who work with microservices may find the concept familiar, but cell-based architecture takes its own spin on modularity to address large-scale system failover issues. Continue Reading
-
3 common CQRS pattern problems, and how teams can avoid them
While CQRS can provide a lot of value when it comes to structuring an event-driven architecture, improper practices can cause this pattern to be more of a burden than a blessing. Continue Reading
-
10 application performance metrics and how to measure them
You've deployed your application, now what? To keep your application performing well, you need to track various metrics. Take a look at these ten critical KPIs. Continue Reading
-
Top 12 application performance monitoring tools
Discover the basic capabilities to evaluate when choosing an APM tool, and then review a list of APM vendors to help you get started with your selection process. Continue Reading
-
A quick glance at the history of C programming languages
Since C hit the scene in 1972, the language has continuously evolved to stay relevant in modern development. We examine C's history and why it's still relevant. Continue Reading
-
APM vs. observability: Key differences explained
If you're debating the use of application performance monitoring and observability to gather system data and improve the user experience, we break down the approaches. Continue Reading
-
Using AI and machine learning for APM
Discover how organizations can streamline operations and improve operational analytics by using AI and machine learning in their application performance monitoring environments. Continue Reading
-
A 7-point language comparison of Ballerina vs. Golang
This comparison takes a look at both Ballerina and Golang, including their support for high-level programming, libraries, built-in management features and community support. Continue Reading
-
How viable is it to create microservices in Python?
Python offers microservices developers access to advanced scripting, embedded testing and plugin tooling. But is it a good fit for you? And what are the alternatives if it isn't? Continue Reading
-
Frameworks for an observability maturity model
Observability helps developers and IT operations teams identify and fix system issues. And with the right setup, it can improve on itself over time to catch potential problems. Continue Reading
-
9 steps to implement in an observability strategy
As distributed software systems grow in scale and complexity, things like monitoring and debugging can become a tangled mess. Here are nine ways to bolster your observability plan. Continue Reading
-
Can you really use a shared database for microservices?
Since its emergence as a mainstream development style, experts have debated the wisdom of using a shared database for microservices versus providing a database per service. Continue Reading
-
5 fundamental strategies for REST API authentication
There are various authentication methods for REST APIs, ranging from basic credentials and token encryption to complex, multilayered access control and permissions validation. Continue Reading
-
6 ways cloud-native and cloud-agnostic architecture differ
While development teams should carefully weigh the tradeoffs between cloud-native and cloud-agnostic architectures, they don't necessarily have to commit to just one. Continue Reading
-
The deep-rooted relationship between REST and microservices
The REST paradigm can be a natural fit for microservices architectures, but it also presents potential challenges for development teams. Continue Reading
-
The management approach for internal vs. external APIs
While internal and external APIs don't differ much mechanically, there are some important contrasts when it comes to certain API design and lifecycle management issues. Continue Reading
-
The role of sidecars in microservices architecture
Sidecars can do a lot for microservices when it comes to communication with distributed application components, though they also present some precarious management challenges. Continue Reading
-
The basics of working with declarative programming languages
While imperative programming is often a go-to, the declarative approach has proved useful in the face of demands for complex, feature-heavy business applications. Continue Reading
-
Micro apps vs. microservices: What developers should know
On the surface, the contrast between micro apps and microservices simply seems a matter of front-end vs. back-end concerns. But this isn't the only difference worth knowing. Continue Reading
-
The ups and downs of using an internal developer platform
IDPs can provide a productive and secure environment for development teams. Consider the pros and cons to see if an internal developer platform is right for your organization. Continue Reading
-
An intro to cloud-native microservices and how to build them
While there are a variety of ways to develop cloud-native microservices, focus on strategies that enable as much agility, resiliency and development simplicity as possible. Continue Reading
-
A brief breakdown of declarative vs. imperative programming
While imperative programming is both an established and approachable method of coding, the declarative model is gaining appeal as demands for complex, flexible features increase. Continue Reading
-
The ups and downs of low-code microservices development
Low-code may not be the most sophisticated of development techniques, but it can often fit the bill for software teams looking to build microservices applications. Continue Reading
-
WebStorm vs. Visual Studio, and how to choose the right IDE
WebStorm and Visual Studio represent two ends of a wide spectrum when it comes to the IDE platform market. However, their true differences go well beyond their pricing structures. Continue Reading
-
Using the BFF pattern to keep UIs flexible and reliable
BFF is a simple design pattern that can help developers address UI-related challenges, such as problematic coupling, overfetching of data and inconsistent error handling. Continue Reading
-
Open vs. closed APIs: 4 crucial factors you should examine
Open and closed APIs both have their respective upsides and downsides. To choose the right approach, developers must examine four critical technical and business-level factors. Continue Reading
-
The pros, cons and challenges of containerized microservices
Containerized microservices are certainly a popular deployment approach, but are they the best? They can be, provided you overcome the unique challenges they present. Continue Reading
-
Will .NET 6 features bridge the gap between .NET frameworks?
Microsoft's original .NET Framework has come a long way, but will the new iterations of this framework be enough to convince developers to leave it behind? Continue Reading
-
How a microservices chassis regulates cross-cutting concerns
Those who've implemented a microservices architecture know that it presents a formidable collection of cross-cutting concerns to manage. Luckily, a microservices chassis might help. Continue Reading
-
Programming in Ruby: A critical look at the pros and cons
While Ruby showcases an impressive spread of beneficial features, there are still specific shortcomings that may explain why its adoption numbers have been conspicuously erratic. Continue Reading
-
The distributed monolith: What it is and how to escape it
Do you suspect that your attempt at microservices left you with distributed monolith application design? There are some telltale signs -- and, thankfully, a few ways to escape it. Continue Reading
-
PHP 8 features that prove it's for more than just web
Looking to keep up with the demand for increasingly sophisticated development capabilities, PHP 8 brings interesting new integrations that transcend the realm of web development. Continue Reading
-
8 fundamental microservices security best practices
Despite the benefits, microservices will introduce profound security issues. We review the biggest microservices security challenges and eight strategies used to combat them. Continue Reading
-
The architectural impact of RPC in distributed systems
It has become increasingly important for software architects to understand the mechanics behind remote procedure call (RPC), particularly its role in distributed architectures. Continue Reading
-
Service mesh vs. API gateway: Where, why and how to use them
While they're both central to inter-application communication processes, it's important to understand the fundamental differences between a service mesh and an API gateway. Continue Reading
-
Should you adopt an API-first approach to development?
While the code-first approach certainly works, its appeal is fading as architectures become increasingly complex webs of software. Learn why the API-first approach is catching on. Continue Reading
-
The functional programming paradigm at enterprise scale
Many enterprise-level architects rely on an object-oriented approach, but there are good reasons and practical ways to introduce functional programming within large-scale systems. Continue Reading
-
.NET vs. Node.js: What they are, and which to choose
The choice between using .NET and Node.js for application development shouldn't be a difficult one but requires a solid understanding of each approach's pros and cons. Continue Reading
-
Synchronous vs. asynchronous communications: The differences
Synchronous execution requires parties or components to work simultaneously in real time, while asynchronous communications don't need anyone to wait around for a reply. Continue Reading
-
The 4 Golden Signals, and how to put them into practice
There's nothing easy about monitoring distributed systems, but the right metrics can help. Here's how to put the Golden Signals of software reliability to work. Continue Reading
-
Microservices vs. SOA: Choose the right app architecture
This primer explains the ins and outs of a microservices vs. SOA architecture: when and where to use either one, and how both are evolving, thanks to containers. Continue Reading
-
How microservices and containers work, apart and together
Microservices and containers are two methods that enable companies to more efficiently create and deliver applications. Here's how they work -- and when they're best used together. Continue Reading