Day: February 19, 2024

In today's distributed computing landscape, coordinating tasks across multiple nodes while ensuring they execute without conflicts or duplication presents significant challenges. Whether managing periodic jobs, batch processes, or critical system tasks, maintaining synchronization and consistency is crucial for seamless operations.

The Problem

Let's say we need to run some tasks on a schedule, whether it's a database cleanup task or some data generation task. If you approach the problem directly, you can solve this problem using the @Schedules annotation included in Spring Framework. This annotation allows you to run code at fixed intervals or on a cron schedule. But what if the number of instances of our service is more than one? In this case, the task will be executed on every instance of our service.

Google Forms is a perfect tool for collecting data, from event registrations to customer feedback. By default, your Google Form responses are added in a Google Sheet that is linked to the form.

However, there could be scenarios where you may want to store a copy of the form responses in a different location, such as a Microsoft Excel worksheet, a Zoho sheet, or even multiple Google sheets.

The Problem

For this example, we have a Google Form where respondents can fill in their name, email address, city and other basic details. When a respondents submits the form, we would like that form response to be stored in an Excel sheet as well in addition to the original Google Sheet.

Let’s see how we can easily automate this with the help of Document Studio.

The Solution

Launch Document Studio inside Google Forms and create a new workflow. Provide the workflow name and move to the Conditions page.

Let’s add some conditions here to filter out the form responses that we don’t want to be saved in the Excel sheet. For instance, you may want to save only the responses where the respondent’s city is either New York or Boston. Any form response that doesn’t meet this condition will be ignored.

Next, move to the Tasks page and add a new task. Choose Copy Row from the list of available tasks. Here we’ll choose the spreadsheet service the Google Form responses should be stored. You can choose from Google Sheets, Microsoft Excel, or Zoho Sheets.

Connect Microsoft Excel to Google Forms

Select Excel Sheets from the list of available spreadsheet applications, and click on the Link Microsoft Excel button. You’ll be asked to sign in with your Microsoft account and grant permissions to Document Studio to access your Excel files.

Once your Microsoft account has been linked, open the Excel workbook in your browser and copy-paste the spreadsheet URL as shown in the screenshot below. If you would like to copy the form response to a Zoho Sheet, you can choose Zoho Sheets from the list and link your Zoho account.

You also need to specify the name of the worksheet where the form responses should be copied. If the sheet doesn’t exist, Document Studio will create a new sheet in Excel with the specified name.

The next section is Field Mapping where you can specify which form fields should be copied to the Excel sheet. You also need to specify the corresponding column names in the Excel sheet where the form responses should be stored.

For instance, if the field in your Google Form is called “Zip Code”, you can map it to the “Postal Code” column in your Excel sheet. Similarly, if the field in your Google Form is “Email”, you can map it to the “Email Address” column in your Excel sheet.

Save your task and click on Continue to proceed to the triggers screen. Check the Run on form submit option so that every time a new form response is submitted, the workflow will be triggered, and a new row will be added to the specified Microsoft Excel or Zoho Sheet.

Related Tutorials

1. Copy Google Form response to Zoho Sheet
2. Duplicate Google Form response in another Google Sheet

Building a REST API to communicate with an RDS database is a fundamental task for many developers, enabling applications to interact with a database over the internet. This article guides you through the process of creating a RESTful API that talks to an Amazon Relational Database Service (RDS) instance, complete with examples. We'll use a popular framework and programming language for this demonstration: Node.js and Express, given their widespread use and support for building web services.

Prerequisites

Before we begin, ensure you have the following:

Function pipelines allow seamless execution of multiple functions in a sequential manner, where the output of one function serves as the input to the next. This approach helps in breaking down complex tasks into smaller, more manageable steps, making code more modular, readable, and maintainable. Function pipelines are commonly used in functional programming paradigms to transform data through a series of operations. They promote a clean and functional style of coding, emphasizing the composition of functions to achieve desired outcomes.

In this article, we will explore the fundamentals of function pipelines in Python, including how to create and use them effectively. We'll discuss techniques for defining pipelines, composing functions, and applying pipelines to real-world scenarios.

Distributed transactions, also known as XA transactions, emerged to address the complexity of coordinating transactions across multiple databases or systems in a distributed environment. Imagine you’re conducting an orchestra where each musician represents a different database or service. Just like ensuring harmony in music requires precise coordination, maintaining transactional integrity across distributed systems demands careful orchestration.

