DZone Spotlight

Tuesday, June 24 View All Articles »

Brilliant Ideas, Bad Pitch? How to Communicate Tech Proposals That Win Support

By Sebastian Malaca

We all know the drill: refactoring makes our code easier to understand, static analysis points out complex areas and code smells, tests help us track and improve our code's coverage, and Domain-Driven Design lets us build code that directly reflects the business rules. Sounds logical, right? Yet, we often find it tough to convince managers, product owners, and other stakeholders of the value in these practices. What's even more puzzling is that we usually have no problem getting fellow developers on board. You might wonder, "What's going on here?" We use the same language, list the same problems and solutions, and back up our points with the same arguments. So, where's the disconnect? Well, it's right in how we're presenting it. Think about it: do you use the same language when you explain your work to your boss that you do when talking to a friend, child, or partner? No, you adjust your message based on who you're talking to. You know their level of understanding might be different from yours. So why do we forget this basic principle when we're trying to make changes for the better at work? Sure, everyone works at the same company, maybe even on the same project, but their roles and responsibilities can be very different. This means they might use different language, some terms might be completely meaningless to them, and things that seem obvious to you might not be clear to them at all. When you're trying to introduce a new idea, solution, or technique, getting your audience to buy into it is crucial. You need to shift your focus from what you want to share to what matters to your audience and how your proposal helps them achieve their goals. That's easier said than done, right? So, how do you prepare effectively? Clarify Your Goal: This might seem obvious, but it's important to know what you want to achieve from the meeting. You'll prepare differently if your goal is just to share knowledge versus asking for support, permission, or budget. Without a clear goal, you won't be able to prioritize what you need to share and how deep you need to go into each topic.Document Your Rationales: Write down why you think your proposed solution is important and worth implementing. This is your perspective, and once you have it written down, you can do a lot with it. You can prioritize your points, group them together if possible, and prioritize within those groups. This helps you build a better narrative around your proposal. Plus, having your priorities clear is especially helpful when you don't have a lot of time. You don't want to spend most of the meeting talking about the least important aspect of your solution.Understand Your Audience: Describe who's invited to the meeting: who they are, why they're invited, why the meeting is or should be important to them, what's important to them right now, and what their high-level priorities are. To make this easier, you can list a few possible values on the side as inspiration: growth, promotion, recognition, visibility, risk reduction, saving money, earning money, and so on. You can describe each person invited if the group is small, or describe types of personas if the group is large. And there's no problem mixing both approaches if needed.Develop Audience-Oriented Arguments: You know why you think your proposal is beneficial, and you know what's important to your audience. Now, go through your reasoning and arguments with their values in mind. What aspects will be most important to them? What arguments need to be adjusted? What arguments are irrelevant? The best part of this exercise is that you'll likely come up with new arguments to support your solution, just by looking at it from their perspective. Of course, it can also show you aspects you hadn't thought of before. This usually helps you prepare better for the meeting. But in some cases, it might become clear that you don't have enough strong arguments to convince the person or group. While this isn't ideal, it's better to know before the meeting than during it. This information can also help you decide whether to continue or stop pursuing the idea. It depends on whether this person or group is your main target and whether you need their approval to move forward.Eliminate Domain-Specific Terminology: Everyone has different knowledge, models reality differently, uses different words, and has their own set of "obvious" information. Remember this when preparing for conversations with people who might not be from your "world." Once you have a list of who they are, it's easier to figure out which terms need explaining, which phrases need replacing, and which details are completely irrelevant. You don't want to sound smart; you want to convince them. Technical jargon will confuse them, and going into too much detail will bore them and lose their interest.Anticipate Challenges: Building understanding is one thing, but addressing their concerns is equally important. Look at what matters to them, look at their goals and priorities, and then go back to your arguments. If you were them, would your arguments contradict their priorities in any way? If not, explain why. If yes, prepare answers for the questions or challenges they might have.Manage Time Effectively: By this point, you know what to say and how to say it. Now, you need to know how much time you have and how quickly you need to get your point across. Do you have 30 minutes or 5? Whatever the answer, accept it. You might have a story you could tell for hours, but this isn't about you or even them; it's about getting them to follow or accept your solution. Remove all unnecessary details, start with the key arguments, and address their biggest concerns. The less time you have, the more important it is to have a well-structured plan.Create an Engaging Agenda: It's worth creating an agenda that keeps your audience engaged. Don't just throw arguments at them randomly. Build a story and a proper narrative. Start with a problem that's important to your audience to grab their attention from the start. If you have more time, you can go into the details of the problem. This can remind them why the issue affected them and why they wanted it solved. Once you have their attention and remind them why the meeting is important, you can move on to your proposal. Depending on the time, include more or fewer details. Make it clear that you're aware of the challenges (no solution is perfect) and describe how you plan to tackle or compensate for them. Leave time at the end to remind them of the problem and finish with the benefits of your proposal. End with a positive message and the benefits, leaving them with a feeling of all the great things that will happen once your solution is implemented.Leave Room for Questions: This depends heavily on how much time you have, but if there's enough, plan for questions upfront to strengthen your narrative. You can plan your presentation and leave time for questions at the end. If you do this, remember to control the situation. There might be challenging questions you don't know the answers to right away, and you don't want to leave your audience uncertain about the quality of your solution. That's why you should summarize the benefits after the Q&A. Another approach is to let them ask questions after each "part" of your presentation. This prevents you from being bombarded with questions from various areas at once, but it requires better control over the audience. You have an agenda, and you need to make sure you cover everything you planned. In most cases, you won't be able to use all of these recommendations. Everything depends on your audience, the time you have, and your goal. And of course, on the importance of the topic. The more important the discussion, the more time you'll need to prepare carefully. And one last thing to remember: you can be really well-prepared, but you won't "win" every discussion. However, the more comfortable you are with these techniques, the more you'll learn from each experience. You'll notice more things, not just the words spoken during the discussion. I wish you good luck in all your important conversations! And if you have any other techniques for preparing well, please share them! More

Real-Object Detection at the Edge: AWS IoT Greengrass and YOLOv5

By Anil Jonnalagadda

Edge computing has transformed how we process and respond to data. By taking compute capability to the point of data, such as cameras, sensors, and machines, businesses can make decisions faster, reduce latency, save on bandwidth, and enhance privacy. AWS empowers this revolution with a set of edge-capable services, most notably AWS IoT Greengrass. In this article, we'll give an example of how to run a machine learning model (YOLOv5) on an edge device via AWS IoT Greengrass v2 to identify objects in real-time within a retail setting. This is a fault-tolerant and scalable solution appropriate for an intermittently cloud-connected environment. Let's look at a Retail Store Video Analytics on the Edge. Consider a chain of retail outlets wanting to: Detect shoplifters in real time Count customer traffic and interaction Run analytics offline during internet outages Rather than streaming video continuously to the cloud and bearing significant cost and latency, the solution is to perform an ML model at the edge for real-time insights. Architecture Overview To facilitate edge object detection in real time, it is essential to have an optimally structured system whose workload offload and interaction with local infrastructure versus cloud services, such as AWS, is balanced. Besides facilitating ultra-low latency inference, this system can also ensure continuity of operations within environments without consistent connectivity, such as shopping stores, factories, or transportation stations. The architecture consists of: Edge Device (such as NVIDIA Jetson Xavier, Raspberry Pi, and AWS Snowcone) IP Camera Feed (IP cameras installed within the store) ML Model (YOLOv5 for object detection) AWS IoT Greengrass V2 for Inference and Control of Lambda Functions AWS IoT Core to process events on the cloud side We are going to decompose the architecture into steps. 1. Edge Device Layer The main component of edge architecture is the edge device, a small yet versatile compute node close to data sources such as a security camera. Some examples of supported devices are: NVIDIA Jetson Nano/Xavier AGX: Ideal for Machine Learning Acceleration.Raspberry Pi 4: Ideal for light applications and prototyping.AWS Snowcone: Managed and rugged edge device for challenging environments. This layer is responsible for ingesting video frames from mounted cameras and running inference on pre-deployed machine learning models, such as in our situation, YOLOv5. It’s also responsible for managing local decision logic and distributing actionable insights.We remove the need to stream raw video to the cloud by processing video on the device, thus reducing bandwidth consumption and latency by a dramatic amount. 2. Edge Runtime Using AWS IoT Greengrass v2 AWS IoT Greengrass V2 is deployed on the edge device, a light-weight, feature-rich edge runtime serving as glue to connect cloud and local applications. Core competencies encompass: Secure Lambda execution at edge: Allows for execution of a Python (or Java/Node.js) function on an event trigger like sensor change or camera input. Component management: You have your object detection code packaged and deployed as a Greengrass component. These components can be updated, rolled back, and monitored directly from the AWS Management Console or the CLI. Offline mode: Even when the device becomes disconnected from the internet, Greengrass keeps on running inference and keeps messages pending to be sent later. This makes it extremely robust and suitable for retail spaces with poor Wi-Fi or cell phone signals. 3. Machine Learning Inference Pipeline We deploy on the edge device a pre-existing PyTorch YOLOv5 object detection model for relevant image data (e.g., person detection, customer behavior, and interaction with product). An example of such a model is: Either trained from scratch or fine-tuned with Amazon SageMaker, optimized for deployment on the edge via Amazon SageMaker Neo (ONNX or Torch Script converted). Embedded within the inference script, which is either run as a Lambda function or a system process. It processes each frame of the video and produces a list of detected objects, along with bounding boxes, class labels, and scores. Locally, predictions are parsed and filtered. For instance, detections with confidence scores of below 80% may be filtered out to eliminate noise. 4. Publishing Events to AWS IoT Core Subsequently, actionable data is made available on the cloud via MQTT, a lightweight publish/subscribe messaging protocol suitable for edge devices. A message can be: JSON { "label": "person", "confidence": 0.91, "timestamp": "2025-01-01T20:04:12Z" "location": "Store#99 / location code 0x34" } This message is sent to a topic, such as edge/camera/events, on which AWS IoT Core subscribes for downstream routing and analytics. Optional services, such as Amazon Timestream and QuickSight, for time-series analytics and dashboards are worth considering for enhanced analytics and visualization. Let's proceed: Steps Step 1: Set up and install the Edge Device Install AWS IoT Greengrass Core v2 on your edge device: Shell sudo apt update sudo apt install openjdk-11-jdk python3-pip -y wget https://d2s8p88vqu9w66.cloudfront.net/greengrass/v2/install.zip unzip install.zip -d greeng cd greeng sudo ./greengrass-cli installer \ --aws-region us-west-2 \ --thing-name EdgeCamera001 \ --thing-group-name EdgeCameras \ --component-default-user ggc_user:ggc_group This registers the device in AWS IoT Core, installs required components, and prepares it for deployment. Step 2: Write the Edge Logic Script Let's use YOLOv5 and boto3, and write our edge inference logic like this: Python # inference.py import torch, cv2, json from datetime import datetime import boto3 model = torch.hub.load('ultralytics/yolov5', 'yolov5s') # Load YOLOv5 model client = boto3.client('iot-data', region_name='us-west-2') # AWS IoT Core def detect(): cap = cv2.VideoCapture(0) while True: ret, frame = cap.read() results = model(frame) for obj in results.xyxy[0]: label = model.names[int(obj[5])] confidence = float(obj[4]) if confidence > 0.8: payload = { "label": label, "confidence": confidence, "timestamp": datetime.utcnow().isoformat() } client.publish( topic='edge/camera/events', qos=1, payload=json.dumps(payload) ) This script: Captures live frames from a USB or RTSP camera.Runs object detection locally.Sends results to the edge/camera/events topic in AWS IoT Core. Step 3: Package and Deploy Zip your Python script: Shell zip object-detection.zip inference.py Upload to S3: Shell aws s3 cp object-detection.zip s3://your-bucket-name/greengrass/ Create the component recipe: JSON { "RecipeFormatVersion": "2020-01-25", "ComponentName": "com.example.objectdetection", "ComponentVersion": "1.0.0", "ComponentDescription": "YOLOv5 object detection at the edge", "Manifests": [ { "Platform": { "os": "linux" }, "Lifecycle": { "Run": "python3 inference.py" }, "Artifacts": [ { "URI": "s3://your-bucket-name/greengrass/object-detection.zip" } ] } ] } Deploy the component: Shell aws greengrassv2 create-deployment \ --target-arn arn:aws:iot:us-west-2:123456789012:thing/EdgeCamera001 \ --components '{"com.example.objectdetection": {"componentVersion": "1.0.0"}' \ --deployment-name "EdgeObjectDetection" You can subscribe to the edge/camera/events topic in AWS IoT Core to review the incoming detections. Example payload: JSON { "label": "person", "confidence": 0.93, "timestamp": "2025-06-08T14:21:35.123Z" } Use this data to: Create Alerts Using Amazon SNS.Store event streams within Amazon Timestream.Create dashboards in Amazon QuickSight. Conclusion In this article, we examined a sample use case and how it can be accomplished with AWS to deploy end-to-end, robust edge AI applications using well-known devices, such as IoT Greengrass and SageMaker. You can deploy a solution fit for production with just hundreds of lines of code and run real-time object recognition on-site, responding immediately to events, and have it plugged into AWS for analytics and visualization. This is not specific to retail but can also be applied to factories, smart cities, logistics, and healthcare settings where data must be processed close to where it is being created. More

