Tips

Tips

• 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

• Functional vs. object-oriented programming: The basics

  Choosing between functional programming vs. object-oriented programming isn't easy, but there are plenty of key factors that may help make the decision easier.  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

• Microservices vs. APIs: How they differ and work together

  Enterprises still rely on monolithic systems, but apps increasingly require speed, scale and flexibility. Here's how microservices and APIs achieve that, separately and together.  Continue Reading

• How pub/sub messaging works, and why it matters today

  While pub/sub has been a standard messaging approach for decades, it's arguably more important than ever for developers to understand what it is, how it works and why it matters.  Continue Reading

• How to handle typical event-driven architecture failures

  Adding events to an architecture can pose plenty of problems. Review some common event-driven architecture failures development teams face, and some strategic fixes for them.  Continue Reading

• The 6 non-negotiable REST architecture constraints

  While REST-centric design isn't necessarily hard, there are some non-negotiable rules when it comes to resource provisioning. Here are six all architects should know.  Continue Reading

• Static vs. dynamic typing: The details and differences

  What are the key differences between static typing and dynamic typing, and what role do their differences play in the decision to use one programming language over another?  Continue Reading