This is where a two-phase commit (2PC), a vital aspect of XA transactions, steps in. 2PC acts as the conductor, ensuring that all musicians (or database participants) are ready to commit before the final note is played. Just as every instrument must be in tune before a symphony reaches its crescendo, 2PC ensures that all components of a distributed transaction are in sync before proceeding, thus guaranteeing the integrity of the transaction across the distributed landscape.

I’m pretty hot on Scroll-Driven Animations! What a wonderful idea that we can tie @keyframe animations timelines to scroll positions. And I’m sure the creators of it thought long and hard, because the API makes a ton of things possible. It’s not just “how far the entire page has scrolled”, although that’s possible. The progress through the animation can be tethered either to the scroll position of any element or to the position of an element within a scrollable container. Those are referred to as the Scroll Progress timeline or the View Progress timeline respectively. Slow clap, people.

Bramus Van Damme makes that nicely clear in this overview article. Bramus has been following, working on, creating demos, and writing about this stuff for a long time, and it was a smart move to wrap all that stuff up in a dedicated website for it.

I’m also a big fan of his co-worker Adam’s approach to an intro article here. Adam makes demos that are a smidge more designery and those tend to land with me. And speaking of designery demos, Ryan Mulligan’s beginning explorations are wonderful. He’s got some Polaroid photo style images that “blur in” when they scroll into view and a pair of photos that shuffle themselves as you scroll. I share Ryan’s sentiment that the tools Bramus has built are nearly crucial in understanding this stuff, since all the different keywords and values have such big effects.

These scroll-driven animations tend to be things that are just fun and could easily be thought of as progressive enhancement. So the fact that this is Chrome-only for now isn’t terribly bothersome to me, although it is polyfillable. We also didn’t get scroll-driven animations on the Interop 2024 list, but that doesn’t mean we won’t get Safari or Firefox support this year. Still could happen, just not really a guarantee.

Why do I think this is so cool? It’s not like we absolutely couldn’t do this before. Greensock has a ScrollTrigger plugin that is widely loved and has a pretty sweet API. (Here’s a great Collection.) I don’t think it’s terribly egregious to use JavaScript for these kind of effects, particularly if it makes them more maintainable, performant, or do things impossible any other way. But that’s the thing — when these abilities come back to native web technology like CSS, chances are the performance is going to be great and arguably more maintainable thinking long term as the people familiar with the technology will grow.

Yuriko Hirota did a great job of proving how much more performant using CSS for these types of animations are. The single-threaded nature of DOM interactive JavaScript means that if JavaScript is busy doing anything else, a JavaScript-powered animation is going to suffer from jankiness, that is, jerky and non-smooth animation. Even when JavaScript is quite busy, a CSS powered animation is fine. Those “scroll progress animations” are the classic demo of this web tech. Michelle Barker went deep on those this past year, starting with the basics and getting lovably weird as the article goes on.

Let’s end with a little tip! Bramus mentioned that if you’re setting up a scroll-driven animation that involves a target element and different scrolling element, if it’s not working, there is a good chance…

The culprit: an overflow: hidden sitting somewhere in between the target and the scroller.

It’s always the overflow, isn’t it? I find overflow is usually the culprit in figuring out why a sticky positioned item isn’t working as well. The solution, if you do actually need to deal with hiding overflow, is to use overflow: clip; instead, a relatively new ability. Kevin Powell covered a couple other scenarios where overflow: clip; saves the day, so it’s definitely worth knowing about!

I’ve been playing with Scroll-Driven Animations myself a bit. I wrote one bit about highlighting a bit of text as you scroll down a blog post, something I was inspired by from Lene Saile’s blog. As a response to a reader question, I also figured out how to zoom in images when they come into the viewport as well. Both of those ultimately use the scroll position to control the point in the animation to be at, which I think is usually nice, but I also enjoyed the idea that you can un-tether those things (say, run a 3s animation once an element becomes fully visible) by flipping a --custom-property in a keyframe which triggers a different keyframe, like Ryan Mulligan digs into.

It’s still early days for Scroll-Driven Animations and there are sure to be extremely clever ideas people will find for years. My jaw was already dropped by using them to fit text exactly to a container and to write conditional logic detecting if an element can scroll or not.

Machine learning models have become an integral part of modern business applications. The increasing demand for machine learning solutions has led to a significant increase in the number of tools and platforms. These tools and platforms support developers in the training and deploying of machine learning models. Amazon SageMaker has gained popularity among data scientists and developers for its ease of use, scalability, and security.