From Java 8 to Java 21: How the Evolution Changed My Developer Workflow

By Akhil Sabu

Refcard #402

SBOM Essentials

By Siri Varma Vegiraju

CORE

Refcard #269

Getting Started With Data Quality

By Miguel Garcia

CORE

Unveiling Supply Chain Transformation: IIoT and Digital Twins

Digital twins and IIoTs are evolving technologies that are transforming the digital landscape of supply chain transformation. The IIoT aims to connect to actual physical sensors and actuators. On the other hand, DTs are replica copies that virtually represent the physical components. The DTs are invaluable for testing and simulating design parameters instead of disrupting production elements. Still, the adoption of both technologies remains limited in real-world scenarios. This article explains the Industrial Internet of Things (IIoT) and digital twins (DT) technologies, and how they transform business and the global environment to optimize supply chain ecosystems. Insights of IIoT Technology in Supply Chain Pioneering technologies, such as IoT, are already well-known to businesses. The Industrial Internet of Things (IIoT) extends the networks of physical sensors and controlling software to connect a centralized web console to receive data from distributed smart devices. A few of the market trends show the importance of adopting IIoT technologies: A study performed by Grand View Research emphasizes growth in IIoT technology to $949 billion by 2025. The global marketplace of IIoT is expecting a growth of USD 1,693.44 billion by 2030, with a 23.3% CAGR from 2025 to 2030.A consulting firm, Accenture, predicted a $14 trillion 2030 global turnover of the IIoT industry. Contrary to generic IoT, which is more oriented towards consumers, the IIoT enables the communication and interconnection between different machines, industrial devices, and sensors within a supply chain management ecosystem with the aim of business optimization and efficiency. The incubation of IIoT in supply chain management systems aims to enable real-time monitoring and analysis of industrial environments, including manufacturing, logistics management, and supply chain. It boosts efforts to increase productivity, cut downtime, and facilitate information and accurate decision-making. The IIoT Technology, empowered with advanced innovative technologies, including artificial intelligence, machine learning, and industry automation, can do wonders in the modern competitive marketplace. In the supply chain management pipeline, IIoT has become a 'must-have' technology that can revolutionize it at every stage with smoother and better operations. Advantages of IIoT in Supply Chain Management Real-Time Tracking of Assets Through Sensor Devices To enhance productivity in supply chain management, including tracking raw materials, in-progress assignments, and finished products, IIoT sensors can be deployed on containers, goods, and other assets. It provides better visibility of goods and their conditions, enabling efficient inventory management and planning. Optimization Through Predictive Analytics Global manufacturing firms lose $ 1 trillion annually due to machine downtime, which can be avoided by deploying innovative technologies. Adopting IIoT technologies enables companies to identify machine failures before actual operation disruption proactively. IIoT equipped with predictive analytics algorithms can detect early machinery failure before it occurs. The proactive approach reduces potential downtime, prevents disruptions, and enhances business optimization. Increased Visibility in Supply Chain and Better Transparency Lack of visibility is a significant concern and a big barrier to efficient supply chain management. The IIoT offers visibility to stakeholders by monitoring goods, identifying potential bottlenecks, and facilitating effective collaboration among partners. The IIoT technology provides better insights by giving a comprehensive view of the supply chain management ecosystem, starting from shipment status, goods tracking, adequate transportation, fault tracking, and early prediction of faulty equipment or machinery. The benefits of IIoT are multi-fold. It enhances the production stages and provides an informative decision to authorities that helps in better logistic management, making better and optimized delivery schedules. Early Demand Forecasting and Inventory Management Undoubtedly, IIoT sensors integrated with the supply chain management ecosystem capture real-time data, which can be leveraged for analytics and demand forecasting to take the business to the next level. Businesses can likely face a shortfall during a specific period, and early forecasting of demands can enable businesses to make informed decisions so that production becomes more optimized and accurate to avoid any shortfall or overstock situations. Recommendation and Data-Driven Information Decision By analyzing a large amount of data from IIoT sensors, predictive analytics algorithms can be used to develop a recommender system to facilitate authorities to give pre-emptive and proactive decisions that help the business minimize the risk involved. Organizations can determine the market trends, anticipate the marketplace, and promptly respond to avoid service disruptions or the risks involved in the supply chain management lifecycle. Smart Warehouse Management The incubation of modern technologies, such as IIoT, brings innovative management to the supply chain warehouse. Automated and real-time inventory management takes the business to the next level, be it a computerized picking and packaging procedure, tracking of faulty devices, or in-progress delivery. It boosts business efficiency by reducing manual efforts and minimizing the chance of human errors. Efficient Quality Control The advancement of IIoT in supply chain management offers innovative solutions that facilitate the quality and condition of goods. These innovative solutions ensure the customer receives a better product that meets the quality standards. Consistent delivery of high-quality products to the customer increases the customer's satisfaction, loyalty, and business reputation in the current competitive marketplace. Figure 1: Integration of IIoT in Supply Chain Management Integration of IIoT in Supply Chain and Its Future Like other domains, advanced modern technologies also significantly impact the supply chain. As we progress into the current digital world, IIoT will play a significant role in the transformation of supply chain management. A supply chain equipped with IIoT will be a main ingredient in boosting real-time monitoring and enabling informed decision-making. Every stage of the supply chain ecosystem will have the impact of IIoT, like automated inventory management, health monitoring of goods and their tracking, analytics, and real-time response to meet the current marketplace. IIoT is a boon to supply chain management that will lead to efficient response, adaptability in the evolving modern digital world, and meet customer requirements. The impact of AI algorithms will be the future of supply chain management, which will move towards predictive and prescriptive analytics, forecasting future demands, early identification of risk, and optimizing business efficiency through utilizing the vast amounts of data generated from IIoT devices and sensors. This way, the companies will be more proactive than conventionally reactive, resolving potential risks before they escalate further. Industrial automation will transform the entire supply chain ecosystem, encompassing every phase and aspect. Integrating IIoT will lead to more streamlined, optimized, and error-free business operations. With the transformation from automated inventory management to AI-powered demand forecasting, the supply chain will be scalable, robust, and more reliable in a different paradigm. Digital Twins (DTs): Key Technologies Digital simulation (DT) differs from the industrial Internet of Things and other simulation technologies. DT gives a comprehensive distribution between the physical and digital worlds. DT has five different technologies to connect, collect, and store real-time data in the supply chain ecosystem to provide meaningful insights into the collected data and optimize the functions in the supply chain (Refer to Figure 2), primarily representing the physical objects digitally. IoT is a critical component in the supply chain for better automation.AI provides real-time analytics and predictive forecasting by processing vast amounts of collected data.AR and VR make digital twins a realistic application.Cloud computing offers services without disruption. Blockchain technology is an evolving, decentralized, and growing technology in the supply chain. Figure 2: Technologies of digital twins Conclusion This article describes the benefits of the Industrial Internet of Things (IIoT) and digital twins (DTs) and how they will revolutionize contemporary supply chains, including automation, demand forecasting, predictive analytics, and informed decision-making to minimize risks and issues early in supply chain management. The adoption of DT technology is growing, but its potential advantages to business and the global community are still untapped in digitally connected worlds. However, technological benefits also come with challenges that must be navigated and addressed before they escalate, such as migration cost and complexity, data security, implementation, and operational cost of IIoT. It is smart to stay ahead in the modern business world and streamline your business by adopting the IIoT and DT.

By Manvinder Kumra

Building an SQL to DataFrame Converter With ANTLR

The modern data engineering landscape frequently demands seamless transitions and interoperability between established SQL-based systems and the popular ecosystem of Dataframe-centric frameworks like Pandas, Apache Spark and Polars. Migrating legacy applications or building hybrid systems often requires translating SQL queries into their DataFrame API equivalents. While manual rewriting is feasible for small-scale projects, it quickly becomes a bottleneck, prone to errors and challenging to maintain as complexity grows. This article delves into leveraging ANTLR (ANother Tool for Language Recognition), a powerful parser generator, to construct a robust and extensible SQL to DataFrame converter. We will explore the core principle, implementation steps and challenges involved in building such system. Why Converting SQL to DataFrames Isn't Always Straightforward The fundamental differences between SQL and DataFrame APIs present significant challenges for direct translation: Declarative vs Imperative: SQL is a declarative language where users specify what data they need, leaving query optimizer to determine how to retrieve it. DataFrame APIs, conversely are more imperative, requiring developers to explicitly chain together operations to achieve the desired transformation.Syntactic Divergence: While core SQL keywords are generally consistent, nuances in function names, date/time manipulation, string operations, and even clause ordering vary significantly across SQL dialects (e.g., MySQL, PostgreSQL, SQL Server). DataFrame APIs, being embedded within programming languages like Python or Scala, possess a distinct, programmatic syntax.Execution Model Discrepancies: SQL queries are typically executed by DBMS optimized for set-based operations. DataFrame operations are typically executed in-memory (Pandas) or distributed across a cluster (Spark), requiring careful consideration of data partitioning and execution strategies during translation.Feature Parity: Not all SQL features have direct counterparts in DataFrame APIs, and vice versa. Window functions, common table expressions (CTEs), and stored procedures in SQL might require intricate combinations of DataFrame operations or even custom logic to replicate. Various Steps to Build SQL to DataFrame Converter Using ANTLR ANTLR provides a structured and automated approach to overcome these challenges. In this article, we will use a simThe process involves the following key steps: Defining the SQL Grammar The first step of our converter is a formal grammar defining the syntax of the source SQL dialect. ANTLR grammars specify both the lexical rules (how the input stream is tokenized) and the syntactic rules (how tokens are combined to form valid SQL statements). Fortunately, well-maintained grammars for various SQL dialects are often available in the ANTLR grammar repository or can be adapted from existing specifications. This grammar will describe the structure of SQL queries, encompassing clauses like SELECT, FROM, WHERE, GROUP BY, ORDER BY, and various expressions. Plain Text grammar MySql; query : selectExpr fromExpr whereExpr? groupBy? orderByExpr? EOF; selectExpr : 'SELECT' identifiers; fromExpr : 'FROM' identifier; whereExpr : 'WHERE' STRING; orderByExpr : 'ORDER' 'BY' identifiers; groupBy : 'GROUP' 'BY' identifiers; string_vals: STRING (',' STRING)*; identifiers : identifier (',' identifier)*; identifier: IDENTIFIER ('.' IDENTIFIER)*; STRING : ('\'' (~'\'')* '\'')+ | ('"' (~'"')* '"')+; IDENTIFIER: [a-zA-Z_] [a-zA-Z_0-9]*; WS: [ \t\r\n]+ -> skip; Please refer to the following github project for complete project files: sql-to-dataframe-converter Generating the Parser Once the grammar is defined, ANTLR generates a parser along with a lexer and visitor in the target programming language (e.g. Java, Python etc). This generated code takes SQL input and constructs a parse tree (or Abstract Syntax Tree - AST) representing the syntactic structure of the query. To generate the parser, we can use the following command: Shell java -cp lib/ST4-4.3.jar:lib/antlr-runtime-3.5.2.jar:lib/antlr4-4.9.jar:lib/antlr4-runtime-4.9.jar org.antlr.v4.Tool -Dlanguage=Java -visitor -o generated/ src/com/sql2dfconverter/parser/MySql.g4 Implementing the Translation Logic The most crucial step is traversing the parse tree and generating the corresponding DataFrame API calls. The Visitor pattern in ANTLR is particularly well-suited for this task. By implementing a custom visitor class, we can define specific actions to be performed when visiting different nodes in the parse tree. Scala // Extend the base visitor generated by ANTLR class SqlToPandasDfVisitor extends MySqlVisitor[String] { override def visitQuery(ctx: MySqlParser.QueryContext): String = { val select = visit(ctx.selectExpr()) val from = visit(ctx.fromExpr()) val where = Option(ctx.whereExpr()).map(visit).getOrElse("") val orderBy = Option(ctx.orderByExpr()).map(visit).getOrElse("") s"$from$select$where$orderBy" } override def visitSelectExpr(ctx: MySqlParser.SelectExprContext): String = { val columns = ctx.identifiers().identifier().asScala.map(_.getText).map(col => s""" "$col" """).mkString(", ") s".select($columns)" } override def visitFromExpr(ctx: MySqlParser.FromExprContext): String = { val tableName = ctx.identifier().IDENTIFIER().asScala.map(_.getText).mkString(".") s"""val df = spark.read.table("$tableName")""" } override def visitWhereExpr(ctx: MySqlParser.WhereExprContext): String = { val condition = ctx.STRING().getText // Remove the single quotes around the condition val cleanedCondition = condition.substring(1, condition.length - 1) s".filter(${cleanedCondition})" } override def visitOrderByExpr(ctx: MySqlParser.OrderByExprContext): String = { val orderBy = ctx.identifiers().identifier().asScala.map(_.getText).map(col => s""" "$col" """).mkString(", ") s".orderBy(${orderBy})" } override def visitGroupBy(ctx: MySqlParser.GroupByContext): String = { val groupBy = ctx.identifiers().identifier().asScala.map(_.getText).mkString(", ") s".groupBy(${groupBy})" } } Please refer to the following github project for complete project files: sql-to-dataframe-converter Handling the Dialect-Specific Variations To support multiple SQL dialects, you would need to create separate grammars and potentially different visitor implementations or conditional logic within a single visitor to account for syntactic and functional differences. A configuration-driven approach could also be employed to map dialect-specific keywords and functions to their DataFrame equivalents. Addressing Semantic Equivalences Ensuring that the generated DataFrame code accurately reflects the intent of the original SQL query is a significant challenge. This requires careful mapping of SQL constructs to the appropriate DataFrame operations, considering data types, null handling, and the nuances of different operations. Thorough testing with a wide range of SQL queries is crucial. Further Considerations and Challenges Complex SQL Features Translating advanced SQL features like joins (especially different join types), subqueries, window functions, and CTEs requires more sophisticated visitor logic and might involve breaking down complex SQL constructs into multiple DataFrame operations. For instance, a JOIN operation would necessitate using the merge() or join() methods in Pandas or the join() operation in Spark DataFrames, carefully handling the join keys and types. Subqueries might require creating intermediate DataFrames. Aggregation Functions Handling SQL aggregation functions (e.g., AVG, COUNT, SUM, MIN, MAX) in conjunction with GROUP BY clauses requires careful orchestration. The visitor needs to identify the aggregation functions in the SELECT clause and apply them after performing the groupby() operation in the DataFrame API. Mapping DataTypes Mapping SQL data types to their corresponding DataFrame types requires a well-defined mapping strategy. Considerations include precision, scale, and nullability. Explicit type casting might be necessary in the generated DataFrame code. Performance Optimization The naively translated DataFrame code might not always be the most performant. Optimizations might involve choosing the most efficient DataFrame operations, considering data partitioning in distributed frameworks, and avoiding unnecessary data shuffles. Error Handling and Reporting A robust converter should provide informative error messages for unsupported SQL syntax or semantic mismatches. ANTLR's error listener mechanism can be extended to capture and report parsing errors. Semantic validation might require additional checks within the visitor. Conclusion Building a SQL to DataFrame converter with ANTLR offers a powerful and extensible solution for bridging the gap between these two dominant data processing paradigms. By leveraging ANTLR's parsing capabilities and implementing careful translation logic within a visitor, developers can automate the often tedious and error-prone process of manual conversion. While challenges exist in handling complex SQL features, ensuring semantic equivalence, and optimizing performance, the structured approach provided by ANTLR lays a solid foundation for building robust and maintainable data integration solutions. As the demand for interoperability across diverse data ecosystems continues to grow, the ability to programmatically translate between data languages will become an increasingly valuable skill.

By Sandeep Bishnoi

Modern IT Incident Management: Tools, Trends, and Faster Recovery