So, what is Amazon SageMaker? The Amazon SageMaker is a managed machine learning platform. It provides data scientists and developers with the essential resources and tools to produce, train, and deploy machine learning models on a massive scale.

Data Streaming is one of the most relevant buzzwords in tech to build scalable real-time applications and innovative business models. Do you wonder about my predicted TOP 5 data streaming trends in 2024 to set data in motion? Learn what role Apache Kafka and Apache Flink play. Discover new technology trends and best practices for event-driven architectures, including data sharing, data contracts, serverless stream processing, multi-cloud architectures, and GenAI.

Some followers might notice that this became a series with past posts about the top 5 data streaming trends for 2021, the top 5 for 2022, and the top 5 for 2023. Trends change over time, but the huge value of having a scalable real-time infrastructure as the central data hub stays. Data streaming with Apache Kafka is a journey and evolution to set data in motion.

Understanding the fundamentals of functions and relations is paramount. Grasping these core concepts lays the groundwork for effective software development and testing. We will delve into the basics of functions and relations, exploring their significance in software engineering and their implications for ensuring software quality. We will highlight basic scenarios for testing to kickstart more intricate testing activities.

Effective testing is not just about covering every line of code. It's about understanding the underlying relationships. How do we effectively test the complex relationships in our software code? Understanding functions and relations proves an invaluable asset in this endeavor.

The generative AI revolution has made significant progress in the past year, mostly in the release of Large Language Models (LLMs). It is true that generative AI is here to stay and has a great future in the world of software engineering. While models work amazingly well and produce advanced outputs, we can also influence models to produce the outputs we want. It's an art to make language models work to produce results/outputs as expected — and this is where prompt engineering comes into play. Prompts play a vital role in talking with language models. In this article, we’ll take a deeper dive into everything you need to know about prompt engineering. 

What Is Prompt Engineering?

The NIST AI RMF (National Institute of Standards and Technology Artificial Intelligence Risk Management Framework) provides a structured framework for identifying, assessing, and mitigating risks associated with artificial intelligence technologies, addressing complex challenges such as algorithmic bias, data privacy, and ethical considerations, thus helping organizations ensure the security, reliability, and ethical use of AI systems.  

How Do AI Risks Differ From Traditional Software Risks?

AI risks differ from traditional software risks in several key ways:

Imagine your online store’s checkout button disappears just before a major sale. Or, your company’s logo suddenly turns neon pink across the entire site. Even minor UI bugs can have disastrous consequences, leading to frustrated users, lost sales, and damaged brand reputation. Visual regression testing ensures that code changes don’t accidentally break the way your website or app looks. It focuses on catching layout issues, color problems, and other visual glitches that can disrupt the user experience.

With a wide range of visual regression testing tools available, choosing the right one is crucial. This blog will help you navigate the options and find the perfect fit for your testing needs.

Managing your secrets well is imperative in software development. It's not just about avoiding hardcoding secrets into your code, your CI/CD configurations, and more. It's about implementing tools and practices that make good secrets management almost second nature. 

A Quick Overview of Secrets Management

What is a secret? It's any bit of code, text, or binary data that provides access to a resource or data that should have restricted access. Almost every software development process involves secrets: credentials for your developers to access your version control system (VCS) like GitHub, credentials for a microservice to access a database, and credentials for your CI/CD system to push new artifacts to production.

In recent years, Domain Driven Design (DDD) has become a buzzword in the software development community, often surrounded by discussions focused on its tactical patterns: entities, value objects, repositories, services, aggregates, and more. This mainstream portrayal of DDD has, unfortunately, done a disservice to the software community. The emphasis on these complex patterns has led many to view DDD as overly complicated and inaccessible, particularly for projects that appear to have simpler domains. The question arises: why entangle your project in the web of DDD's tactical patterns if they seem unnecessary?

The Misguided Focus and Its Consequences

The vast majority of content and discussions available online revolve around DDD's tactical aspects, obscuring its true essence and benefits. This skewed focus has made it easy to lose sight of what DDD fundamentally aims to achieve: the strategic advantage of clearly defined boundaries within your domain, encapsulated by the concept of a bounded context. Unfortunately, for many newcomers to DDD, the bounded context—the cornerstone of DDD's strategic patterns — is not what they first encounter. Instead, they are introduced to DDD through tutorials or sample applications that dive straight into its tactical patterns without establishing a foundational understanding of the domain itself.