Modern IT systems are built on interconnected, cloud-native architectures with complex service dependencies and distributed components. In such an environment, unplanned incidents can severely impact your software service availability and revenue streams. Well-defined IT incident management helps tech teams manage disruptions to IT services to restore normal service operations. These could be anything from server crashes, cybersecurity threats, hardware failures, or even natural disasters. Types of IT Incidents in Complex Systems An IT incident refers to any unplanned event that disrupts normal service operations or reduces system performance. In distributed and multi-layered architectures, incidents take many forms depending on the component affected. Here are the top incidents affecting complex infrastructures: Hardware failures: Servers crashing, hard drives failing, faulty RAM, broken motherboards, or power supply problems that bring systems down.Software defects: Logic errors in complex algorithms, improper error handling, stale cache states, orphaned processes, time synchronization issues, or inconsistent data replication that lead to unpredictable application behavior.Network disruptions: DNS outages, slow network performance, bandwidth overload, routing mistakes, or lost packets causing connectivity problems.Cloud provider issues: Misconfigured resources, failing APIs, resource quota limits, or vendor-side problems affecting cloud-hosted applications.Storage incidents: Snapshot corruption, backup failure, storage latency spikes, file system corruption, or metadata server failures causing data unavailability or integrity issues. It’s important to distinguish incidents from related operational events. An incident causes an unplanned service impact. A problem is the underlying root cause behind repeated incidents. A service request involves routine changes or user-driven tasks that do not reflect a fault. Modern architectures complicate incident management due to distributed dependencies. A failure in one cloud instance, container, or service mesh node can cascade across multiple microservices, amplifying disruption. Identifying the precise fault domain requires full-stack observability across infrastructure, application layers, and external integrations. How Modern Incident Management Software Can Help Here’s how modern incident management software improves recovery Centralized Incident Logging and Tracking IT incident management software consolidates incident reports from multiple sources. They monitor systems, user reports, and automated alerts in a single dashboard. This centralization allows teams to track incident status, assignments, ownership, and resolution progress in real-time, reducing communication gaps. Automated Workflow and Escalation Management Response pipelines autonomously distribute incidents by evaluating impact radius, operational criticality, responder load balancing, and predefined runbook-driven escalation matrices. This minimizes manual decision points during triage and ensures that mission-critical events propagate to the most capable response units without delay. AI-Driven Assistance and Predictive Capabilities AI capabilities found in issue-tracking systems analyze incoming incidents, suggest recommended actions, and even resolve certain categories of issues autonomously. Machine learning models detect patterns across historical incidents, enabling proactive detection of emerging problems and continuous process refinement. Real-Time Alerting and Immediate Notifications Incident response solutions interface with telemetry pipelines to emit actionable signals upon breaching dynamically computed thresholds or anomaly baselines. Alerts are delivered through various communication channels—like mobile push notifications, messaging platforms, and incident bridges—ensuring responders stay updated wherever they are. Prioritizing Incidents by Severity AI-powered incident management software categorizes incidents by severity, aligning response actions to the business impact. Incidents affecting core services receive the highest priority, while minor issues are queued for routine handling. This structured prioritization allows teams to allocate resources efficiently. Integrated Collaboration and War Room Features During major incidents, responders collaborate in real-time through integrated chat, video conferencing, shared runbooks, and live dashboards. Centralized communication channels reduce misalignment and prevent fragmented response efforts. Future Trends in IT Incident Management Here are the top trends to look for in the coming years that will change the way how IT incidents are managed: AI-powered anomaly detection is expected to become more predictive: Artificial intelligence models are evolving to analyze logs, metrics, traces, and behavioral signals far earlier than conventional monitoring tools. These systems are starting to detect subtle deviations that suggest emerging failures before full outages occur. As training data grows, these models will adapt to complex system baselines, enabling earlier detection and intervention. Machine learning based root cause analysis will reduce investigation time: ML-based inference engines are being trained to process historical incident data, system configurations, and telemetry patterns to suggest probable root causes during live incidents. Predictive learning frameworks are projected to help responders narrow down complex investigations much faster than current manual correlation methods. Over time, this will significantly shorten diagnostic windows in large distributed systems. Predictive analytics is emerging to support proactive failure prevention: Anomaly forecasting models are starting to analyze long-term system performance, deployment patterns, configuration changes, and resource utilization to estimate where future incidents may occur. While still maturing, these models are likely to become key tools in helping teams prevent incidents before they impact production environments. Large language models will assist in response and documentation workflows: Context-aware AI models are being introduced into incident response pipelines to generate live incident summaries, assist in retrospective reporting, and suggest procedural adjustments. Gen AI engines will help reduce documentation load during high-pressure recovery phases. As they become fine-tuned on internal incident data, their relevance and accuracy will improve. Self-healing architectures will automate recovery for recurring failures: Systems are being designed to automatically detect certain failure conditions and execute predefined corrective actions such as failovers, service restarts, or resource reallocations. As self-healing logic improves, these systems will handle routine operational disruptions autonomously, reducing downtime for known failure types and allowing responders to focus on more complex incidents. Conclusion You can significantly improve your incident recovery by adopting modern IT incident management software. With automation, real-time monitoring, and predictive analytics, you can detect issues faster and respond with greater accuracy. Modern IT issue-tracking tools minimize downtime, prevent cascading failures, and keep business operations stable even under pressure. By using advanced technologies like machine learning and large language models, you build stronger defenses, improve coordination, and reduce manual errors.

By Joydeep Bhattacharya

CORE

Architects of Ambient Intelligence With IoT and AI Personal Assistants

Introduction: The Moment It Clicked — From Convenience to Contextual Intelligence I still vividly recall a particular brainstorming session at Amazon, the hum of whiteboard markers and the scent of lukewarm coffee filling the room. My team and I were neck-deep in the intricate challenge of weaving Alexa into a sprawling home automation system. We weren't just integrating devices; we were grappling with the nuances of creating a truly responsive environment. It was in that moment, as we debated the finer points of event-driven architectures and state synchronization across disparate protocols, that it truly clicked for me: this wasn't merely about convenience anymore. This was about reshaping the very fabric of how we live, how we interact with our digital and physical worlds, and how technology can genuinely anticipate our needs. As a software development manager with a longstanding affinity for distributed systems, I've witnessed countless technological shifts. Yet, few have captivated me as much as the potent convergence of the Internet of Things (IoT) and artificial intelligence (AI), especially when it comes to personal assistants. The sheer potential for these technologies to deliver hyper-personalized, almost clairvoyant experiences and fundamentally enhance our daily lives is immense. But let's be honest, getting there is a tightrope walk, fraught with complex technical challenges that demand not just dexterity, but deep, insightful engineering. Hyper-Personalization and Behavioral Prediction: Beyond the "Next Best Action" We hear "hyper-personalization" thrown around a lot, often in marketing contexts. But for us, the builders, it's about engineering systems where IoT devices and AI personal assistants don't just react to explicit commands; they anticipate user intent. Think beyond your Google Assistant suggesting a departure time based on traffic. We're talking about systems learning your evening routine and subtly adjusting lighting, ambient temperature, or even proactively queuing up your favorite podcast as you walk through the door. At Amazon, in our work with Alexa, this wasn't about some distant future. We were deep-diving into the trenches of behavioral prediction algorithms, capturing and learning from subtle, often unconscious, user preferences. This wasn't for a "wow" factor; it was about genuine, friction-free augmentation of daily life. From a technical standpoint, this often involves tackling massive streams of sensor data and applying advanced machine learning techniques. A critical piece of the puzzle here is federated learning. This approach, which we heavily explored, offers a compelling balance between deep personalization and user privacy. Instead of shipping sensitive raw user data back to a central cloud, federated learning allows individual devices (your smart speaker, your thermostat, your wearable) to train AI models locally, using the rich, granular data they collect. Only the model updates — essentially, the learned parameters, not the raw data — are aggregated centrally. It's a powerful technique, but it demands meticulous attention to data security protocols, secure aggregation methods, and robust model versioning. It's not a silver bullet, but it's a significant leap forward in addressing the ever-present privacy conundrum. Decentralized AI Processing: Bringing Intelligence to the Edge For years, the cloud has been our default computational playground for AI assistants. But as the sheer volume of IoT data explodes and our reliance on real-time responsiveness grows, the limitations of centralized processing — latency, bandwidth constraints, and lingering privacy concerns — become glaringly apparent. This is where edge computing isn't just a buzzword; it's a fundamental architectural paradigm shift that's been a game-changer in many of my recent projects. By offloading more AI processing directly to edge devices — think local IoT gateways, smart home hubs, or even the devices themselves — we dramatically slash latency. Imagine a smart lock that can recognize a face and unlock in milliseconds, or a health monitor that can detect a critical anomaly and alert paramedics without a round trip to a distant server. During my tenure at Deloitte, I led teams architecting decoupled systems, frequently leveraging edge computing to bolster the real-time decision-making capabilities of various applications. We saw firsthand how this decentralized model could significantly reduce cloud dependency while maintaining, or even enhancing, performance, particularly in low-bandwidth or highly sensitive environments. Implementing robust edge AI isn't trivial. It often means designing for resource constraints (limited memory, CPU, and power), necessitating highly optimized models (e.g., using quantization or pruning techniques) and efficient inference engines. We're talking about micro-frameworks like TensorFlow Lite or ONNX Runtime that can run effectively on embedded systems. The challenge lies in distributing the intelligence intelligently: what stays on the device, what goes to a local gateway, and what, if anything, needs to reach the cloud for deeper analysis or model retraining? It’s a nuanced dance of distributed state management and asynchronous communication. Cross-Industry Healthcare Applications: The Unsung Heroes of Ambient Health When we talk IoT and AI, healthcare might not leap to mind as readily as smart homes or entertainment. Yet, this is precisely where I've witnessed some of the most profound and genuinely life-altering applications. Consider remote patient monitoring, for instance. IoT wearables and sensors tirelessly track vital signs, sleep patterns, glucose levels, and more. The AI then acts as an intelligent sentinel, analyzing these data streams in real-time to provide insights to caregivers, or even directly to patients. Our integration efforts with smart health devices, such as those at Amazon (Alexa), often hinted at a future where AI assistants could autonomously manage elements of personalized patient care plans. Imagine an AI proactively reminding a diabetic patient about medication, analyzing their diet via connected kitchen scales, and even predicting potential hypoglycemic events, then autonomously notifying a doctor before a critical situation develops. This paradigm shift isn't just about convenience; it's about transforming traditional, reactive healthcare into a proactive, personalized model. However, diving into healthcare is like entering a regulatory minefield. We're dealing with strict data privacy regulations like HIPAA. This means building secure, auditable data pipelines, ensuring end-to-end encryption, and often implementing zero-trust architectures. The technical hurdles for achieving robust data interoperability and ensuring security when integrating these solutions into existing, often archaic, healthcare ecosystems are substantial, requiring a deep understanding of both technical and compliance requirements. AI-Driven Interoperability Solutions: The Unifying Fabric of Fragmented Ecosystems The sheer explosion of IoT devices, each with its own proprietary protocols, APIs, and data formats, has created a notoriously fragmented landscape. It's the Wild West of connectivity, and for us developers, it's a persistent headache. During my work with API and cloud integrations at Deloitte, I observed firsthand the frustration users faced when their smart thermostat couldn't talk to their smart lighting, or their fitness tracker offered no unified health dashboard. This is where AI-driven middleware solutions aren't just helpful; they're becoming absolutely indispensable. They act as the universal translator, the semantic layer bridging diverse communication protocols and data schemas. We've explored using AI to enhance API and cloud integration, particularly focusing on dynamic schema generation and real-time data translation. Instead of hardcoding every possible device interaction, an AI model can learn on the fly from diverse data inputs, infer common semantics, and dynamically map incoming data to a standardized model. This involves techniques like natural language processing (NLP) for understanding unstructured device data and graph databases for modeling complex device relationships. It's about building highly adaptable integration layers that can self-configure and self-heal as new devices and protocols emerge. The goal isn't just to connect devices, but to do so in a way that truly respects the heterogeneous nature of modern IoT ecosystems. This journey is far from over; achieving truly seamless, self-adapting interoperability remains an ongoing, fascinating battle, demanding constant innovation in semantic web technologies and machine learning for data inference. Lessons Learned and Actionable Insights: Navigating the New Frontier Reflecting on these experiences, several clear lessons emerge for anyone building in this space: 1. Privacy by Design, Not as an Afterthought The ethical imperative of user privacy and data security cannot be overstated. As developers and tech leaders, we must embed privacy into the very architecture of our systems from day one. This means embracing techniques like federated learning, differential privacy, and robust encryption. Transparency with users about data collection and usage isn't just good PR; it's a cornerstone of trust. 2. Embrace the Edge, But Understand Its Nuances The shift towards edge computing isn't a mere technical adjustment; it's a strategic imperative aligned with broader trends in decentralized data processing. For teams looking to embark on this journey, start small. Pilot projects are invaluable for demonstrating practical benefits, identifying performance bottlenecks, and ironing out deployment and management challenges in a controlled environment. Consider hybrid architectures that intelligently balance edge and cloud capabilities. 3. Collaboration Is Key, and Standards are Our Friends The fragmentation in the IoT landscape is a significant blocker. Collaboration across industries, particularly in areas like healthcare, where disparate systems are the norm, is critical. This necessitates a concerted effort to overcome interoperability challenges, emphasizing the adoption and development of common, open standards (e.g., Matter, OPC UA, FHIR for healthcare). Contributing to open-source solutions can also accelerate progress and foster a more connected ecosystem. Conclusion: Engineering an Adaptive Future The convergence of IoT and AI personal assistants is far more than a technological evolution; it's a profound transformation of how we live, work, and interact with our surroundings. As we engineer smarter, more intuitive systems, the focus will increasingly shift from reactive responses to truly proactive, personalized assistance. This paves the way for environments that don't just passively exist around us, but actively adapt and evolve with us. In the coming years, I foresee an even stronger emphasis on AI ethics and the bedrock of user trust. Transparent, explainable AI models won't just be a nice-to-have; they'll become the non-negotiable foundation of our industry, shaping not only what technology we build but how we build it. As technical leaders, it's our profound responsibility to guide this transformation, ensuring that it genuinely enhances human experiences while unequivocally safeguarding user rights and privacy. The journey ahead is undoubtedly complex, riddled with fascinating technical puzzles. But with each robust system we design, each interoperability challenge we conquer, and each ethical consideration we address, we are fundamentally redefining the possibilities of our digital lives — one intelligent, context-aware interaction at a time.

By Praveen Chinnusamy

Snowflake Cortex for Developers: How Generative AI and SaaS Enable Self-Serve Data Analytics

In the era of low-code, no-code platforms, SaaS solutions, and the new trend called Agentic AI, the industry is focused on optimizing software development for greater efficiency. Text-to-SQL is one such area in software engineering where organizations aim to enable self-serve analytics and democratize SQL using AI. Snowflake Cortex AI, a generative AI offering from Snowflake, bundles this capability into a SaaS product that eliminates the complexity of building custom text-to-SQL solutions. The benefits go beyond reduced development effort. Cortex AI also delivers significantly higher accuracy in SQL query generation compared to custom-built solutions, thanks to its use of a semantic model. Cortex AI comes in two versions: Cortex Analyst to function against structured data stored in traditional tablesCortex Search to function against unstructured data stored as documents (e.g. PDF) Background: The Rise of Self-Serve Analytics Before we dive into Cortex, it is important to understand the challenges organizations face in the field of analytics. Data analytics is an essential part of enterprises across all sectors. Although analyzing data stored in a warehouse has been common practice for over two decades, the rise of big data and data lakes in the past ten years has accelerated the adoption of data analytics across industries. At the heart of data analytics are queries that extract insights from databases to support business decision-making. To accomplish this, business intelligence tools like Tableau and Power BI have become widely used. Data engineers write analytical queries and build dashboards for business teams, who then use these tools to gain insights and drive growth. While this approach works reasonably well, it presents several growing concerns as organizations seek to move faster. Due to the dynamic nature of data, the introduction of new data types, and the adoption of new business models, businesses frequently require updated queries to keep up with evolving demands. Analytical queries often involve complex SQL, and business users typically lack the knowledge of data models or the SQL skills needed to write them. As a result, they must depend on data engineers to build new queries. This dependency becomes a bottleneck, as data engineers have their own workloads and may not be able to respond to ad hoc requests quickly. The process is inefficient and leads to delays in delivering business insights. In the past few years, the emergence of generative AI and large language models (LLMs) has begun to change this landscape. Organizations have started building custom web applications that accept queries in plain English, translate them into SQL, run the SQL against a database, and return results. This shift aims to reduce reliance on technical teams and empower business users to access insights on their own. As generative AI has evolved, so too has the architecture of text-to-SQL systems. Amazon's blog provides a detailed view of this architectural evolution. Although adoption of text-to-SQL continues to grow, building and maintaining these solutions still involves significant complexity. Accuracy remains a major challenge, as incorrect SQL translations lead to invalid or misleading results. Snowflake Cortex addresses this challenge by offering a fully managed SaaS solution that eliminates implementation complexity. It delivers much higher accuracy through its semantic model and supports both structured and unstructured data, providing a significant advancement in making self-serve analytics both accessible and reliable. Cortex Analyst Cortex Analyst is a conversational self-serve data analytics tool powered by generative AI. Cortex Analyst exposes both an SDK and a REST API, which a front-end application running in any technology can use to query a database using a plain English prompt. Figure 1 shows the conceptual architecture of a Cortex Analyst–based solution. Figure-1 Cortex Analyst Architecture The front-end application could be a Snowflake-hosted Streamlit app, a custom Python or Node.js application, or another SaaS solution like Slack. An end user who wants to pull analytics information from the database, without any knowledge of the underlying data model, types their question into the front-end application as a prompt. The application sends the user prompt to the Cortex Analyst API, which performs the processing behind the scenes. It uses a previously configured semantic model and sends the model and prompt to a prompt processor component. Generally, there could be a list of semantic models in the Snowflake ecosystem and the front-end application will choose a semantic model appropriate to the user prompt leveraging some internal algorithm.The prompt processor enriches the user prompt with semantic information using the semantic model, finds similar answerable questions and send the enriched information to an LLM hosted by Snowflake.The LLM generates the SQL, prepares an interpretation of the question and sends the information to the API. The API in its final step executes the query against the database and returns database result as well as interpretation of the prompt/query to the end user. If Cortex Analyst is not able to answer the question asked by the end user, it sends back a possible set of matching questions as response to the user. The intention of returning a set of suggested questions is primarily to prevent hallucination. This also gives the user an opportunity to select an alternative question that better matches their intent, especially when the original prompt does not yield a relevant result in Snowflake. The Semantic Model The core of the Cortex Analyst solution, which enables over 90% query accuracy, is the semantic model. The semantic model serves as the bridge where organization-specific terminology is incorporated, allowing business user vocabulary and raw schema to work together to generate accurate query results. It is the only component in the solution ecosystem that developers need to create and deploy within Snowflake. It is recommended to create a set of semantic models based on the organization’s data domains. This approach helps narrow the scope of queries to specific schemas or tables, thereby improving result accuracy. Snowflake provides a tool for building semantic models, available through its Github repository. In the near future, support for creating semantic models directly within the Snowsight portal will be added, simplifying the development process. A Pool of LLM Agents Figure-1 shows a simplified architecture of Cortex Analyst. There are multiple agents involved in the process to produce accurate query result: LLM specific SQL generation agents - This typically includes the enterprise grade LLMs such as Meta LLama, Mistral, etc. Snowflake added support for DeepSeek-R1 as well as Anthropic Claude.Error correction agents – Responsible for validating syntactical correctness of the generated SQL using Snowflake’s in-built SQL Compiler tool.Synthesizer agent for final query – This agent refines the SQL query and delivers that as final response along with interpretation of the user prompt. Cortex Search Cortex Search is another generative AI-powered solution from Snowflake that works with unstructured documents such as PDFs. It is not a text-to-SQL solution, but rather a fully managed RAG engine designed to deliver high-quality fuzzy search. Figure-2 demonstrates a Cortex Search API based document processing solution. Figure-2: Cortex Search Architecture In this conceptual architecture solution, there are two different flows. Bring documents into Snowflake, process and store for future searchPerform the actual search against stored documents using Cortex Search tool Snowflake, as a product, offers various connectors to bring data from external systems, including those for unstructured data such as documents. Using the SharePoint connector or Snowflake Knowledge Extensions, Snowflake can ingest data from a SharePoint location or third-party systems, as shown in the diagram. The documents that are brought in are processed and stored in the database both as plain text and as vector embeddings. This dual storage approach allows for both vector-based search and text-based search, which helps improve the accuracy of search results. The client-side search architecture is similar to the Cortex Analyst search discussed in the previous section. In this setup, whether the query originates from a Streamlit app, Slack integration, or a custom Node.js or Python-based front-end application, the user prompt is sent to the Cortex Search API. Cortex Search performs two types of search under the hood: vector search and lexical search. It then extracts matching results and re-ranks them. The search results, along with the user prompt, are passed to the LLM, which generates the final response and returns it to the front-end application. Agentic AI With Cortex In 2023, the focus was on getting familiar with Generative AI. In 2024, it shifted to implementing RAG (Retrieval-Augmented Generation) applications. Now, 2025 is shaping up to be the year of building Agentic AI solutions. Early this year, Snowflake introduced its own Agentic AI: Cortex Agent. Cortex Agent is designed to interpret user prompts and determine whether to query structured data using Cortex Analyst, unstructured data using Cortex Search, or both. Unlike traditional one-shot models, Cortex Agent works iteratively. It analyzes the initial results and, if needed, performs additional queries before delivering a complete and accurate response. Getting Started With Cortex Unlike traditional programming language or software library where the process to get started with a tool typically happens by installing library and dive into a GitHub repo, getting started with a Cortex implementation involves a few additional steps. Prerequisite Basic SQL and Python programming knowledgeA Snowflake account Implementation As shown in the architecture diagrams above, developers need to build a front-end application. If you're familiar with Python, the easiest way to get started is by using Streamlit, which can be built directly within the Snowsight portal in Snowflake. Simply log in to your Snowflake account and follow the quick-start guide to create a data warehouse, load data, and build your Streamlit application. Cortex AnalystCortex Search Low Level AI Functions From a developer standpoint, it is important to be aware of a few notable low-level functions Cortex AI offers to build solution. COMPLETE function uses LLM to produce the final output to client or consumerCORTEX.PARSE_DOCUMENT - performs the OCR type of work with added capability to retain the layout such as table headers using the layout ON/OFF modeSPLIT_TEXT_RECURSIVE_CHARACTER - parses the extracted document and splits into logical segmentsCORTEX.FINETUNE - capability to fine tune out-of-the-box LLMsCLASSIFY_TEXT - text classification function Cortex Security A discussion about AI can’t be complete without talking about security. Snowflake incorporates appropriate guardrails to protect customer data in Cortex AI implementation. LLMs are deployed within Snowflake boundary therefore data never leaves outside of Snowflake.The Cortex AI services run within Snowflake boundary and is executable only via appropriate RBAC (role based access control) policy.The structured data or the unstructured documents are all brought into Snowflake and Cortex Analyst or Search runs within the datastore of SnowflakeThe query or prompt from an external service like Slack or custom user interface is sent using Cortex REST API over HTTPS and further processed within Snowflake. Conclusion In this article, we introduced Snowflake Cortex, a SaaS-based generative AI solution. This tool removes the need for custom text-to-SQL implementations and significantly improves query accuracy. It also offers advanced capabilities for ingesting documents via connectors and performing searches on unstructured data. Cortex reduces both implementation and infrastructure management overhead while enabling non-technical users to access self-serve analytics. The platform is user-friendly, feature-rich, and continues to improve with advancements in LLM and AI. It is gaining traction and is expected to see increased adoption across the industry.

By Dipankar Saha

The Future Is Now: Top Generative AI Services You Can’t Ignore

AI continues to transform various sectors, with generative AI leading a new wave of innovation. Unlike traditional AI that focuses on processing and interpreting data, generative AI creates entirely new content, including text, visuals, audio, and video, offering fresh possibilities for how we build and interact with technology. Overview of Generative AI Services and Solutions How Does Generative AI Work? Generative AI works by taking a large dataset. It learns patterns from the data. Then it learns and creates new and unique content. For example, OpenAI's GPT model generates text. You ask it a question, it writes the full answer to you. Similarly, DALL·E creates images. Why Are Generative AI Services and Solutions Important? Saves time: Earlier it used to take hours to create content. Now, with the help of Generative AI services, the work is done in seconds.Reduces cost: Expenses on manual work are reduced.Improves quality: AI is always upgrading, so content quality is also better.Personalization: Can create different content for each user. What Is the Role of a Generative AI Development Company? Every business has different needs. A Generative AI Development Company creates customized AI solutions. They design AI models according to your company's work, budget, nd target audience. For example, if your business is in healthcare, AI will help you create medical reports. Leading Generative AI Services and Their Impact Large Language Models (LLMs) for Text Generation OpenAI's GPT series (GPT-4o, GPT-4, etc.) and ChatGPT: These models are at the forefront of natural language understanding and generation. Applications: Content creation (articles, marketing copy, social media posts), customer support (chatbots, virtual assistants), code generation (e.g., GitHub Copilot, which leverages OpenAI's models), summarization, translation, and even creative writing like poetry and scripts.Why they stand out: Their immense size and training data enable them to generate remarkably coherent, contextually relevant, and human-like text, often outperforming previous generations on various benchmarks.Google's Gemini: A multimodal family of models capable of handling text, images, audio, and video. Applications: Similar to GPT models, Gemini excels in content creation, summarization, and conversational AI, with added capabilities for understanding and generating across different modalities. This opens doors for more interactive and visually rich applications.Why it stands out: Its multimodal nature allows for a more holistic understanding of information and more versatile output, making it highly adaptable for diverse use cases.Anthropic's Claude: Developed with a focus on AI safety and interpretability. Applications: Strong in conversational AI, content generation, and tasks requiring responsible and understandable interactions, often used in enterprise settings where safety and transparency are crucial.Why it stands out: Its emphasis on "constitutional AI" and safety makes it a preferred choice for applications where ethical considerations are paramount.Cohere: Specializes in natural language processing (NLP) and offers powerful generative AI models for enterprises. Applications: Enterprise-grade text generation, summarization, semantic search, and more, with a focus on scalability and integration into existing business workflows.Why it stands out: Its focus on enterprise solutions and strong NLP capabilities make it a valuable asset for businesses looking to integrate generative AI into their operations. Image and Video Generation OpenAI's DALL-E (DALL-E 2, DALL-E 3): Generates high-quality images from text descriptions. Applications: Graphic design, advertising, content creation, concept art, and visual storytelling.Why it stands out: Its ability to produce diverse and creative images from simple text prompts has revolutionized visual content creation.Adobe Firefly: A multimodal AI tool for generating and editing text, images, audio, and video, integrated into Adobe's creative suite. Applications: Enhancing creative workflows for designers, photographers, and video editors, allowing for rapid content generation and manipulation.Why it stands out: Its seamless integration into professional design tools makes it incredibly powerful for creative professionals.Stability AI's Stable Diffusion: An open-source model for generating images from text or other images. Applications: Similar to DALL-E, but with the added flexibility of being open-source, allowing for widespread customization and development within the community.Why it stands out: Its open-source nature has fueled a massive ecosystem of developers and applications, enabling rapid innovation and specialized use cases.RunwayML: A leading platform for AI-powered video creation and editing. Applications: Generating videos from text, applying various visual effects, and streamlining the video production process for creators.Why it stands out: It aims to democratize AI video creation, making powerful tools accessible to a broader audience.Synthesia: An AI video platform for creating realistic AI presenters and videos from text. Applications: Corporate training, marketing videos, personalized communications, and creating digital avatars.Why it stands out: Its focus on generating human-like video content with customizable avatars offers unique possibilities for content delivery. Audio and Music Generation ElevenLabs: Specializes in AI voice and audio generation, offering versatile assets. Applications: Voiceovers, audiobooks, podcasts, game development, and creating synthetic voices for various applications.Why it stands out: Its ability to generate high-quality, natural-sounding voices with emotional nuances makes it a powerful tool for audio content.Suno AI: Focuses on creative text-to-audio results, particularly for music. Applications: Music composition, generating sound effects, and creating unique audio experiences from text prompts.Why it stands out: It allows users to generate full songs, complete with lyrics and instrumentation, from simple text descriptions, pushing the boundaries of AI in music. Code Generation and Development Tools GitHub Copilot (powered by OpenAI): An AI pair programmer that provides real-time code and function suggestions. Applications: Accelerating software development, generating boilerplate code, assisting with debugging, and translating programming languages.Why it stands out: It significantly boosts developer productivity by automating repetitive coding tasks and offering intelligent suggestions.Amazon CodeWhisperer: Another AI coding companion offered by AWS. Applications: Code generation, improving code quality, and assisting developers within the AWS ecosystem.Why it stands out: Its deep integration with AWS services makes it particularly valuable for developers working on cloud-native applications. Enterprise Solutions and Platforms Microsoft Azure OpenAI Service: Integrates OpenAI's models into Azure's cloud platform, providing enterprise-grade security and scalability. Applications: Building custom AI applications, powering internal tools, and leveraging generative AI for various business functions like customer service, legal drafting, and content creation.Why it stands out: Offers a robust and secure environment for enterprises to deploy and manage generative AI models.Google Cloud Vertex AI: Google's unified platform for building, deploying, and scaling AI models, including its own generative AI models. Applications: Developing custom AI solutions, leveraging Google's cutting-edge models for diverse business needs, and integrating AI into existing workflows.Why it stands out: Provides a comprehensive suite of tools and services for the entire AI lifecycle, making it a strong choice for complex enterprise AI initiatives.Amazon Bedrock: A fully managed service that makes foundation models from Amazon and leading AI startups accessible via an API. Applications: Rapidly building and scaling generative AI applications with various pre-trained models, without managing infrastructure.Why it stands out: Simplifies access to a wide range of powerful foundation models, allowing businesses to experiment and deploy generative AI applications quickly.IBM watsonx: IBM's platform for enterprise AI, focusing on trust and responsible AI. Applications: AI solutions for industries like finance and healthcare, with emphasis on data governance, explainability, and compliance.Why it stands out: IBM's long-standing expertise in enterprise technology and commitment to responsible AI make Watson a strong contender for businesses with stringent requirements. How Industries Use Generative AI Services and Solutions Marketing AI makes content marketing better and faster. Blogs, emails, and social media posts are automated. E-commerce AI also generates product descriptions, customer support, and reviews. Healthcare AI helps in medical reports, diagnoses, and clinical notes. Education AI creates personalized lesson plans and quizzes for teachers. Media and Entertainment AI helps create music, scripts, and video content. Challenges of Generative AI Deepfakes and Misuse With the help of AI, it has become easy to create fake videos. This can also lead to the spreading of false news. Copyright and Legal Issues The ownership of AI-generated content is not yet clear. This can lead to copyright disputes. Impact on Jobs Some simple jobs may be lost to AI. But new and better jobs will also come. How to choose the right Generative AI Service or Solution? Understand the needs of your business.Compare budget and features.See that it can work with the rest of your software.Customer support should be good. Prospects Generative AI is now connecting with technologies like AR (Augmented Reality), VR (Virtual Reality), IoT (Internet of Things), and blockchain. This will create new and exciting products and solutions. With the rise of Generative AI services, real-time AI support and hyper-personalization are also becoming more accessible and impactful across industries. Conclusion Generative AI Services are no longer the future; they have already become the present. Every business, small or large, can benefit from it. Whether you are a marketer or an educator, start with a reliable Generative AI Development Company and take the next step in growth.

By Chandrasekhar Kumar Sah

CORE

Cybersecurity Innovations in Software Development: How Developers Are Tackling Security Threats

Cybersecurity is more critical than ever as technology becomes more integrated into our daily lives and business operations. Cyber threats change quickly, so software developers need to make sure that apps, data, and users are safe by putting strong security measures in place. New developments in cybersecurity, like post-quantum cryptography and AI-driven threat detection, are changing the way software are developed. In this blog post, I will discuss the advanced cybersecurity innovations in software development and how software developers are dealing with security problems. Let’s start with navigating the growing cyber threats! The Growing Cyber Threats Cybersecurity threats are getting smarter and are attacking everything from personal information to important infrastructure. According to Statista, cybercrime costs worldwide are estimated to hit $10.5 trillion annually by 2025. Here are some of the most dangerous threats: Phishing Attacks: Scam emails get people to give out private information.Ransomware: This is bad software that locks up your files and demands money to unlock them.Zero-Day Exploits: Attackers take advantage of security holes before coders can fix them.Supply Chain Attacks: Hackers get into software changes to make them more likely to contain malware.Insider Threats: Insider threats happen when employees or partners abuse their access to break security. Considering these threats, software developers are putting advanced security steps in place to keep apps and user data safe. How Software Developers are Tackling these Cyber Threats Hackers are smarter than ever before, and software developers are using a variety of ways to deal with cyber threats. Below are some different cybersecurity innovations software developers are incorporating in development lifecycles to keep both apps and users safe. Shift-Left Security Approach In the past, security testing was done at the end of the creation process. The shift-left method, on the other hand, builds security into the process early on. Whether developing an app for esim card for Germany or a fintech solution to streamline finances, this approach can make the development process safe and secure. For enhances security, developers now conduct: Threat modeling is now something that developers do to find holes in the system before they start writing code.Security testing that is done automatically in CI/CD pipelines.Review secure code to find bugs before deploying software. This proactive approach reduces security risks and makes sure that security is built into apps. By building security into the whole process of development, developers can stop flaws before they happen instead of having to fix them after the fact. Threat Detection Powered by AI Artificial intelligence (AI) is revolutionizing cybersecurity by enabling in many ways and some of those are: Real-time threat detection is one way that artificial intelligence (AI) is changing cybersecurity.Behavioral analysis to find strange things that users are doing.Automatic reaction systems that stop attacks before they get worse. Developers can stay ahead of hackers with the help of AI-powered security tools that can spot and stop threats. For instance, security systems that use AI can look at patterns in network traffic to find odd behavior, stopping possible breaches before they happen. Zero Trust Architecture By default, the Zero Trust model says that no one should be believed, inside or outside the network. For this purpose, software developers use techniques like: Multi-factor authentication (MFA) is used by developers to make sure that users are who they say they are.Using micro-segmentation to control who can see private info.Constant watching to find people who aren't supposed to be there. This method reduces the chance of insider threats and breaches that aren't authorized. Zero Trust architecture makes apps and networks safer by enforcing strict access controls and checking each request. Post-Quantum Cryptography As quantum computing gets closer, old ways of encrypting data are becoming less secure. Post-quantum cryptographic methods are being used by software developers to make security more future-proof and protect data from quantum-based attacks. A lot of people use encryption methods like RSA and ECC, but quantum computers might be able to break them. To protect against this danger, scientists are working on quantum-resistant methods of encryption, such as: Lattice-based cryptography: To protect data, it uses complicated mathematical patterns.Hash-based cryptography: Makes use of secure hash functions to keep information safe.Multivariate polynomial cryptography: This type of encryption uses mathematical equations to make it safe. By using post-quantum cryptography in software development, developers can keep private information safe for a long time. Secure DevOps (DevSecOps) DevSecOps integrates security into the DevOps process, ensuring: Automated security scans in development pipelines.Container protection for apps that run in the cloud.Infrastructure as Code (IaC) security to avoid misconfigurations. This method improves security without slowing down the development process. Developers can find and fix security holes early in the software development lifecycle by incorporating security into DevOps processes. Blockchain for Cybersecurity Software developers are using blockchain technology to make their work safer. Here are some important applications: Decentralized identity management: This makes centralized authentication methods less necessary to enhance overall security.Tamper-proof data storage: Makes sure data is correct and prevents illegal changes.Smart contracts for security automation: These are the contracts that run themselves to enforce security rules. Because blockchain is not centralized, it is not vulnerable to cyberattacks. This adds another layer of security to data and apps. Homomorphic Encryption for Secure Data Processing Homomorphic encryption lets you do math on secured data without having to decrypt it first. Cloud computing: This new technology improves security by letting data be processed safely without putting private information at risk.Privacy-preserving AI: This feature lets AI models look at protected data without revealing it to anyone else.Safe financial transactions: Keeps private financial information from getting into the wrong hands. Developers can protect data privacy and make processes safe by using homomorphic encryption. How Cybersecurity Will Change in Software Development Cyber threats are always changing, so coders need to stay alert and flexible. New technologies like biometric identity, security automation powered by AI, and quantum-safe encryption will make security even stronger. Developers can make software that saves users and businesses from cyber threats by using these new cybersecurity innovations and ideas. Cybersecurity isn't just an option anymore; it's an important part of software development processes. Developers who put security first will not only keep their apps safe, but they will also build trust and credibility among competitors.

By Fawad Malik

AI/ML Big Data-Driven Policy: Insights Into Governance and Social Welfare

Data-driven policy refers to the practice of using data, analytics, and empirical evidence to inform and guide government decision-making, moving beyond reliance on intuition or anecdotal information. Governments must be agile, transparent, and resilient in their decision-making. The convergence of big data, cloud computing, and AI/ML is enabling a new era of data-driven policy, transforming how societies anticipate challenges and adapt to change. This article explores the impact of data-driven governance, illustrated with real-world examples, statistics, and diagrams. The Data-Driven Policy Ecosystem Modern policy-making is no longer a static process. By integrating diverse data sources, leveraging cloud infrastructure, and applying AI-powered analytics, governments can make informed decisions, respond to emerging threats, and build societal resilience. Diagram: Data-Driven Policy Framework Smart Cities: South Korea's Songdo South Korea's Songdo and Beyond One of the most sophisticated smart cities in the world, Songdo was created from the ground up using data-driven infrastructure. An underground waste system replaces the need for garbage trucks, and sensors track waste, traffic, and energy consumption. This has led to significant environmental and social benefits: Enhancing residents’ quality of life by 70% fewer emissions than developments of a comparable size (Integrated Data Infrastructure | Stats NZ, n.d.) and 40% green space. Forecasted increases of 60,000 jobs and 100,000 residents, driving economic growth. These innovations have reduced energy and water consumption and improved residents’ quality of life. along with Songdo which has data-driven urban planning. In the United States, San Antonio, Aurora, Mesa, and Raleighare are examples for leveraging data to enhance urban living in USA (Violino, 2025). For instance: Aurora, IL, uses AI for resident collaboration through platforms like Zencity Engage and has implemented a Public Safety Transparency Program with body cameras and drones (Violino, 2025). San Antonio, TX, launched the Smarter Together initiative in 2023, focusing on access to public information, public safety, and environmental quality, with prototype projects like an AI chatbot for bond construction updates. Raleigh, NC, employs computer vision at intersections to reduce traffic fatalities, integrating Esri GIS and NVIDIA AI. Mesa, AZ, has a Smart City Master Plan that includes smart metering, real-time crime centers, and augmented reality for tourism. These examples illustrate the global adoption of data-driven policies in smart cities, showcasing how diverse initiatives can address urban challenges and improve citizen well-being. Healthcare Expansion: Kenya Kenya’s Digital Leap Data analytics is being adopted by Kenya’s health sector to enhance patient care and resource allocation, particularly in underprivileged areas. Over the past decade, healthcare spending has increased by 6.2% annually (Kurowski et al., 2024), and analytics has enabled hospitals to reduce patient wait times by 30%, staff overtime by 20%, and increase patient satisfaction by 15% (Nazrien Kader et al., 2017). However, 67% of private hospitals still rely on outdated practices, highlighting the need for further modernization. Kenya is increasing access to healthcare and improving outcomes for vulnerable populations by leveraging data to identify gaps and allocate resources. Digital Health Act enablement in October 2023, which enables exemplery use of technology for healthcare (Cipesa, 2024). This landmark legislation enhances privacy, confidentiality, and security of health data while supporting m-Health, telemedicine, and e-learning. It also treats health data as a strategic national asset, facilitating data sharing for decision-making and ensuring equitable health standards. By establishing a Digital Health Agency to manage an integrated health information system, Kenya is positioning itself as a leader in digital health governance in Africa. Disaster Preparedness: AI-Powered Flood Forecasting Disaster relief is changing as a result of AI and predictive analytics. Based on real-time data, Google's Flood Hub and similar websites in Kenya predict floods and issue early warnings, expanded flood forecast coverage in high-risk areas, enabling more rapid and targeted interventions (Diaz, 2025). These systems help authorities efficiently allocate resources and evacuate vulnerable communities to reduce the loss of life and property. Diagram: The Resilience Cycle in Data-Driven Policy Social Services and Policy Evaluation: New Zealand By connecting data from various government agencies, New Zealand's Integrated Data Infrastructure (IDI) makes it possible to assess the long-term effects of policies. Over a 20-year period, early childhood interventions have demonstrated an 8:1 return on investment, directing future social spending (Integrated Data Infrastructure | Stats NZ, n.d.). Policymakers can evaluate what works, improve programs, and optimize the benefits of government initiatives with this approach. Citizen Engagement and Transparency The way citizens engage with the government is changing as a result of open data platforms. These days, cities all over the world release information about their budgets, infrastructure, and environmental conditions. Data-driven policy not only improves decision-making efficiency but also strengthens democratic institutions. The Open Data Barometer data reports that open data efforts have resulted in greater accountability and boosted civic participation, showing how transparency can foster trust and engagement between governments and citizens. Diagram: Adaptive Governance Feedback Loop Challenges and Considerations Although data-driven policy has revolutionary advantages, it also presents fresh difficulties. Privacy and Ethics: It's critical to safeguard personal information and make sure algorithmic decisions are equitable.Transparency: People need to know how data drives policy.Digital Divide: Reducing disparities in access and digital literacy is necessary to guarantee that all communities gain from data-driven governance. Conclusion Governance is changing as a result of data-driven policy, which is also making societies more inclusive, flexible, and resilient. Governments can increase citizen trust, make better decisions, and react quickly to emergencies by utilizing big data, cloud computing, and AI/ML. The aforementioned examples demonstrate that the future of governance involves more than just technology; it also involves the prudent use of data to build a more resilient and better world for everybody. References 1. Integrated Data Infrastructure | Stats NZ. (n.d.). https://www.stats.govt.nz/integrated-data/integrated-data-infrastructure/ 2. Violino, B. (2025, March 20). 4 cities proving the transformative value of data and IT. CIO. https://www.cio.com/article/3476112/4-cities-proving-the-transformative-value-of-data-and-it.html 3. Kurowski, C., Schmidt, M., Evans, D. B., Tandon, A., Eozenou, P. H.-V., Cain, J. S., Pambudi, E. S., & Health, Nutrition and Population Global Practice, World Bank, Washington, DC, USA. (2024). Government health spending outlook - Projections through 2029. https://documents1.worldbank.org/curated/en/099110524145099363/pdf/P506692116ebcb0e188b4175eb4c560cb5.pdf 4. Nazrien Kader, Wilson, M., Lyons, S., Klopper, L., & Walters, J. (2017). Guide to fiscal information. https://www2.deloitte.com/content/dam/Deloitte/fpc/Documents/services/fiscalite/deloitte-afrique_guide-fiscal-panafricain-2017.pdf 5. Cipesa. (2024, May 3). Does Kenya’s Digital Health Act Mark A New Era for Data Governance and Regulation? Collaboration on International ICT Policy for East and Southern Africa (CIPESA). https://cipesa.org/2024/05/does-kenyas-digital-health-act-mark-a-new-era-for-data-governance-and-regulation/ 6. Diaz, A. (2025, February 18). Advanced Flood Hub features for aid organizations and governments. Google. https://blog.google/technology/ai/advanced-flood-hub-features-for-aid-organizations-and-governments/

By Ram Ghadiyaram

How to Test Multi-Threaded and Concurrent Java

Testing multi-threaded, concurrent Java code is difficult because each test run only captures one possible thread interleaving, and those interleavings are non-deterministic. To address this, I created the open-source tool VMLens. VMLens allows you to test concurrent Java code in a deterministic and reproducible way by executing all possible thread interleavings. In this guide, I will show you how to use VMLens with a simple example. We will build a concurrent Address class that holds a street and a city. The class should support parallel reading and writing from multiple threads. You can download all examples from this Git repository. The First Problem: A Data Race Here is our first implementation of the Address: Java public class Address { private String street; private String city; public Address(String street, String city) { this.street = street; this.city = city; } public void update(String street, String city) { this.street = street; this.city = city; } public String getStreetAndCity() { return street + ", " + city; } } And the test: Java @Test public void readWrite() throws InterruptedException { try(AllInterleavings allInterleavings = new AllInterleavings("howto.address.regularFieldReadWrite")) { while (allInterleavings.hasNext()) { // Given Address address = new Address("First Street", "First City"); // When Thread first = new Thread() { @Override public void run() { address.update("Second Street","Second City"); } }; first.start(); String streetAndCity = address.getStreetAndCity();; first.join(); // Then assertThat(streetAndCity,anyOf(is("First Street, First City"), is("Second Street, Second City"))); } } } The test updates the Address in a newly started thread, while simultaneously reading the Address inside the original thread. We expect to either read the original address if the read happens before the update. Or the updated address if the read happens after the update. We test this using the assertion: Java assertThat(streetAndCity,anyOf(is("First Street, First City"), is("Second Street, Second City")));` To cover all possible thread interleavings, we wrap the test in a while loop that runs through every possible execution order: Java try(AllInterleavings allInterleavings = new AllInterleavings("howto.address.regularFieldReadWrite")) { while (allInterleavings.hasNext()) { Running the test with VMLens leads to the following error: a data race. A data race occurs when two threads access the same field at the same time without proper synchronization. Synchronization actions — such as reading or writing a volatile field or using a lock — ensure visibility and ordering between threads. Without synchronization, there’s no guarantee that a thread will see the most recently written value. This is because the compiler may reorder instructions, and CPU cores can cache field values independently. Both synchronization actions and data races are formally defined in the Java Memory Model. As the trace shows, there is no synchronization action between the read and write to our street and city variables. So VMLens reports a data race. To fix the error, we add a volatile modifier to both fields. The Second Problem: A Read-Modify-Write Race Condition Here is the new Address class with the two volatile fields: Java public class Address { private volatile String street; private volatile String city; public Address(String street, String city) { this.street = street; this.city = city; } public void update(String street, String city) { this.street = street; this.city = city; } public String getStreetAndCity() { return street + ", " + city; } } When we run our test now, the assertion fails: Plain Text Expected: (is "First Street, First City" or is "Second Street, Second City") but: was "First Street, Second City" We read a partially updated Address. The VMLens report reveals the specific thread interleaving that caused this error: The main thread first reads the street variable before it has been updated. Meanwhile, another thread updates both the street and city variables. When the main thread later reads the city variable, it ends up seeing a partially updated Address. To solve this, we use a ReenatrantLock. The Solution: A Lock For our new test, we add a ReenatrantLock to the update and getStreetAndCity methods: Java public class Address { private final Lock lock = new ReentrantLock(); private String street; private String city; public Address(String street, String city) { this.street = street; this.city = city; } public void update(String street, String city) { lock.lock(); try{ this.street = street; this.city = city; } finally { lock.unlock(); } } public synchronized String getStreetAndCity() { lock.lock(); try{ return street + ", " + city; } finally { lock.unlock(); } } } Now our test succeeds. What to Test? When we write a concurrent class, we want the methods of the class to be atomic. This means that we either see the state before or after the method call. We already tested this for the parallel execution of updating and reading our Address class. What is still missing is a test for the parallel update of our class from two threads. This second test is shown below: Java @Test public void writeWrite() throws InterruptedException { try(AllInterleavings allInterleavings = new AllInterleavings("howto.address.lockWriteWrite")) { while (allInterleavings.hasNext()) { // Given Address address = new Address("First Street", "First City"); // When Thread first = new Thread() { @Override public void run() { address.update("Second Street","Second City"); } }; first.start(); address.update("Third Street","Third City"); first.join(); // Then String streetAndCity = address.getStreetAndCity(); assertThat(streetAndCity,anyOf(is("Second Street, Second City"), is("Third Street, Third City"))); } } } This test also succeeds for the class with the ReenatrantLock. Tests Are Missing The number of cores of the CPU is continuously increasing. In 2020, the processor with the highest core count was the AMD EPYC 7H12 with 64 cores and 128 hardware threads. Today, June 2025, the processor with the highest core count has 288 efficiency cores, the Intel Xeon 6 6900E. AMD increased the core count to 128 and 256 hardware threads with the AMD EPYC 9754. Java with volatile fields, synchronization blocks and the powerful concurrency utilities in java.util.concurrent allows us to use all those cores efficiently. Project Loom with its virtual threads and structured concurrency will further improve this. What is still missing is a way to test that we are using all those techniques correctly. I hope VMLens can fill this gap. Get started with testing multi-threaded, concurrent Java here.

By Thomas Krieger

Distributed Rate Limiting in Java: A Deep Dive into Bucket4j + PostgreSQL

Important note: There are implementation details for the integration between PostgreSQL and the bucket4j library, specifically for version 8.14.0. The post's author is not responsible for future changes, but I'm 90% sure that it will be accurate for a long time. Hey everyone! Have you ever needed a distributed rate limiter in Java, only to realize there aren’t many out-of-the-box solutions available? It can feel overwhelming to piece together a reliable approach, especially when working in distributed systems. That’s where Bucket4j comes in — a powerful library that simplifies rate limiting while ensuring consistency across distributed environments. Imagine writing code like this (below) and trusting that your rate-limiting logic will work seamlessly across multiple instances of your application: Java boolean tryConsume(HttpRequest request, HttpResponse response) { Long key = getKey(request); Bucket bucket = bucketProvisioner.getBucket(key); ConsumptionProbe probe = bucket.tryConsumeAndReturnRemaining(tokenNum); if (probe.isConsumed()) { response.addHeader("X-Rate-Limit-Remaining", String.valueOf(probe.getRemainingTokens())); return true; } long waitForRefill = toSeconds(probe.getNanosToWaitForRefill()); response.addHeader("X-Rate-Limit-Retry-After-Seconds", String.valueOf(waitForRefill)); return false; } If your tech stack relies heavily on relational databases like PostgreSQL, Bucket4j offers a compelling solution for distributed rate limiting without the need for in-memory caches like Redis or Hazelcast. However, if you prefer working with Ignite or Hazelcast, Bucket4j has you covered as well, thanks to its native support for the JCache API (JSR 107). Of course, it has a Spring Boot starter to simplify your user experience. But in this post, we’ll dive specifically into Bucket4j + PostgreSQL integration to explore how it works and why it’s a great choice for relational database-based systems. How It Works: Bucket4j + PostgreSQL Bucket4j leverages PostgreSQL to implement a distributed token bucket algorithm. Each "bucket" (representing rate limits for a user, API key, or resource) is stored as a serialized object in a PostgreSQL table. The library ensures atomicity and consistency across multiple application instances, making it perfect for distributed systems. Locking Strategies: Ensuring Consistency To prevent race conditions and maintain accurate rate limits, Bucket4j employs two locking mechanisms: SELECT ... FOR UPDATE: This approach locks the specific row representing the bucket's state during a transaction, ensuring exclusive access.pg_advisory_xact_lock: A more advanced method leverages PostgreSQL's advisory locks, which are application-level locks not tied to specific rows. For most cases, Bucket4j uses a hash of the bucket's identifier (e.g., user ID or API key) as the lock key. However, when working with numeric keys, the algorithm directly uses the numeric value as the lock key. Both strategies ensure consistency, but the choice depends on your application's requirements and PostgreSQL expertise. However, it's worth noting that the SELECT ... FOR UPDATE approach typically sends 4 requests compared to 5 requests in the advisory locking case, making it slightly more efficient in terms of database interactions. Code in Action: Configuration Made Simple Here’s a quick example of how you can configure Bucket4j with PostgreSQL: Java ProxyManager<Long> proxyManager = Bucket4jPostgreSQL .selectForUpdateBasedBuilder(dataSource) .build(); // it will be use as a lock key in db Long key = 1L; BucketConfiguration bucketConfiguration = BucketConfiguration.builder() .addLimit(limit -> limit.capacity(10).refillGreedy(10, ofSeconds(1))) .build(); BucketProxy bucket = proxyManager.getProxy(key, () -> bucketConfiguration); This setup connects your application to PostgreSQL, enabling distributed rate limiting with minimal effort. SQL in Action: What Happens Under the Hood Let’s take a closer look at the SQL queries Bucket4j generates: 1. SELECT ... FOR UPDATE Example Initialization/First Request SQL BEGIN; SELECT state FROM bucket WHERE id = 'your-bucket-id' FOR UPDATE; INSERT INTO bucket(id, state) VALUES('your-bucket-id', null) ON CONFLICT(id) DO NOTHING; COMMIT; This sequence locks the row, retrieves the bucket's state, and inserts it if it doesn’t exist. Subsequent Requests (Updating State) SQL BEGIN; SELECT state FROM bucket WHERE id = 'your-bucket-id' FOR UPDATE; UPDATE bucket SET state = $1, expires_at = '...' WHERE id = 'your-bucket-id'; COMMIT; The row is locked, and the serialized state ($1) is updated with the remaining tokens and metadata. 2. pg_advisory_xact_lock Example Locking and Retrieving State Here, the advisory lock ensures transaction-level consistency without locking specific rows. SQL BEGIN; SELECT pg_advisory_xact_lock('hash-of-your-bucket-id'); SELECT state FROM bucket_lock WHERE id = 'your-bucket-id'; -- INSERT or UPDATE logic follows... COMMIT; Key Considerations Eviction Policy To prevent unbounded growth, expired buckets need to be cleaned up periodically. Bucket4j calculates an expires_at value, but you’ll need a background job to delete old entries. You can find extra details in the documentation. Performance While PostgreSQL is highly performant, it’s not as fast as in-memory caches for extreme high-throughput scenarios. Consider your latency requirements before choosing this approach. Serialization The bucket state is stored as a serialized object in the database. Bucket4j handles this seamlessly, but it’s worth understanding how it works. Transaction Isolation Ensure your database transactions use an appropriate isolation level (e.g., READ COMMITTED) to maintain consistency. Lock Key Isolation When using pg_advisory_xact_lock, ensure that each lock key is unique to avoid unintended locking of unrelated transactions. Conclusion Bucket4j’s PostgreSQL integration is a robust solution for distributed rate limiting, especially for teams already leveraging PostgreSQL. By understanding its locking mechanisms and SQL operations, you can confidently implement rate limiting to protect your APIs and ensure a smooth user experience. While in-memory caches like Redis may be preferable for ultra-high-performance scenarios, Bucket4j combined with PostgreSQL offers a reliable and accessible alternative for many use cases. Have you used Bucket4j or implemented distributed rate limiting in your projects? Let me know your thoughts and experiences in the comments!

By Arkadii Osheev