InfoWorld's Avatar

InfoWorld

@infoworld.com.web.brid.gy

Business technology, IT news, product reviews and enterprise IT strategies. [bridged from https://infoworld.com/ on the web: https://fed.brid.gy/web/infoworld.com ]

4 Followers  |  0 Following  |  509 Posts  |  Joined: 05.02.2025  |  3.0736

Latest posts by infoworld.com.web.brid.gy on Bluesky

Preview
Databricks One mirrors Microsoft Copilot strategy to transform enterprise data access Databricks has previewed a no-code version of its Data Intelligence platform — Databricks One — that aims to provide AI and BI tools to non-technical users through a conversational user interface. According to analysts, Databricks One draws inspiration from Microsoft’s M365 Copilot strategy to reimagine the user interface of M365, centering on generative AI, and applies this approach to the enterprise data analytics tools that Databricks provides. “Databricks One mirrors Microsoft’s M365-Copilot strategy in that it reimagines the user interface, although not for productivity apps, but for enterprise data and AI,” said Michael Ni, principal analyst at Constellation Research. Speaking to ComputerWorld, last month, a top Microsoft executive said that the company was planning to move away from a typical apps based interface to a Copilot driven experience in the future: instead of accessing individual apps like Word, Excel and PowerPoint, users prompts Copilot with the task at hand and the generative AI assistant spins up the required application. Databricks One similarly offers a simplified, AI-assisted access point to governed data, metrics, and insights, helping business teams engage without code or complexity. “It’s not about replacing business intelligence (BI) tools, but about embedding decision intelligence into daily workflows,” Ni said. ## One comes with AI/BI Dashboards and apps As part of the One platform, which is currently in private preview and can be accessed by Data Intelligence platform subscribers for free, Databricks is offering AI/BI Dashboards, Genie, and Databricks Apps along with built-in governance and security features via Unity Catalog and the Databricks IAM platform. While AI/BI Dashboards will enable non-technical enterprise users to create and access data visualizations and perform advanced analytics without writing code, Genie, a conversational assistant, will allow users to ask questions on their data using natural language. The conversational assistant is also expected to support deep research on data as it understands business-specific semantics, the company said. Additionally, Databricks Apps inside One will allow non-technical users to package complex workflows that interweave analytics, AI, and transactional processing in a custom app for a particular use case, the company said. However, Moor Insights and Strategy principal analyst Robert Kramer pointed out that enterprises shouldn’t expect every advanced feature of the Data Intelligence platform to be baked inside One, despite it connecting to the same backend core engine of the platform and working on the same enterprise data. ## Centralizing metadata on Databricks’ platform Analysts see Databricks One as a vehicle for the lakehouse provider to drive stickiness of its products. “Databricks One is a Trojan horse for garnering enterprise mindshare and an effort towards centralizing metadata on Databricks’ platform. The more users rely on One to make decisions, the more sticky the Databricks platform becomes,” said Constellation Research’s Ni. The decision to launch One could be seen as Databricks’ first salvo in the next war engulfing the data and analytics space: It isn’t just about which vendor has captured more enterprise data, but which vendor helps enterprises understand it better and makes it easy to use for business scenarios or use cases, Ni added. Although, when compared to rivals, Databricks’ approach to making analytics easier without code and accessible via natural language is not new, Kramer pointed out that Databricks One stands out. “Other vendors like Snowflake (with Cortex AI) and Microsoft (with Fabric and Copilot) also offer natural language tools for business users. Databricks One stands out because it’s built directly into the lakehouse platform,” Kramer said. Separately, Databricks has also launched a free edition of its Data Intelligence platform in order to encourage users to try out the gamut of tools and capabilities that the platform offers. Analysts see the free edition as a “classic category capture.” While at one end it will help shape the talent ecosystem when it comes to Databricks’ stack, it is also a moat builder at the other end, Ni said, adding that the earlier developers and data analysts get hooked into Databricks, the harder it is for rivals to pry them loose later. However, Kramer pointed out that the free edition only includes basic computing resources while placing limits on how many jobs or apps a user can run. “It doesn’t include enterprise features like advanced security or large-scale storage,” Kramer said. Databricks has not provided any information on the usage limitations of the free editions. In contrast, rivals such as Snowflake offer free trials that usually expire after a set time, often 30 days.
12.06.2025 11:28 — 👍 0    🔁 0    💬 0    📌 0
Preview
How to use frozen collections in C# Developers often grapple with the available options in their quest to use the most suitable data structure for their application. The various collections in C# offer different ways to store data objects and search, sort, insert, modify, delete, and iterate across those objects. For example, the .NET Base Class Library (BCL) provides support for read-only, immutable, and frozen collections. Each of these collection types has distinct use cases. Read-only collections provide read-only access to data in a mutable collection, i.e., a collection that can be altered by other means. Immutable collections are collections that preserve their structure, meaning they cannot be altered after creation. An immutable collection enables thread-safe modifications to the data by creating a new instance of the collection each time you change its data. Typical examples of immutable collections are `ImmutableStack`, `ImmutableList`, and `ImmutableHashSet`. Frozen collections, including the `FrozenSet` and `FrozenDictionary` classes, were introduced in .NET 8. These are immutable collections that have been optimized for fast look-ups. In addition, frozen collections provide a thread-safe way to access an immutable collection. In this article, we’ll examine how we can use frozen collections in C#. We’ll also look at the performance advantages of frozen collections by comparing the look-up speed of a `FrozenSet`to other collection types. ## Create a console application project in Visual Studio First off, let’s create a .NET Core console application project in Visual Studio. Assuming Visual Studio 2022 is installed in your system, follow the steps outlined below to create a new .NET Core console application project. 1. Launch the Visual Studio IDE. 2. Click on “Create new project.” 3. In the “Create new project” window, select “Console App” from the list of templates displayed. 4. Click Next. 5. In the “Configure your new project” window, specify the name and location for the new project. 6. Specify the Solution name for your project and select the check box to place the solution and the project files in the same directory. 7. Click Next. 8. In the “Additional information” window shown next, choose “.NET 9.0 (Standard Term Support)” as the framework version you would like to use. 9. Ensure that the check boxes for enabling container support, specifying container build type, and enabling native AOT publish are unchecked. We won’t be using any of these features in this example. 10. Click Create. We’ll use this .NET 9 Core console application project to work with frozen collections in the subsequent sections of this article. ## What are frozen collections? Why do we need them? Frozen collections refer to a specific type of collection that blends the benefits of immutability and fast read performance. The term immutable here implies that these collections cannot be altered after they are created, thereby ensuring thread safety. Frozen collections eliminate the need to synchronize code that uses these collections in concurrent applications, i.e., applications that handle multiple threads simultaneously. The `System.Collections.Frozen` namespace in .NET 8 introduces two new collection classes, `FrozenSet` and `FrozenDictionary`. “Frozen” here implies that the collections are immutable. You cannot change these collections once an instance of these classes has been created. These new collection classes enable you to perform faster look-ups and enumerations using methods such as `TryGetValue()` and `Contains()`. ## Key features of frozen collections in .NET Core These are the key features of frozen collections in .NET Core: * Immutability: Because frozen collections are immutable, you cannot alter them after they are created. As a result, your application’s data will remain thread-safe and consistent without requiring the use of synchronization techniques. * Performance optimization: Frozen collections allow only read access, which reduces their memory footprint or overhead during initialization while improving lookup times. Hence, these collections are a great choice when your application needs frequent read-only access to data. * Thread safety: Thanks to their immutable nature, frozen collections are thread-safe, allowing multiple threads to access the same frozen collection simultaneously without encountering race conditions or synchronization issues. * Simplicity: Frozen collections are easy to use. You can easily integrate frozen collections into your application because their APIs are the same as the APIs of traditional collections. ## Types of frozen collections in .NET Core Basically, there are two types of frozen collections in .NET Core: * `FrozenDictionary`:**** A `FrozenDictionary` represents a read-only dictionary that is optimized for fast searches. You can use this collection when the collection needs to be created once and read frequently. * `FrozenSet`:**** A `FrozenSet` represents a read-only immutable set optimized for fast searches and enumeration. Like a `FrozenDictionary`, you cannot alter this collection after creation. Because both `FrozenSet` and `FrozenDictionary` are read-only collections, you cannot add, change, or remove items in these collections. ## Create frozen collections in C# The following code snippet shows how you can create a `FrozenSet` from a `HashSet` instance, populate it with sample data, and then search for an item inside it. Recall that a `HashSet` is an unordered collection of unique elements that supports set operations (union, intersection, etc.) and uses a hash table for storage. var hashSet = new HashSet { "A", "B", "C", "D", "E" }; var frozenSet = hashSet.ToFrozenSet(); bool isFound = frozenSet.TryGetValue("A", out _); In the preceding code snippet, the `ToFrozenSet()` method is used to convert a `HashSet` instance to a `FrozenSet` instance. The method `TryGetValue()` will return `true` in this example because the data searched for is present in the collection. The following code shows how you can create a `FrozenDictionary`, store data in it, and search for a particular key in the collection. var dictionary = new Dictionary { { 1, "A" },{ 2, "B" },{ 3, "C" },{ 4, "D" },{ 5, "E" } }; var frozenDictionary = dictionary.ToFrozenDictionary(); bool isFound = dictionary.TryGetValue(7, out _); When the above code is executed, the `TryGetValue` method will return `false` because the key `7` is not available in the collection. ## Benchmarking performance of frozen collections in .NET Core Let us now benchmark the performance of a frozen collection, specifically a `FrozenSet`, against other collection types using the BenchmarkDotNet library. For comparison, we’ll use a `List`, a `HashSet`, and an `ImmutableHashSet`. Recall that a `List` is a mutable, strongly-typed, dynamically-sized, ordered collection of elements (even duplicates), and that a `HashSet` is a mutable, array-based collection of unique elements that is optimized for fast look-ups. Note that the time complexity for searching an item in a `HashSet` is O(1), compared to a time complexity of O(n) for a `List` (where n is the number of elements in the collection). Clearly, a `HashSet` is useful in cases where quick access is necessary. On the downside, a `HashSet` consumes more memory than a `List` and cannot include duplicate elements. You should use a `List` if you want to store an ordered collection of items (possibly duplicates) and where resource consumption is a constraint. An `ImmutableHashSet` is the immutable counterpart of a `HashSet`, i.e., an array-based collection of unique elements that cannot be changed once created. Note that, whereas a `HashSet` is a mutable, array-based hash bucket optimized for fast searches, an `ImmutableHashSet` is a persistent data structure that uses AVL trees for immutability. Because this introduces additional overhead, searches of an `ImmutableHashSet` are much slower than searches of a `HashSet`. ### Install BenchmarkDotNet To use BenchmarkDotNet, you must first install the BenchmarkDotNet package. You can do this either via the NuGet Package Manager in the Visual Studio IDE, or by executing the following command at the NuGet Package Manager Console: Install-Package BenchmarkDotNet ### Create a benchmark class In the console application project we created earlier, create a class named `CollectionPerformanceBenchmark` in a file with the same name and a .cs extension as shown below. [MemoryDiagnoser] public class CollectionPerformanceBenchmark { [GlobalSetup] public void SetupData() { } } In the preceding code snippet, the attribute `MemoryDiagnoser` has been attached to the `CollectionPerformanceBenchmark` class to include memory consumption metrics in our benchmark results. The `SetupData` method is where we will write the initialization code for our benchmark, i.e., the code to create our collections, populate them with dummy data, and so on. The `[GlobalSetup]` attribute is used to ensure that `SetupData` method is executed before any benchmark methods. ### Write the initialization code The following code snippet implements the `SetupData` method that initializes each of the collection instances and populates them with data. [GlobalSetup] public void SetupData() { list = Enumerable.Range(0, NumberOfItems).ToList(); hashSet = Enumerable.Range(0, NumberOfItems).ToHashSet(); immutableHashSet = Enumerable.Range(0, NumberOfItems).ToImmutableHashSet(); frozenSet = Enumerable.Range(0, NumberOfItems).ToFrozenSet(); } ### Write the benchmark code Next, we must write the necessary code for benchmarking. Each method that contains code for benchmarking should be decorated using the `[Benchmark]` attribute as shown below. [Benchmark(Baseline = true)] public void SearchList() { for (var i = 0; i In the preceding code snippet, the `SearchList` method has been decorated using the `[Benchmark]` attribute and has been set as the baseline against which the performance of the other benchmark methods will be compared. The complete source code of our `CollectionPerformanceBenchmark` benchmarking class is given below for reference. Note that it includes the necessary code for the other benchmark methods (`SearchFrozenSet`, `SearchHashSet`, and `SearchImmutableHashSet`), which are implemented in much the same way we implemented the `SearchList` method. [MemoryDiagnoser] public class CollectionPerformanceBenchmark { private const int NumberOfItems = 1000; private List list; private FrozenSet frozenSet; private HashSet hashSet; private ImmutableHashSet immutableHashSet; [GlobalSetup] public void SetupData() { list = Enumerable.Range(0, NumberOfItems).ToList(); hashSet = Enumerable.Range(0, NumberOfItems).ToHashSet(); immutableHashSet = Enumerable.Range(0, NumberOfItems).ToImmutableHashSet(); frozenSet = Enumerable.Range(0, NumberOfItems).ToFrozenSet(); } [Benchmark(Baseline = true)] public void SearchList() { for (var i = 0; i ## Faster searches in frozen collections When you run the benchmarks above, you’ll notice the distinct performance differences between searching data in a frozen collection (in this case a `FrozenSet`) compared to a normal collection such as a `List` as shown in Figure 1. Figure 1. Performance benchmark results for searching various collection types (`List`, `FrozenSet`, `HashSet`, and `ImmutableHashSet`). IDG As you can see in the benchmark results, searching a `FrozenSet` is not only much faster than searching a `List`, it is even faster than searching a `HashSet`. So, when you need fast look-ups in a mutable set, use a `HashSet`. When you need fast look-ups in an immutable set, use a `FrozenSet`. Keep in mind that, because a `FrozenSet` is immutable, it incurs a significantly higher overhead cost of creation compared to a `HashSet`. Performance and scalability have improved with every release of .NET Core. The introduction of frozen collections heralds a new approach to efficiently searching data, and future releases will include more such improvements.
12.06.2025 09:00 — 👍 0    🔁 0    💬 0    📌 0
Preview
Apple rolls out Swift, SwiftUI, and Xcode updates Apple at its Worldwide Developers Conference (WWDC) this week announced the latest advancements for the Swift language, SwiftUI framework, and Xcode IDE. Highlights include concurrency enhancements and improved C++ and Java interoperability for Swift, compilation caching for Xcode, and new design APIs in SwiftUI. With Swift 6.2, developers can incrementally adopt Swift in existing C++, C, and Objective-C apps to make code safer and more efficient, Apple said. The swift-java interoperability project now allows developers to incorporate Swift in Java code. Updates to concurrency make asynchronous and concurrent code easier to write correctly. Inline arrays enable developers to declare fixed-size arrays, which allows for compile-time optimizations. A new Span type provides an alternative to unsafe buffer pointers. Apple also introduced Containerization, an open-source project written in Swift for building and running Linux containers on macOS and Apple silicon. With Xcode 26, in addition to built-in support for ChatGPT, Xcode now allows developers to use generative AI powered by a large language model of their choice, either by using API keys from other providers or running local models on their Mac (Apple silicon required). Coding Tools now provides suggestions to help developers quickly write documentation, fix an issue, or make a code change, Apple said. Compilation caching, introduced as an opt-in feature, speeds up iterative build and test cycles for Swift and C-family languages. Compilation caching caches the results of compilations that were produced for a set of source files and, when it detects that the same set of source files are getting re-compiled, speeds up builds by providing prior compilation results directly from the cache. Xcode 26 also includes a preview of a new implementation for Swift package builds, based on shared code with Swift Package Manager. This should improve the consistency and stability of builds across the package manager and Xcode, Apple said. Finally, SwiftUI, Apple’s user interface toolkit, has been updated to support Apple’s new Liquid Glass, which Apple describes as a dynamic design material that combines the optical properties of glass with a sense of fluidity. SwiftUI also adds new APIs for immersive spaces in visionOS, new WebKit APIs for bringing web content into Swift apps, and 3D Swift Charts based on RealityKit, Apple’s 3D and augmented reality framework.
12.06.2025 02:00 — 👍 0    🔁 0    💬 0    📌 0
Preview
Databricks aims to optimize agent building for enterprises with Agent Bricks Databricks has released a beta version of a new agent building interface to help enterprises automate and optimize the agent building process. Agent Bricks is a new generative AI-driven interface combining technologies developed by MosaicML, which Databricks acquired in 2023, includng TAO, synthetic data generation API, and the Mosaic Agent platform. However, it is not a rebranded Mosaic Agent Platform, said Robert Kramer, principal analyst at Moor Insights and Strategy, but rather a higher-level, automated abstraction that streamlines agent development for enterprises. Agent Bricks is intended for use mainly by data professionals and developers, and can be accessed via the “Agent” button in the lakehouse software provider’s Data Intelligence platform. ## Using Agent Bricks Users begin by selecting from a variety of task types they want to execute via agents, such as extracting information from documents, creating a conversational agent, or building a multi-agent workflow system. Next, they provide a high-level description of the type of agent or agents they are trying to build and attach different knowledge sources for the required task. Agent Bricks then automatically creates a custom evaluation benchmark for the specified task, said Databricks’ CTO of neural networks, Hanlin Tang, said, giving the example of an agent for customer support. “We will build a custom LLM judge that’ll measure whether the customer will churn during that support call, or the customer is happy or unhappy. Once we have the benchmark for the task, Agent Bricks then looks at how to optimize the agent itself,” Tang added. During the optimization phase, Agent Bricks uses techniques including synthetic data generation, prompt engineering, model selection, and fine tuning to deliver an agent that is optimized for quality and cost that enterprises can deploy. ## Optimization Databricks is pitching Agent Bricks as a way to take the complexity out of the process of building agents, as most enterprises don’t have either the time or the talent to go through an iterative process of building and matching an agent to a use case. “Agent Bricks is notable for automating the agent creation lifecycle from evaluation to optimization, an area where most competitors focus on hosting or orchestrating models rather than lifecycle automation,” said Kramer. “Snowflake Cortex, for example, supports hosted AI agents but lacks synthetic data and auto-optimization features. AWS Bedrock and Azure OpenAI provide model hosting and tooling but do not offer integrated evaluation and cost tuning at this level,” he said. Teradata doesn’t offer direct agent-building capabilities either, while Salesforce’s Agentforce platform, though offering evaluation tools for agents, doesn’t automate the process and leaves a lot of engineering to data professionals and developers. At Constellation Research, Principal Analyst Michael Ni pointed out that though Agent Bricks automates and optimizes the agent building process, it will not replace data engineers, but rather help them save them time in building agentic applications. “Data engineers still oversee integration and deployment, but they’re no longer blocked by repetitive, low-value scaffolding work,” Ni said, adding he doesn’t see Agent Bricks as a point-and-click tool for non-technical users. ## Support for MCP As part of the new interface, Databricks is adding some templatized agents that enterprises can use out-of-the-box: Information Extraction Agents for getting structured data from unstructured data, Knowledge Assistant Agent for supporting conversational agents, Multi-Agent Supervisor for building multi-agent systems, and Custom LLM Agent for custom tasks. These agents are use-case templates or archetypes designed for common enterprise scenarios and act as starting points that can be customized based on organizational data and performance requirements, rather than rigid building blocks or mandatory frameworks. Agent Bricks also supports Anthropic’s Model Context Protocol (MCP), an increasingly popular framework for connecting agents across disparate technology stacks or systems. The Multi-Agent supervisor inside Agent Bricks can read and accept an MCP server as an agent, making agents on other systems accessible, said Databricks’ Tang, adding that an agent produced on Agent Bricks can also be exposed as an endpoint in order to connect to other agent systems. Databricks is also working on support for Google’s A2A protocol, Tang said, cautioning that development is in “very early days.” ## A different approach to agent lifecycle management Agent Bricks takes a different approach to agent lifecycle management when compared to similar offerings from other vendors. While most vendors have built agent lifecycle management tools inside their agent builders, Databricks is leveraging Unity Catalog and MLflow 3.0 for managing agents built on Agent Bricks — meaning ongoing AgentOps tasks, such as, monitoring, evaluation, deployment, and rollback, are handled by MLflow 3.0 and Unity Catalog. Snowflake, on the other hand, integrates agent lifecycle management within Cortex, while AWS and Azure embed monitoring directly into their agent environments. Kramer said that enterprises with smaller teams may think twice before adopting Agent Bricks as Databricks’ approach requires users to work across multiple services. “This separation may slow adoption for teams expecting a unified toolset, especially those new to Databricks’ platform,” he said. But, said Bradley Shimmin, the lead of the data and analytics practice at The Futurum Group, some enterprises may align with Databricks’ approach towards agent lifecycle management: an agent, like a data table or machine learning model, is an asset and should be governed by the same central catalog.
11.06.2025 13:57 — 👍 0    🔁 0    💬 0    📌 0
Preview
Building an analytics architecture for unstructured data and multimodal AI Data scientists today face a perfect storm: an explosion of inconsistent, unstructured, multimodal data scattered across silos – and mounting pressure to turn it into accessible, AI-ready insights. The challenge isn’t just dealing with diverse data types, but also the need for scalable, automated processes to prepare, analyze, and use this data effectively. Many organizations fall into predictable traps when updating their data pipelines for AI. The most common: treating data preparation as a series of one-off tasks rather than designing for repeatability and scale. For example, hardcoding product categories in advance can make a system brittle and hard to adapt to new products. A more flexible approach is to infer categories dynamically from unstructured content, like product descriptions, using a foundation model, allowing the system to evolve with the business. Forward-looking teams are rethinking pipelines with adaptability in mind. Market leaders use AI-powered analytics to extract insights from this diverse data, transforming customer experiences and operational efficiency. The shift demands a tailored, priority-based approach to data processing and analytics that embraces the diverse nature of modern data, while optimizing for different computational needs across the AI/ML lifecycle. ### **Tooling for unstructured and multimodal data projects** Different data types benefit from specialized approaches. For example: * Text analysis leverages contextual understanding and embedding capabilities to extract meaning; * Video pipelines processing employs computer vision models for classification; * Time-series data uses forecasting engines. Platforms must match workloads to optimal processing methods while maintaining data access, governance, and resource efficiency. Consider text analytics on customer support data. Initial processing might use lightweight natural language processing (NLP) for classification. Deeper analysis could employ large language models (LLMs) for sentiment detection, while production deployment might require specialized vector databases for semantic search. Each stage requires different computational resources, yet all must work together seamlessly in production. **_Representative AI Workloads_**** __** **AI Workload Type**| **Storage**| **Network**| **Compute**| **Scaling Characteristics** ---|---|---|---|--- **Real-time NLP classification**| In-memory data stores; Vector databases for embedding storage| Low-latency (<100ms); Moderate bandwidth| GPU-accelerated inference; High-memory CPU for preprocessing and feature extraction| Horizontal scaling for concurrent requests; Memory scales with vocabulary **Textual data analysis**| Document-oriented databases and vector databases for embedding; Columnar storage for metadata| Batch-oriented, high-throughput networking for large-scale data ingestion and analysis| GPU or TPU clusters for model training; Distributed CPU for ETL and data preparation| Storage grows linearly with dataset size; Compute costs scale with token count and model complexity **Media analysis**| Scalable object storage for raw media; Caching layer for frequently- accessed datasets| Very high bandwidth; Streaming support| Large GPU clusters for training; Inference-optimized GPUs| Storage costs increase rapidly with media data; Batch processing helps manage compute scaling **Temporal forecasting, anomaly detection**| Time-partitioned tables; Hot/cold storage tiering for efficient data management| Predictable bandwidth; Time-window batching| Often CPU-bound; Memory scales with time window size| Partitioning by time ranges enables efficient scaling; Compute requirements grow with prediction window. _Note: Comparative resource requirements for representative AI workloads across storage, network, compute, and scaling._ _Source: Google Cloud_ The different data types and processing stages call for different technology choices. Each workload needs its own infrastructure, scaling methods, and optimization strategies. This variety shapes today’s best practices for handling AI-bound data: * **Use in-platform AI assistants** to generate SQL, explain code, and understand data structures. This can dramatically speed up initial prep and exploration phases. Combine this with automated metadata and profiling tools to reveal data quality issues before manual intervention is required. * **Execute all data cleaning, transformation, and feature engineering directly within your core data platform** using its query language. This eliminates data movement bottlenecks and the overhead of juggling separate preparation tools. * **Automate data preparation workflows** with version-controlled pipelines inside your data environment, to ensure reproducibility and free you to focus on modeling over scripting. * **Take advantage of serverless, auto-scaling compute platforms** so your queries, transformations, and feature engineering tasks run efficiently for any data volume. Serverless platforms allow you to focus on transformation logic rather than infrastructure. These best practices apply to structured and unstructured data alike. Contemporary platforms can expose images, audio, and text through structured interfaces, allowing summarization and other analytics via familiar query languages. Some can transform AI outputs into structured tables that can be queried and joined like traditional datasets. By treating unstructured sources as first-class analytics citizens, you can integrate them more cleanly into workflows without building external pipelines. ### **Today’s architecture for tomorrow’s challenges** Effective modern data architecture operates within a central data platform that supports diverse processing frameworks, eliminating the inefficiencies of moving data between tools. Increasingly, this includes direct support for unstructured data with familiar languages like SQL. This allows them to treat outputs like customer support transcripts as query-able tables that can be joined with structured sources like sales records – without building separate pipelines. As foundational AI models become more accessible, data platforms are embedding summarization, classification, and transcription directly into workflows, enabling teams to extract insights from unstructured data without leaving the analytics environment. Some, like Google Cloud BigQuery, have introduced rich SQL primitives, such as AI.GENERATE_TABLE(), to convert outputs from multimodal datasets into structured, queryable tables without requiring bespoke pipelines. AI and multimodal data are reshaping analytics. Success requires architectural flexibility: matching tools to tasks in a unified foundation. As AI becomes more embedded in operations, that flexibility becomes critical to maintaining velocity and efficiency. Learn more about these capabilities and start working with multimodal data in BigQuery.
11.06.2025 13:10 — 👍 0    🔁 0    💬 0    📌 0
Preview
Databricks targets AI bottlenecks with Lakeflow Designer Databricks showcased a new no-code data management tool, powered by a generative AI assistant, at its ongoing Data + AI summit, which is designed to help enterprises eliminate data engineering bottlenecks slowing down AI projects. Called Lakeflow Designer, the tool is designed to empower data analysts build no-code ETL (extract, transform, load) pipelines — a task, typically, left to data engineers who are always busy, thus creating a barrier to accelerate AI projects or uses cases, said Bilal Aslam, senior director of product management at Databricks. Lakeflow Designer is currently in preview. While enterprises employ low-code or no-code tools for data analysts to curtail the load on data engineers, these tools lack governance and scalability, Aslam said, adding that Lakeflow Designer is designed to alleviate these challenges. “Lakeflow Designer addresses a key data management problem: data engineering bottlenecks are killing AI momentum with disconnected tools across data ingestion, preparation, cleansing, and orchestration,” said Michael Ni, principal analyst at Constellation Research. “Lakeflow Designer blows the doors open by putting the power of a no-code tool in analysts’ hands, while keeping it enterprise safe.” Ni called Lakeflow Designer the “Canva of ETL” — instant, visual, AI-assisted development of data pipelines — yet under the hood, it’s Spark SQL at machine scale, secured by Unity Catalog. Advisory firm ISG’s director of software research, Matt Aslett, said the new tool is expected to reduce the burden on data engineering teams but pointed out that data analysts are highly likely to still be working with data engineering teams for use cases that have more complex integration and transformation requirements that require additional expertise. Lakeflow Designer makes collaboration between data analysts and engineers in an enterprise easier as it allows sharing of metadata and CI/CD pipelines, meaning these can be inspected, edited by engineers if required, Ni said. The tool also supports Git and DevOps flows, providing lineage, access control, and auditability, Ni added. Like Aslett, the analyst pointed out that the new tool is likely to aid enterprises in less complex use cases, such as regional margin tracking, compliance, metric aggregation, retention window monitoring, and cohorting, although it supports custom development. Lakeflow Designer is part of Lakeflow, which will now be generally available. Lakeflow has three modules — Lakeflow Connect, Lakeflow Declarative Pipelines, and Lakeflow Jobs. Designer is integrated within Declarative Pipelines. ## United in purpose, divided in approach Lakeflow Designer, despite being very similar to rival Snowflake’s Openflow, differs in its approach, analysts say. “Lakeflow and OpenFlow reflect two philosophies: Databricks integrates data engineering into a Spark-native, open orchestration fabric, while Snowflake’s OpenFlow offers declarative workflow control with deep Snowflake-native semantics. One favors flexibility and openness; the other favors consolidation and simplicity,” Ni said. Both the offerings also differ in maturity, ISG’s Aslett said. While Snowflake’s OpenFlow is relatively new, Lakeflow has matured in functionality over the years, with Designer being its latest tool. “The Connect capabilities were acquired along with Arcion in 2023. Declarative pipelines functionality is the evolution of DLT (Delta Live Tables), and Jobs is the evolution of Databricks Workflows,” Aslett added. Separately, Databricks also released another pro-code integrated development environment (IDE) for data engineers, which unifies the data engineer’s full pipeline lifecycle — code, DAGs, sample data, and debugging — all in one integrated workspace. Releasing Lakeflow Designer and the new IDE together is a strategic play, according to Ni, as the lakehouse provider is targeting both ends of the pipeline maturity curve — low-code to move fast and the full IDE to scale and maintain pipelines.
11.06.2025 13:00 — 👍 0    🔁 0    💬 0    📌 0
Preview
Managing software projects is a double-edged sword In 2010, I got fired. I deserved it. I wasn’t wrong, but I deserved it. And I think there is an interesting lesson in that dichotomy. I was managing a team of developers at a once-great Silicon Valley firm that had fallen from its peak. The development team was very good—elite, even. Our product was a once-popular but fading software development tool. Our management team—we called it “the Core Team”—was a great bunch. I enjoyed the job. The product was monolithic—a single, large install that had to be built and deployed all at once. We shipped about once a year, and all development was geared around building new features and fixing bugs that would all culminate in that big, annual release. Being a development tool, it had many complex components, including a compiler, a run-time library, a visual framework, and an IDE. Getting everything pulled together and built was no mean feat. A big part of keeping the product viable in the marketplace was doing platform shifts. The first one was going from the Win16 platform to the Win32 platform. The product made an ill-fated foray into Linux, as well as smaller shifts to newer Windows versions and Win64. The product was large and complex, and these platform shifts were not easily done. The development and QA teams were very experienced and they knew what they were doing. They knew well what it took to ship a new version of the product, and they knew the extra effort it took to do a platform shift. ## Seeds of misunderstanding One of the ways that the company had been humbled was that a smaller database tools company had bought it and brought in a new team of senior leadership. The process went pretty normally, with our middle management team cautiously optimistic as we adjusted to a new set of executives. We did our best to integrate and be integrated into the new order of things. While SQL/database development tools and more general software development tools have much in common, and seem very similar on the surface, our product was a level deeper and more complex than our new parent company’s product. This incongruity proved to be challenging to integrate. While a SQL IDE and a programming language IDE seem the same on the surface, our product’s underlying frameworks, libraries, and compilers were orders of magnitude more complex than a SQL parser and editor. This difference was a challenge for the new leadership to understand. So, when the decision was made to take our tool cross-platform to both Linux and Mac OS at the same time, the new executive team appeared not to understand the challenges and difficulties of doing these platform shifts. We on the Core Team looked at what it would take to provide support for those two platforms, and arrived at a general estimate of 18 months for each, given the current staffing levels. We recommended plans that could shorten that cycle by front-loading the projects and hiring more staff, doing our best to avoid Brooks’s law in the process (“Adding manpower to a late software project makes it later”). And here’s where things started getting a bit dicey. Upper management was shocked at the notion that it would take three years to migrate to the two new platforms. They seemed to take the attitude that the team was “sandbagging” and “was exaggerating because they didn’t want to do it.” So they set a deadline of six months to do both platforms. ## Temperatures rising Doing two platform shifts in six months was beyond challenging—it was absurd. We couldn’t have hacked together a half-baked version for even one platform in that time. It was flat-out impossible. Let’s just say I was quite unhappy with this request. It was completely unreasonable. My team of developers was being asked to work evenings and weekends on a task that was guaranteed to fail. The subtle implication that we were being rebellious and dishonest was difficult to swallow. So I set about making my position clear. I tried to stay level-headed, but I’m sure that my irritation showed through. I fought hard to protect my team from a pointless death march—my time in the Navy had taught me that taking care of the team was my top job. My protestations were met with little sympathy. My boss, who like me came from the software development tool company, certainly knew that the request was unreasonable, but he told me that while it was a challenge, we just needed to “try.” This, of course, was the seed of my demise. I knew it was an impossible task, and that “trying” would fail. How do you ask your team to embark on a task that you know will fail miserably and that they know will fail miserably? Well, I answered that question very poorly. ## What I did and what I should have done What I did was exactly wrong. In the name of defending my team and sticking up for my people, I failed to at least pretend like I was on board with the project. I didn’t even remotely try to be a team player. I told the developers that I thought the plan was nuts and that they shouldn’t even try. I kept telling upper management that that plan was ridiculous and that the team could never do it. What should I have done? This is the hard part. What I _should_ have done was to make the best of a very difficult situation. I should have found a middle path. I should have found a way that supported management even though the plan was not doable and that supported my team even though they were being put in an impossible position. Would that have been challenging? Yes. Should I have at least tried? Again, yes. In the end, my immature approach got me fired. Was I right that the project wouldn’t be completed in the ridiculous timeline? Sure. Was I right to press the issue so hard that I lost my job? No, I was not. The lesson? Sometimes being a manager is hard—even impossible. Sometimes you have to give up being right and put the needs of the entire organization over yourself. Sometimes you have to balance protecting your people with being a loyal member of the management team. Sometimes you have to manage up as well as you manage down. Being right isn’t enough—being effective matters more. I learned that the hard way.
11.06.2025 09:00 — 👍 0    🔁 0    💬 0    📌 0
Preview
Mistral AI unveils Magistral reasoning model AI startup Mistral AI has announced Magistral, a reasoning model geared to domain-specific, transparent, and multilingual reasoning. Announced June 10, Magistral is designed for research, strategic planning, operational optimization, and data-driven decision making, whether executing risk assessment and modeling with multiple factors, or calculating optimal delivery windows under constraints, Magistral AI said. Combining expertise across professional domains, transparent reasoning that can be followed and verified, and deep multilingual flexibility, Magistral is suited for enterprise use cases ranging from structured calculations and programmatic logic to decision trees and rule-based systems, according to the company. Magistral is fine-tuned for multi-step logic, improving interpretability, and providing a traceable thought process in the user’s language, unlike general-purpose models, Mistral AI said. The company said the model excels in maintaining high-fidelity reasoning across numerous languages, and is particularly well-suited to reason in languages including English, French, Spanish, German, Italian, Arabic, Russian, and Simplified Chinese. It also enhances coding and development use cases, significantly improving project planning, back-end architecture, front-end design, and data engineering compared to non-reasoning models, according to the company. Mistral is releasing Magistral in two variants. Magistral Small is a 24B parameter open-source version, downloadable from Hugging Face. Magistral Medium is a more powerful enterprise version, being previewed at Le Chat or via API on La Plateforme. Magistral Medium also is available on Amazon SageMaker. Alongside the Magistral release, Mistral has published a research paper covering its evaluations of Magistral, training infrastructure, reinforcement learning algorithm, and thoughts on training reasoning models.
10.06.2025 22:10 — 👍 0    🔁 0    💬 0    📌 0
Preview
Cisco Live: AI will bring developer workflow closer to the network At Cisco Live 2025 in San Diego, Cisco CEO Chuck Robbins compared AI’s effect on networking to what the Internet felt like in the 1990s. Back then, the arrival of TCP/IP shattered the boundaries of closed networks, connecting individual computers to a worldwide web of information. AI is reshaping networking in ways that demand a new degree of programmability, observability, and optimization, Robbins said. And if history is any guide, what starts as an infrastructure concern for network and platform teams will eventually trickle down to developers. ## From static routers to programmable platforms The rise of cloud-native infrastructure made containers and APIs the lingua franca of compute. Now, networking is undergoing a similar transformation. Thomas Graf, CTO of Cisco’s Isovalent and creator of Cilium, an open-source, cloud-native, eBPF-based networking, observability, and security solution, sees legacy routers and switches becoming programmable platforms in their own right. “With the launch of the new DPU-enabled Cisco top-of-rack switch… we now have switches that not only perform traditional functions but also bring firewalling and load balancing directly into the switch,” Graf said. “This means replacing legacy firewall boxes with functionality baked into the networking fabric itself.” Graf describes DPU-enhanced switches as programmable systems, allowing software-defined network services to be delivered from the switch itself rather than in VMs or sidecar containers. Combined with runtime protection tools like Tetragon and other kernel observability frameworks enabled by eBPF, this paves the way for classic network operations—firewalls, segmentation, even observability—to be more flexibly managed in code. It’s a shift from “ticket ops” to GitOps for networking, Graf said. ## AI agents tackle network debugging At Cisco Live, Cisco introduced its Foundation AI Security Model, an open-source, purpose-built model for security trained on a curated set of five million security-specific tokens. The company also unveiled the Deep Network Model, optimized for network operations with an agentic UI experience called AI Canvas. David Zacks, director of innovation, advanced technologies and AI and machine learning at Cisco, introduced the model. “The AI system isn’t smarter than the network engineer—it just has access to more data,” Zacks said. The ability to collect telemetry at scale, process it using machine reasoning, and surface actionable insights is rapidly becoming table stakes for operating reliable networks, he added. As these feedback loops mature, it’s only a matter of time before developers start leveraging the same frameworks in pre-production environments, modeling how inference pipelines behave under load and automatically flagging performance cliffs or bottlenecks. ## A new architecture to meet the needs of AI A repeated theme at Cisco Live has been that the full-stack redesign necessary to support AI is collapsing the traditional boundaries between applications and infrastructure. “Two things in parallel—the models and the silicon—are becoming more bespoke,” said Cisco’s Jeetu Patel. “Models are getting smaller, silicon more programmable, and the time to market is shrinking. The model becomes part of the application itself. Iterating the app is iterating the model.” That compression between application logic and inference hardware is triggering an architectural rethink. For AI workloads to perform, developers need visibility into how model design, network bandwidth, and inference placement intersect. Bandwidth-heavy queries from large language models are especially sensitive to latency and congestion—issues that are invisible until they hit the network. At Cisco Live, sessions have emphasized how AI workflows are now being mapped directly to the network topology itself. Distributing load through pipeline parallelism, optimizing inference placement based on network path characteristics, and pre-caching model shards near compute boundaries are just a few of the strategies being discussed. This is infrastructure thinking at the developer level, because performance is no longer just about the GPU, but about where, how, and how fast the data flows. ## A convergence of application logic and network control So then, are we approaching a moment where developers will get direct programmability over the network? “Network programmability has been a goal for years within the networking community,” said Jim Frey, principal analyst for networking at Enterprise Strategy Group. “There is even a term of art for it, NetDevOps, as well as a growing community, the Network Automation Forum, that is focused on making it a reality.” “But achieving that goal has been fiendishly difficult due to a lack of standard interfaces and closed, proprietary equipment architectures,” Frey said. “The arrival of AI is changing the rules of the game. Network infrastructure teams, and the equipment providers that supply them, are having to fall back and regroup for this new world, and find a path to programmability that aligns with rest of infrastructure domains.” Given this new reality, the idea that a future control plane will give AI developers declarative access to bandwidth, latency profiles, or even Layer 7 behavior is not far-fetched, according to Cisco. “We’re building for AI not as a workload, but as the platform,” said Patrick LeMaistre, technical solutions architect at Cisco. “That changes everything.”
10.06.2025 20:54 — 👍 0    🔁 0    💬 0    📌 0
Preview
Digital AI introduces Quick Protect Agent, a no-code way to protect mobile apps Threat actors are increasingly targeting mobile apps, adding to the security risks for enterprises and their customers. To help address this burgeoning issue, enterprise software delivery platform vendor Digital.ai Tuesday is expanding its Application Security suite with the addition of Quick Protect Agent to give developers a quick, no-code way to protect their enterprise apps from tampering. While flagship apps such as client-facing mobile banking receive a lot of attention from security teams, secondary and tertiary apps such as trading apps, or apps for employees only that aren’t in public app stores, may not, noted Digital.ai CEO Derek Holt. Security teams just don’t have the resources to apply the same rigor to them. The Quick Protect Agent is designed to fill that gap. In the 2025 version of Digital.ai’s Annual Application Security Threat Report, Holt said, “We saw that over 80% of the apps in the respective app stores are under attack, and we saw about a 20% increase year over year in the number of attacks.” When investigators dug deeper, they found that the industry has done a “pretty good job” of putting more guards and protections in place in some industry verticals and with primary apps. “However, the threat actors are now going after secondary and tertiary apps and are starting to expand into industry verticals that maybe were previously not as much of a focus area,” he said. That discovery led to the development of the Quick Protect Agent, with a simple interface that allows developers to drag and drop their binaries into a GUI and select the level of security required and any or all of the offered protections, including all four OWASP MASVS (Mobile Application Security Verification Standard) Resilience categories. Once the protections are approved, the tool provides a command line interface version of the configuration to include in automated pipelines for future builds. While the full Application Security Suite gives security teams the ability to fine-tune security for flagship apps, balancing security protections and performance, Holt said, they frequently don’t have the resources to give all apps the same attention. Quick Protect Agent asks a series of questions about general areas of concern and the required balance between performance and security, and the agent then generates the security profile for the app. In both cases, he said, detailed logs record every decision. “This is an interesting new set of capabilities and largely aligns with what we are seeing in the devops space,” said Jason Andersen, principal analyst at Moor Insights & Strategy. “Overall, Digital.ai’s assertion that we are witnessing a significant increase in hacking activity is accurate. Companies like JFrog, who cover different aspects of the toolchain, are also seeing similar increases and it’s largely being chalked up to increased use of automation and AI technology by hackers. So, the need is certainly there, especially in mobile applications which tend to be much more frequently updated than typical enterprise web apps. That’s a crucial distinction for a set of applications that are frankly higher visibility due to customer and partner contact.” Andersen noted that the use of agents in the development workflow accomplishes two things. First, it helps developers not well acquainted with application security to protect their apps. “I’d expect this to lead to better coverage and more frequent application of security processes,” he said. In addition, he pointed out, the solution makes a lot of sense as the use and complexity of agents increases. “New agent capabilities and standards, such as those seen in tools like GitHub Copilot, are pointing to a new future in the devops toolchain,” he said. “Consider agents like these engaging in some degree of cross-agent teaming, resulting in a more real-time and autonomous application security process.” However, said David Shipley, CEO of Beauceron Security, “Obscure code helps, but it doesn’t close vulnerabilities: it makes them harder to find by, for example, old-fashioned trial and error.” This kind of intervention, he said, “is like having the forward collision alert come on to stop an accident” — it’s a good thing, but it would be better if we understood the reason so that we fixed the underlying cause, not just the symptom.
10.06.2025 17:59 — 👍 0    🔁 0    💬 0    📌 0
Preview
Mastering AI risk: An end-to-end strategy for the modern enterprise Organizations find themselves navigating an environment where artificial intelligence can be a phenomenal growth engine, while simultaneously introducing unprecedented risks. This leaves executive leadership teams grappling with two critical questions: First, where should an AI cyber risk process begin and end for organizations creating and consuming AI? Second, what governance, training, and security processes should be implemented to protect people, data, and assets against vulnerabilities exposed by human error, AI system bias, and bad actors? The answers lie in adopting a comprehensive life cycle approach to AI risk management—one that equips**** the C-suite, IT, AI development teams, and security leaders with the tools to navigate an ever-evolving threat landscape. ## Understanding the faces of AI cyber risk ### Trustworthy AI development Organizations developing AI models or AI applications—i.e., whether creating proprietary machine learning models or integrating AI features into existing products—must approach the process with a security-first mindset. If cyber risks and broader security risks are not properly considered at the onset, an organization is needlessly exposed to several dangers: * **Lack of security-by-design** : Models developed without formal oversight or security protocols are more susceptible to data manipulation and adversarial inputs. * **Regulatory gaps** : With emerging guidelines like the EU AI Act, the NIST AI Risk Management Framework, and ISO 42001, failing to comply invites legal scrutiny and reputational damage. * **Biased or corrupted data** : Poor data quality can yield unreliable outputs, while malicious actors can intentionally feed incorrect data to skew results. ### Responsible AI usage Organizations not actively developing AI are still consumers of the technology—often at scale and without even realizing it. Numerous software-as-a-service (SaaS) platforms incorporate AI capabilities to process sensitive data. Employees might also experiment with generative AI tools, inputting confidential or regulated information that leaves organizational boundaries. When AI usage is unregulated or poorly understood, organizations face several risks that can lead to serious security gaps, compliance issues, and liability concerns, including: * **Shadow AI tools** : Individuals or departments may purchase, trial, and use AI-enabled apps under the radar, bypassing IT policies and creating security blind spots. * **Policy gaps** : Many businesses lack a dedicated acceptable use policy (AUP) that governs how employees interact with AI tools, potentially exposing them to data leakage, privacy, and regulatory issues. * **Regional laws and regulations** : Many jurisdictions are developing their own specific AI-related rules, like New York City’s Bias Act or Colorado’s AI governance guidelines. Misuse in hiring, financial decisions, or other sensitive areas can trigger liability. ### Defending against malicious AI usage As much as AI can transform legitimate business practices, it also amplifies the capabilities of cyber criminals that must be defended against. Key risks organizations face from bad actors include: * **Hyper-personalized attacks** : AI models can analyze massive data sets on targets, customizing emails or phone calls to maximize credibility. * **Increasingly sophisticated deepfakes:** Video and voice deepfakes have become so convincing that employees with access to corporate financial accounts and sensitive data have been tricked into paying millions to fraudsters. * **Executive and board awareness** : Senior leaders are prime targets for whaling attempts (spear-phishing cyber attacks that target high-level executives or individuals with significant authority) that leverage advanced forgery techniques. ## A life-cycle approach to managing AI risk Organizations gain a strategic advantage with a life-cycle approach to AI cyber risk that acknowledges AI technologies evolve rapidly, as do the threats and regulations associated with them. A true life-cycle approach combines strategic governance, advanced tools, workforce engagement, and iterative improvement. This model is not linear; it forms a loop that continuously adapts to evolving threats and changes in AI capabilities. Here is how each stage contributes. ### Risk assessment and governance * **Mapping AI risk** : Conduct an AI usage inventory to identify and categorize existing tools and data flows. This comprehensive mapping goes beyond mere code scanning; it evaluates how in-house and third-party AI tools reshape your security posture, impacting organizational processes, data flows, and regulatory contexts. * **Formal frameworks implementation** : To demonstrate due diligence and streamline audits, align with recognized standards like the EU AI Act, the NIST AI Risk Management Framework, and ISO 42001. In tandem, develop and enforce an explicit acceptable use policy (AUP) that outlines proper data handling procedures. * **Executive and board engagement** : Engage key leaders, including the CFO, general counsel, and board, to ensure they comprehend the financial, legal, and governance implications of AI. This proactive involvement secures the necessary funding and oversight to manage AI risks effectively. ### Technology and tools * **Advanced detection and response** : AI-enabled defenses, including advanced threat detection and continuous behavioral analytics, are critical in today’s environment. By parsing massive data sets at scale, these tools monitor activity in real time for subtle anomalies—such as unusual traffic patterns or improbable access requests—that could signal an AI-enabled attack. * **Zero trust** : Zero trust architecture continuously verifies the identity of every user and device at multiple checkpoints, adopting least-privilege principles and closely monitoring network interactions. This granular control limits lateral movement, making it far more difficult for intruders to access additional systems even if they breach one entry point. * **Scalable defense mechanisms** : Build flexible systems capable of rapid updates to counter new AI-driven threats. By proactively adapting and fine-tuning defenses, organizations can stay ahead of emerging cyber risks. ### Training and awareness * **Workforce education** : Ransomware, deepfakes, and social engineering threats are often successful because employees are not primed to question unexpected messages or requests. To bolster defense readiness, offer targeted training, including simulated phishing exercises. * **Executive and board involvement** : Senior leaders must understand how AI can amplify the stakes of a data breach. CFOs, CISOs, and CROs should collaborate to evaluate AI’s unique financial, operational, legal, and reputational risks. * **Culture of vigilance** : Encourage employees to report suspicious activity without fear of reprisal and foster an environment where security is everyone’s responsibility. ### Response and recovery * **AI-powered attack simulations** : Traditional tabletop exercises take on new urgency in an era where threats materialize faster than human responders can keep pace. Scenario planning should incorporate potential deepfake calls to the CFO, AI-based ransomware, or large-scale data theft. * **Continuous improvement** : After any incident, collect lessons learned. Were detection times reasonable? Did staff follow the incident response plan correctly? Update governance frameworks, technology stacks, and processes accordingly, ensuring that each incident drives smarter risk management. ### Ongoing evaluation * **Regulatory and threat monitoring** : Track legal updates and new attack vectors. AI evolves quickly, so remaining static is not an option. * **Metrics and continuous feedback** : Measure incident response times, security control effectiveness, and training outcomes. Use this data to refine policies and reallocate resources as needed. * **Adaptation and growth:** To keep pace with the changing AI landscape, evolve your technology investments, training protocols, and governance structures. A proactive, integrated approach not only safeguards your systems but also drives continuous improvement throughout the AI life cycle. ### Key takeaways **Stay proactive against malicious AI:** The same AI-driven automation that boosts productivity can supercharge criminals’ phishing, malware creation, and reconnaissance. Protecting financial assets and company reputation hinges on advanced security strategies. **Fortify training and governance:** Human error often opens the door to AI-powered attacks. Training that resonates with employees at all levels—coupled with strong leadership commitment—helps seal potential entry points. **Balance innovation with accountability:** Formal frameworks, from NIST to ISO, encourage responsible AI development and deployment. Adhering to these principles demonstrates that an organization is serious about safeguarding stakeholders. **Foster cross-functional collaboration:** CISOs, CTOs, CFOs, and CROs each bring a unique perspective to AI risk. Collectively, they can create a tapestry of policies, controls, and cultural awareness that underpins a robust cybersecurity posture. As AI development intensifies—propelled by fierce market competition and the promise of transformative insights—leaders must move beyond questioning _whether_ to adopt AI and focus instead on _how_ to do so responsibly. Although AI-driven threats are becoming more complex, a life-cycle approach enables organizations to maintain their competitive edge while safeguarding trust and meeting compliance obligations. _John Verry is the managing director of CBIZ Pivot Point Security, CBIZ’s cybersecurity team, in the National Risk and Advisory Services Division._ — **_Generative AI Insights_**** _provides a venue for technology leaders—including vendors and other outside contributors—to explore and discuss the challenges and opportunities of generative artificial intelligence. The selection is wide-ranging, from technology deep dives to case studies to expert opinion, but also subjective, based on our judgment of which topics and treatments will best serve InfoWorld’s technically sophisticated audience. InfoWorld does not accept marketing collateral for publication and reserves the right to edit all contributed content. Contact_**** _doug_dineley@foundryco.com_**** _._**
10.06.2025 09:00 — 👍 0    🔁 0    💬 0    📌 0
Preview
SQL slips in language popularity index Structured Query Language, the standard means of manipulating and querying data in relational databases since the 1980s, has dropped out of the Tiobe index top 10 in recent months and now ranks 12th, its lowest-ever position. The Tiobe index for June 2025 was published June 8. “SQL will remain the backbone and lingua franca of databases for decades to come,” said Paul Jansen, CEO of software quality services vendor Tiobe, in the June release of the index. “However, in the booming field of AI, where data is usually unstructured, NoSQL databases are often a better fit.” Jansen likened the popularity of NoSQL to the rise of dynamically typed languages such as Python if compared to well-defined, statically typed languages such as C++ and Java. While SQL was a serious top 10 player when the index began in 2001, it was taken from the list after someone noted in 2004 that SQL was not a programming language. In 2018, it was pointed out that SQL is Turing-complete, which makes it a programming language. So SQL was re-added to the index. The monthly Tiobe Programming Community Index rates the popularity of programming languages based on the number of engineers worldwide, courses, and third-party vendors pertinent to a language. The ratings are calculated using websites such as Google, Bing, Amazon, Wikipedia, and more than 20 others. The Tiobe index top 10 for June 2025: 1. Python, with a rating of 25.87% 2. C++, 10.68% 3. C, 9.47% 4. Java, 8.84% 5. C#, 4.69% 6. JavaScript, 3.21% 7. Go, 2.28% 8. Visual Basic, 2.2% 9. Delphi/Object Pascal, 2.15% 10. Fortran, 1.86% The alternative Pypl Popularity of Programming Language index assesses language popularity based on how often language tutorials are searched on in Google. The Pypl top 10 for June 2025: 1. Python, with a 30.63% share 2. Java, 15.36% 3. JavaScript, 7.78% 4. C/C++, 7.02% 5. C#, 6.02% 6. R, 4.63% 7. PHP, 3.58% 8. Rust, 2.97% 9. TypeScript, 2.81% 10. Objective-C, 2.79%
10.06.2025 03:12 — 👍 0    🔁 0    💬 0    📌 0
Preview
The AI platform wars will be won on the developer experience As much as we like to imagine technology repeatedly presents us with something novel, the reality is that tech history usually repeats itself. Whether mobile, cloud, or another technology trend, the platform that wins developers ends up owning the market. Microsoft learned this lesson with Windows and .NET, and AWS with cloud primitives, as detailed by Microsoft exec Scott Guthrie in a fascinating recent interview. Today we’re seeing the same dynamic in AI. Powerful models matter, sure, but the real prize will go to whoever makes AI _trivial_ to build into everyday software. In other words, the center of AI gravity isn’t research papers or GPUs; it’s the IDE, the API, and the open source repo. Whoever nails that workflow will end up with the largest, most loyal community—and the bank balance that goes with it. Nothing is guaranteed, but for a variety of reasons, Microsoft seems to be in the strongest position. ## Microsoft: The accidental front-runner Microsoft looks like an overnight AI sensation, but its lead has been decades in the making and originally had nothing to do with AI. It is, and was, always a matter of developers. According to Guthrie, Microsoft’s early dominance didn’t happen because Windows was a superior operating system. Microsoft relentlessly focused on making it easy for developers to build for Windows. “No one buys a platform by itself,” Guthrie notes, “they buy it for the applications that run on top.” Microsoft’s success was built on a foundation of tools such as Quick Basic and Microsoft C, which armed developers to build the ecosystem that made Windows indispensable. Then came Visual Basic, a tool Guthrie calls “absolutely revolutionary.” At a time when building a graphical user interface was a soul-crushing exercise in writing error-prone code, Visual Basic let developers drag and drop buttons, double-click, write a few lines of code, and run. It “transformed development” by lowering the barrier to entry, enabling a generation of programmers who were more focused on solving business problems than mastering arcane syntax. This playbook—empower the developer, win the platform—is core to Microsoft’s DNA. It’s why the company faltered in the early 2010s when its developer story grew stale, and it’s precisely how it engineered its stunning comeback. The masterstroke, of course, was Visual Studio Code, or VS Code. By 2014, Microsoft was losing the hearts and minds of the next generation of web and cloud developers who lived on Macs and in open source. As Guthrie tells it, Microsoft leadership knew they were on a “slowly melting iceberg.” Their response wasn’t to build a better Azure portal. It was to make a series of bold, developer-first decisions: They open-sourced .NET and made it cross-platform, and, most critically, they launched VS Code. VS Code was free, fast, open source, and ran everywhere. It wasn’t an explicit on-ramp to Azure; it was just a great tool that developers loved. That love rebuilt Microsoft’s credibility from the ground up and created the bridge that made the GitHub acquisition not just possible but palatable to a skeptical developer community. Today, Microsoft owns the primary editor (VS Code) and the primary collaboration platform (GitHub) preferred by developers. VS Code is used by three quarters of professional developers, and GitHub boasts more than 100 million developers. As Guthrie puts it in his interview with Gergely Orosz, “If you don’t have developers … building … applications [on your platform then] you don’t … have a business.” It’s safe to say Microsoft now has lots (and lots) of developers building applications on its platforms. GitHub Copilot also created a virtuous cycle for Azure. Need more model horsepower? One click in VS Code lights up an Azure OpenAI endpoint. Microsoft’s $10 billion bet on OpenAI, which at the time seemed excessive, suddenly looks cheap; the company turned bleeding-edge research into a sticky developer value proposition faster than any rival. Microsoft, weirdly, is cool again. ## Is the AI war Microsoft’s to lose? None of this guarantees Microsoft the winning position in AI, but it does make unseating Microsoft difficult. Again, the winner in AI will not be the company with the best API for a stand-alone model. The winner will be the company that seamlessly integrates AI into the developer’s existing workflow, making them more productive by orders of magnitude. Guthrie sees AI not as a replacement for developers but as the next evolution—a continuum from IntelliSense to today’s AI agents. “It’s really about … giving every developer superpowers,” he says. Microsoft is clearly ahead with this approach. Guthrie’s vision of evolving Copilot from a code-completing assistant to an autonomous agent that can take a Figma design and build a working microservices architecture is the holy grail of developer enablement. If the tech giant can pull it off, it’ll be tough to beat. Even so, it’s way too early to declare victory. Take AWS, for example. AWS has a massive, entrenched developer base, roughly one-third of all cloud spend, and an extensive menu of AI services, such as Amazon Bedrock and Amazon SageMaker. On this last front, AWS has been trying to up its developer tools game. Amazon Q Developer, for example, is an IDE plug-in that promises everything GitHub Copilot does, plus deep knowledge of your AWS bill, identity and access management policies, and Kubernetes manifests. AWS has the distribution and is trying to give developers a reason to keep workloads on AWS. And yet, AWS has never been a “tools” company. Its strength lies in providing a vast, powerful, and often bewildering array of infrastructure primitives. The developer experience can feel like assembling a car from a million different parts without a manual. AWS Cloud9 has failed to gain any meaningful traction against VS Code. AWS is powerful but has never demonstrated the product savvy to build a cohesive, beloved developer tool. For AWS to win the AI tools race would require a fundamental shift in its corporate DNA. After all, Microsoft didn’t just integrate GPT-4; it re-thought the whole editing experience. AWS must prove it can match that polish while keeping its hallmark flexibility. If it does, its installed base all but guarantees share. If not, developers may happily write Lambda functions in VS Code—and deploy them on Azure. What about OpenAI? It has what the others crave: unparalleled mindshare and, for now, the “hottest” models. Developers genuinely love the elegance and power of OpenAI’s APIs. OpenAI has successfully made sophisticated AI accessible to anyone with a credit card and a few lines of Python. But OpenAI is not a platform company. OpenAI is a feature, albeit a spectacular one. It exists entirely on top of someone else’s platform (Microsoft Azure). OpenAI doesn’t own the editor, the source control, or the CI/CD pipeline. To win, the company must either build out this entire developer ecosystem themselves—a monumental task—or hope that their API-led momentum is so strong that it doesn’t matter. The risk is that OpenAI becomes a commoditized intelligence layer, with the true value accruing to the platform that integrates its APIs most effectively. ## Keep an eye on Redmond History rarely repeats itself exactly, but its lessons are potent. Just as Visual Basic transformed development by simplifying complexity, AI-powered tools will do the same on a much grander scale. For this reason, Microsoft is the clear favorite to win the largest share of the AI market. Their victory is not guaranteed. It depends on their ability to execute on the VS Code playbook: prioritizing the developer experience above all else, even if it means building tools that help developers deploy to AWS or Google Cloud. The moment VS Code feels like a restrictive on-ramp to Azure, its magic will fade. The same is true of GitHub. Microsoft, as Guthrie calls out, learned its lesson in the early 2010s and has kept its eye on developers. Today Microsoft starts closer to developers’ keyboards and has shown a willingness to bet the balance sheet to stay there. But AI platform cycles are measured in months not decades. AWS has the cash and OpenAI has the mindshare, and both have huge communities betting on their success. All of this is great for developers, who have never had more leverage.
09.06.2025 18:01 — 👍 0    🔁 0    💬 0    📌 0
Preview
New AI tool targets critical hole in thousands of open source apps Dutch and Iranian security researchers have created an automated genAI tool that can scan huge open source repositories and patch vulnerable code that could compromise applications. Tested by scanning GitHub for a particular path traversal vulnerability in Node.js projects that’s been around since 2010, the tool identified 1,756 vulnerable projects, some described as “very influential,” and led to 63 projects being patched so far. The tool opens the possibility for genAI platforms like ChatGPT to automatically create and distribute patches in code repositories, dramatically increasing the security of open source applications. But the research, described in a recently published paper, also points to a serious limitation in the use of AI that will need to be fixed for this solution to be effective. While automated patching by a large language model (LLM) dramatically improves scalability, the patch also might introduce other bugs. And it might be difficult to fully eradicate the particular vulnerability they worked on because, after 15 years of exposure, some popular large language models (LLMs) seem to have been poisoned with it. Why? Because LLMs are trained on open source codebases, where that bug is buried. In fact, the researchers found that if an LLM is contaminated with a vulnerable source code pattern, it will generate that code even when instructed to synthesize secure code. So, the researchers say, one lesson is that popular vulnerable code patterns need to be eradicated not only from open-source projects and developers’ resources, but also from LLMs, “which can be a very challenging task.” ## Hackers have been planting bad code for years Threat actors have been planting vulnerabilities in open source repositories for years, hoping that, before the bugs are discovered, they can be used to infiltrate organizations adopting open source applications. The problem: Developers unknowingly copy and paste vulnerable code from code-sharing platforms such as Stack Overflow, which then gets into GitHub projects. Attackers need to know only one vulnerable code pattern to be able to successfully attack many projects and their downstream dependencies, the researchers note. The solution created by the researchers could allow the discovery and elimination of open source holes at scale, not just in one project at a time as is the case now. However, the tool isn’t “scan for this once, correct all,” because developers often fork repositories without contributing to the original projects. That means for a vulnerability to be truly erased, all repositories with a vulnerable piece of a code would have to be scanned and corrected. In addition, the vulnerable code pattern studied in this research used the path name part of the URL directly, without any special formatting, creating an easy to exploit flaw. That’s the pattern the tool focuses on; other placements of the bad code aren’t detected. The researchers will release the tool in August at a security conference in Vietnam. They plan to improve and extend it in several directions, particularly by integrating other vulnerable code patterns and improving patch generation. ## Skeptical expert However, Robert Beggs, head of Canadian incident response firm DigitalDefence, is skeptical of the value of the tool in its present state. The idea of an automated tool to scan for and patch malicious code has been around for a while, he pointed out, and he credits the authors for trying to address many of the possible problems already raised. But, he added, the research still doesn’t deal with questions like who’s responsible if a faulty patch damages a public project, and whether a repository manager can recognize that an AI tool is trying to insert what may be a vulnerability into an application? When it was suggested that management would have to approve the use of such a tool, Beggs wondered how managers would know the tool is trustworthy and – again – who would be responsible if the patch is bad? It’s also not clear how much, if any, post-remediation testing the tool will do to make sure the patch doesn’t do more damage. The paper says ultimately the responsibility for making sure the patch is correct lies with the project maintainers. The AI part of the tool creates a patch, calculates a CVSS score and submits a report to the project maintainers. The researchers “have an excellent process and I give them full credit for a tool that has a lot of capability. However, I personally wouldn’t touch the tool because it deals with altering source code,” Beggs said, adding, “I don’t feel artificial intelligence is at the level to let it manage source code for a large number of applications.” However, he admitted, academic papers are usually just the first pass at a problem. ## Open source developers can be part of the problem Along the way, the researchers also discovered a disturbing fact: Open source app developers sometimes ignore warnings that certain code snippets are radioactive. The vulnerable code the researchers wanted to fix in as many GitHub projects as possible dated back to 2010, and is found in GitHub Gist, a service for sharing code snippets. The code creates a static HTTP file server for Node.js web applications. “[Yet] despite its simplicity and popularity, many developers appear unaware that this code pattern is vulnerable to the path traversal attack,” the researchers write. Even those who recognized the problem faced disagreement from other developers, who repeatedly squashed the notion that the code was bad. In 2012, a developer commented that the code was vulnerable. Two years later, another developer raised the same concern about the vulnerability, but yet another developer said that the code was safe, after testing it. In 2018, somebody commented about the vulnerability again, and another developer insisted that that person did not understand the issue and that the code was safe. Separately, the code snippet was seen in a hard copy of a document created by the community of Mozilla developers in 2015 – and fixed seven years later. However, the vulnerable version also migrated to Stack Overflow in late 2015. Although snippet received several updates, the vulnerability was not fixed. In fact, the code snippet there was still vulnerable as of the publication of the current research. The same thing happened in 2016, the researchers note, with another Stack Overflow question (with over 88,000 views) in which a developer suspected the code held a vulnerability. However, that person was not able to verify the issue, so the code was again assumed safe. The researchers suspect the misunderstanding about the seriousness of the vulnerability is because, when developers test the code, they usually use a web browser or Linux’s _curl_ command. These would have masked the problem. Attackers, the researchers note, are not bound to use standard clients. Disturbingly, the researchers add, “we have also found several Node.js courses that used this vulnerable code snippet for teaching purposes.” . Further reading * High-risk open source vulnerabilities on the rise, Synopsys reports * Thousands of open source projects at risk from hack of GitHub Actions tool * [What GitHub can tell us about the future of open source ](https://www.infoworld.com/article/3965544/what-github-can-tell-us-about-the-future-of-open-source.html)
09.06.2025 13:00 — 👍 0    🔁 0    💬 0    📌 0
Preview
Building a multi-zone and multi-region SQL Server Failover Cluster Instance in Azure Much has been written about SQL Server Always On Availability Groups, but the topic of SQL Server Failover Cluster Instances (FCI) that span both availability zones and regions is far less discussed. However, for organizations that require SQL Server high availability (HA) and disaster recovery (DR) without the added licensing costs of Enterprise Edition, SQL Server FCI remains a powerful and cost-effective solution. In this article, we will explore how to deploy a resilient SQL Server FCI in Microsoft Azure, leveraging Windows Server Failover Clustering (WSFC) and various Azure services to ensure both high availability and disaster recovery. While deploying an FCI in a single availability zone is relatively straightforward, configuring it to span multiple availability zones—and optionally, multiple regions—introduces a set of unique challenges, including cross-zone and cross-region failover, storage replication, and network latency. To overcome these challenges, we must first establish a properly configured network foundation that supports multi-region SQL Server FCI deployments. This article includes a comprehensive PowerShell script that automates the necessary networking configuration, ensuring a seamless and resilient infrastructure. This script: * Creates two virtual networks (vNets) in different Azure paired regions * Establishes secure peering between these vNets for seamless cross-region communication * Configures network security groups (NSGs) to control inbound and outbound traffic, ensuring SQL Server and WSFC can function properly * Associates the NSGs with subnets, enforcing security policies while enabling necessary connectivity By automating these steps, we lay the groundwork for SQL Server FCI to operate effectively in a multi-region Azure environment. Additionally, we will cover key technologies such as Azure Shared Disks, SIOS DataKeeper, Azure Load Balancer, and quorum configuration within WSFC to complete the deployment. By the end of this discussion, you will have a clear roadmap for architecting a SQL Server FCI deployment that is highly available, disaster-resistant, and optimized for minimal downtime across multiple Azure regions. ## Pre-requisites Before deploying a SQL Server Failover Cluster Instance (FCI) across availability zones and regions in Azure, ensure you have the following prerequisites in place: 1. Azure subscription with necessary permissions * You must have an active Azure subscription with sufficient permissions to create virtual machines, manage networking, and configure storage. Specifically, you need Owner or Contributor permissions on the target resource group. 2. Access to SQL Server and SIOS DataKeeper installation media * SQL Server installation media: Ensure you have the SQL Server Standard or Enterprise Edition installation media available. You can download it from the Microsoft Evaluation Center. * SIOS DataKeeper installation media: You will need access to SIOS DataKeeper Cluster Edition for block-level replication. You can request an evaluation copy from SIOS Technology. ## Configuring networking for SQL Server FCI across Azure paired regions To deploy a SQL Server Failover Cluster Instance (FCI) across availability zones and regions, you need to configure networking appropriately. This section outlines the automated network setup using PowerShell, which includes: 1. Creating two virtual networks (vNets) in different Azure paired regions 2. Creating Subnets – two in the primary region and one in the DR region 3. Peering between vNets to enable seamless cross-region communication 4. Configuring a network security group (NSG) to: * Allow full communication between vNets (essential for SQL and cluster traffic) * Enable secure remote desktop (RDP) access for management purposes The PowerShell script provided in this session automates these critical networking tasks, ensuring that your SQL Server FCI deployment has a robust, scalable, and secure foundation. Once the network is in place, we will proceed to the next steps in configuring SQL Server FCI, storage replication, and failover strategies. # Define Variables $PrimaryRegion = "East US 2" $DRRegion = "Central US" $ResourceGroup = "MySQLFCIResourceGroup" $PrimaryVNetName = "PrimaryVNet" $DRVNetName = "DRVNet" $PrimaryNSGName = "SQLFCI-NSG-Primary" $DRNSGName = "SQLFCI-NSG-DR" $PrimarySubnet1Name = "SQLSubnet1" $DRSubnetName = "DRSQLSubnet" $PrimaryAddressSpace = "10.1.0.0/16" $PrimarySubnet1Address = "10.1.1.0/24" $DRAddressSpace = "10.2.0.0/16" $DRSubnetAddress = "10.2.1.0/24" $SourceRDPAllowedIP = "98.110.113.146/32" # Replace with your actual IP $DNSServer = "10.1.1.102" #set this to your Domain controller # Create Resource Group if not exists Write-Output "Creating Resource Group ($ResourceGroup) if not exists..." New-AzResourceGroup -Name $ResourceGroup -Location $PrimaryRegion -ErrorAction SilentlyContinue # Create Primary vNet with a subnet Write-Output "Creating Primary VNet ($PrimaryVNetName) in $PrimaryRegion..." $PrimaryVNet = New-AzVirtualNetwork -ResourceGroupName $ResourceGroup -Location $PrimaryRegion -Name $PrimaryVNetName -AddressPrefix $PrimaryAddressSpace -DnsServer $DNSServer $PrimarySubnet1 = Add-AzVirtualNetworkSubnetConfig -Name $PrimarySubnet1Name -AddressPrefix $PrimarySubnet1Address -VirtualNetwork $PrimaryVNet Set-AzVirtualNetwork -VirtualNetwork $PrimaryVNet # Create DR vNet with a subnet Write-Output "Creating DR VNet ($DRVNetName) in $DRRegion..." $DRVNet = New-AzVirtualNetwork -ResourceGroupName $ResourceGroup -Location $DRRegion -Name $DRVNetName -AddressPrefix $DRAddressSpace -DnsServer $DNSServer $DRSubnet = Add-AzVirtualNetworkSubnetConfig -Name $DRSubnetName -AddressPrefix $DRSubnetAddress -VirtualNetwork $DRVNet Set-AzVirtualNetwork -VirtualNetwork $DRVNet # Configure Peering Between vNets Write-Output "Configuring VNet Peering..." $PrimaryVNet = Get-AzVirtualNetwork -Name $PrimaryVNetName -ResourceGroupName $ResourceGroup $DRVNet = Get-AzVirtualNetwork -Name $DRVNetName -ResourceGroupName $ResourceGroup # Create Peering from Primary to DR Write-Output "Creating Peering from $PrimaryVNetName to $DRVNetName..." $PrimaryToDRPeering = Add-AzVirtualNetworkPeering -Name "PrimaryToDR" -VirtualNetwork $PrimaryVNet -RemoteVirtualNetworkId $DRVNet.Id Start-Sleep -Seconds 10 # Create Peering from DR to Primary Write-Output "Creating Peering from $DRVNetName to $PrimaryVNetName..." $DRToPrimaryPeering = Add-AzVirtualNetworkPeering -Name "DRToPrimary" -VirtualNetwork $DRVNet -RemoteVirtualNetworkId $PrimaryVNet.Id Start-Sleep -Seconds 10 # Retrieve and update Peering settings $PrimaryToDRPeering = Get-AzVirtualNetworkPeering -ResourceGroupName $ResourceGroup -VirtualNetworkName $PrimaryVNetName -Name "PrimaryToDR" $DRToPrimaryPeering = Get-AzVirtualNetworkPeering -ResourceGroupName $ResourceGroup -VirtualNetworkName $DRVNetName -Name "DRToPrimary" $PrimaryToDRPeering.AllowVirtualNetworkAccess = $true $PrimaryToDRPeering.AllowForwardedTraffic = $true $PrimaryToDRPeering.UseRemoteGateways = $false Set-AzVirtualNetworkPeering -VirtualNetworkPeering $PrimaryToDRPeering $DRToPrimaryPeering.AllowVirtualNetworkAccess = $true $DRToPrimaryPeering.AllowForwardedTraffic = $true $DRToPrimaryPeering.UseRemoteGateways = $false Set-AzVirtualNetworkPeering -VirtualNetworkPeering $DRToPrimaryPeering Write-Output "VNet Peering established successfully." # Create Network Security Groups (NSGs) Write-Output "Creating NSGs for both regions..." $PrimaryNSG = New-AzNetworkSecurityGroup -ResourceGroupName $ResourceGroup -Location $PrimaryRegion -Name $PrimaryNSGName $DRNSG = New-AzNetworkSecurityGroup -ResourceGroupName $ResourceGroup -Location $DRRegion -Name $DRNSGName # Define NSG Rules (Allow VNet communication and RDP) $Rule1 = New-AzNetworkSecurityRuleConfig -Name "AllowAllVNetTraffic" -Priority 100 -Direction Inbound -Access Allow -Protocol * ` -SourceAddressPrefix VirtualNetwork -SourcePortRange * -DestinationAddressPrefix VirtualNetwork -DestinationPortRange * $Rule2 = New-AzNetworkSecurityRuleConfig -Name "AllowRDP" -Priority 200 -Direction Inbound -Access Allow -Protocol TCP ` -SourceAddressPrefix $SourceRDPAllowedIP -SourcePortRange * -DestinationAddressPrefix "*" -DestinationPortRange 3389 # Apply Rules to NSGs $PrimaryNSG.SecurityRules = @($Rule1, $Rule2) $DRNSG.SecurityRules = @($Rule1, $Rule2) Set-AzNetworkSecurityGroup -NetworkSecurityGroup $PrimaryNSG Set-AzNetworkSecurityGroup -NetworkSecurityGroup $DRNSG Write-Output "NSGs created and configured successfully." # Associate NSGs with Subnets Write-Output "Associating NSGs with respective subnets..." $PrimaryVNet = Get-AzVirtualNetwork -Name $PrimaryVNetName -ResourceGroupName $ResourceGroup $DRVNet = Get-AzVirtualNetwork -Name $DRVNetName -ResourceGroupName $ResourceGroup $PrimaryNSG = Get-AzNetworkSecurityGroup -Name $PrimaryNSGName -ResourceGroupName $ResourceGroup $DRNSG = Get-AzNetworkSecurityGroup -Name $DRNSGName -ResourceGroupName $ResourceGroup $PrimarySubnet1 = Set-AzVirtualNetworkSubnetConfig -VirtualNetwork $PrimaryVNet -Name $PrimarySubnet1Name ` -AddressPrefix $PrimarySubnet1Address -NetworkSecurityGroup $PrimaryNSG $DRSubnet = Set-AzVirtualNetworkSubnetConfig -VirtualNetwork $DRVNet -Name $DRSubnetName ` -AddressPrefix $DRSubnetAddress -NetworkSecurityGroup $DRNSG Set-AzVirtualNetwork -VirtualNetwork $PrimaryVNet Set-AzVirtualNetwork -VirtualNetwork $DRVNet Write-Output "NSGs successfully associated with all subnets!" Write-Output "Azure network setup completed successfully!" ## Deploying SQL Server virtual machines in Azure with high availability To achieve HA and DR, we deploy SQL Server Failover Cluster Instance (FCI) nodes across multiple Availability Zones (AZs) within Azure regions. By distributing the SQL Server nodes across separate AZs, we qualify for Azure’s 99.99% SLA for virtual machines, ensuring resilience against hardware failures and zone outages. Each SQL Server virtual machine (VM) is assigned a static private and public IP address, ensuring stable connectivity for internal cluster communication and remote management. Additionally, each SQL Server node is provisioned with an extra 20GB Premium SSD, which will be used by SIOS DataKeeper Cluster Edition to create replicated cluster storage across AZs and regions. Because Azure does not natively provide shared storage spanning multiple AZs or regions, SIOS DataKeeper enables block-level replication, ensuring that all clustered SQL Server nodes have synchronized copies of the data, allowing for seamless failover with no data loss. In a production environment, multiple domain controllers (DCs) would typically be deployed, spanning both AZs and regions to ensure redundancy and fault tolerance for Active Directory services. However, for the sake of this example, we will keep it simple and deploy a single domain controller (DC1) in Availability Zone 3 in East US 2 to provide the necessary authentication and cluster quorum support. The PowerShell script below automates the deployment of these SQL Server VMs, ensuring that: * SQLNode1 is deployed in Availability Zone 1 in East US 2 * SQLNode2 is deployed in Availability Zone 2 in East US 2 * SQLNode3 is deployed in Availability Zone 1 in Central US * DC1 is deployed in Availability Zone 3 in East US 2 By following this deployment model, SQL Server FCI can span multiple AZs and even multiple regions, providing a highly available and disaster-resistant database solution. # Define Variables $ResourceGroup = "MySQLFCIResourceGroup" $PrimaryRegion = "East US 2" $DRRegion = "Central US" $VMSize = "Standard_D2s_v3" # VM Size $AdminUsername = "sqladmin" $AdminPassword = ConvertTo-SecureString "YourSecurePassword123!" -AsPlainText -Force $Credential = New-Object System.Management.Automation.PSCredential ($AdminUsername, $AdminPassword) # Get Virtual Networks $PrimaryVNet = Get-AzVirtualNetwork -Name "PrimaryVNet" -ResourceGroupName $ResourceGroup $DRVNet = Get-AzVirtualNetwork -Name "DRVNet" -ResourceGroupName $ResourceGroup # Get Subnets $PrimarySubnet1 = Get-AzVirtualNetworkSubnetConfig -VirtualNetwork $PrimaryVNet -Name "SQLSubnet1" $DRSubnet = Get-AzVirtualNetworkSubnetConfig -VirtualNetwork $DRVNet -Name "DRSQLSubnet" # Define Static Private IPs $IP1 = "10.1.1.100" # SQLNode1 in East US, AZ1 $IP2 = "10.1.1.101" # SQLNode2 in East US, AZ2 $IP3 = "10.2.1.100" # SQLNode3 in West US (Availability Zones may not be supported) $IP4 = "10.1.1.102" # DC1 in East US, AZ3 (No extra disk) # Function to Create a VM with Static Private & Public IP, Availability Zone, and attach an extra disk (except for DC1) Function Create-SQLVM { param ( [string]$VMName, [string]$Location, [string]$SubnetId, [string]$StaticPrivateIP, [string]$AvailabilityZone, [bool]$AttachExtraDisk ) # Create Public IP Address (Static) Write-Output "Creating Public IP for $VMName..." $PublicIP = New-AzPublicIpAddress -ResourceGroupName $ResourceGroup -Location $Location ` -Name "$VMName-PublicIP" -Sku Standard -AllocationMethod Static # Create Network Interface with Static Private & Public IP Write-Output "Creating NIC for $VMName in $Location (Zone $AvailabilityZone)..." $NIC = New-AzNetworkInterface -ResourceGroupName $ResourceGroup -Location $Location ` -Name "$VMName-NIC" -SubnetId $SubnetId -PrivateIpAddress $StaticPrivateIP -PublicIpAddressId $PublicIP.Id # Create VM Configuration with Availability Zone (if supported) Write-Output "Creating VM $VMName in $Location (Zone $AvailabilityZone)..." if ($Location -eq $DRRegion) { # Check if Availability Zones are supported for West US $VMConfig = New-AzVMConfig -VMName $VMName -VMSize $VMSize -Zone $AvailabilityZone | ` Set-AzVMOperatingSystem -Windows -ComputerName $VMName -Credential $Credential | ` Set-AzVMSourceImage -PublisherName "MicrosoftWindowsServer" -Offer "WindowsServer" -Skus "2022-Datacenter" -Version "latest" | ` Add-AzVMNetworkInterface -Id $NIC.Id | ` Set-AzVMOSDisk -CreateOption FromImage Write-Output "Warning: Availability Zones not supported in West US. Deploying without AZ." } else { # Use Availability Zone for East US $VMConfig = New-AzVMConfig -VMName $VMName -VMSize $VMSize -Zone $AvailabilityZone | ` Set-AzVMOperatingSystem -Windows -ComputerName $VMName -Credential $Credential | ` Set-AzVMSourceImage -PublisherName "MicrosoftWindowsServer" -Offer "WindowsServer" -Skus "2022-Datacenter" -Version "latest" | ` Add-AzVMNetworkInterface -Id $NIC.Id | ` Set-AzVMOSDisk -CreateOption FromImage } # Conditionally Attach an Extra 20 GB Premium SSD LRS Disk in the same Availability Zone (Not for DC1) if ($AttachExtraDisk) { Write-Output "Attaching extra 20GB Premium SSD disk to $VMName in Zone $AvailabilityZone..." $DiskConfig = New-AzDiskConfig -SkuName "Premium_LRS" -Location $Location -Zone $AvailabilityZone -CreateOption Empty -DiskSizeGB 20 $DataDisk = New-AzDisk -ResourceGroupName $ResourceGroup -DiskName "$VMName-Disk" -Disk $DiskConfig $VMConfig = Add-AzVMDataDisk -VM $VMConfig -Name "$VMName-Disk" -CreateOption Attach -ManagedDiskId $DataDisk.Id -Lun 1 } # Deploy VM New-AzVM -ResourceGroupName $ResourceGroup -Location $Location -VM $VMConfig } # Deploy SQL Nodes in the specified Availability Zones with Static Public IPs Create-SQLVM -VMName "SQLNode1" -Location $PrimaryRegion -SubnetId $PrimarySubnet1.Id -StaticPrivateIP $IP1 -AvailabilityZone "1" -AttachExtraDisk $true Create-SQLVM -VMName "SQLNode2" -Location $PrimaryRegion -SubnetId $PrimarySubnet1.Id -StaticPrivateIP $IP2 -AvailabilityZone "2" -AttachExtraDisk $true Create-SQLVM -VMName "SQLNode3" -Location $DRRegion -SubnetId $DRSubnet.Id -StaticPrivateIP $IP3 -AvailabilityZone "1" -AttachExtraDisk $true # West US AZ fallback # Deploy DC1 in East US, AZ3 with Static Public IP but without an extra disk Create-SQLVM -VMName "DC1" -Location $PrimaryRegion -SubnetId $PrimarySubnet1.Id -StaticPrivateIP $IP4 -AvailabilityZone "3" -AttachExtraDisk $false Write-Output "All VMs have been successfully created with Static Public & Private IPs in their respective Availability Zones!" ## Completing the SQL Server FCI deployment With the SQL Server virtual machines deployed across multiple AZs and regions, the next steps involve configuring networking, setting up Active Directory, enabling clustering, and installing SQL Server FCI. These steps will ensure HA and DR for SQL Server across Azure regions. ### 1. Create a domain on DC1 The domain controller (DC1) will provide authentication and Active Directory services for the SQL Server Failover Cluster. To set up the Active Directory Domain Services (AD DS) on DC1, we will: 1. Install the Active Directory Domain Services role. 2. Promote DC1 to a domain controller. 3. Create a new domain (e.g., corp.local). 4. Configure DNS settings to ensure domain resolution. Once completed, this will allow the cluster nodes to join the domain and participate in Windows Server Failover Clustering (WSFC). ### 2. Join SQLNode1, SQLNode2, and SQLNode3 to the domain Now that DC1 is running Active Directory, we will join SQLNode1, SQLNode2, and SQLNode3 to the new domain (e.g., datakeeper.local). This is a critical step, as Windows Server Failover Clustering (WSFC) and SQL Server FCI require domain membership for proper authentication and communication. Steps: 1. Join each SQL node to the Active Directory domain. 2. Restart the servers to apply changes. ### 3. Enable Windows Server Failover Clustering (WSFC) With all nodes now part of the Active Directory domain, the next step is to install and enable WSFC on all three SQL nodes. This feature provides the foundation for SQL Server FCI, allowing for automatic failover between nodes. Steps: 1. Install the Failover Clustering feature on all SQL nodes. Install-WindowsFeature -Name Failover-Clustering -IncludeManagementTools 2. Enable the Cluster service. New-Cluster -Name SQLCluster -Node SQLNode1,SQLNode2,SQLNode3 -NoStorage SIOS ### 4. Create a cloud storage account for Cloud Witness To ensure quorum resiliency, we will configure a Cloud Witness as the cluster quorum mechanism. This Azure storage account-based witness is a lightweight, highly available solution that ensures the cluster maintains quorum even in the event of an AZ or regional failure. Steps: 1. Create an Azure storage account in a third, independent region. New-AzStorageAccount -ResourceGroupName "MySQLFCIResourceGroup" ` -Name "cloudwitnessstorageacct" ` -Location "westus3" ` -SkuName "Standard_LRS" ` -Kind StorageV2 2. Get the key that will be used to create the Cloud Witness. Get-AzStorageAccountKey -ResourceGroupName "MySQLFCIResourceGroup" -Name "cloudwitnessstorageacct" KeyName Value Permissions CreationTime ------- ----- ----------- ------------ key1 dBIdjU/lu+86j8zcM1tdg/j75lZrB9sVKHUKhBEneHyMOxYTeZhtVeuzt7MtBOO9x/8QtYlrbNYY+AStddZZOg== Full 3/28/2025 2:38:00 PM key2 54W5NdJ6xbFwjTrF0ryIOL6M7xGOylc1jxnD8JQ94ZOy5dQOo3BAJB2TYzb22KaDeYrv09m6xVsW+AStBxRq6w== Full 3/28/2025 2:38:00 PM 3. Configure the WSFC cluster quorum settings to use Cloud Witness as the tie-breaker. This PowerShell script can be run on any of the cluster nodes. $parameters = @{ CloudWitness = $true AccountName = 'cloudwitnessstorageacct' AccessKey = 'dBIdjU/lu+86j8zcM1tdg/j75lZrB9sVKHUKhBEneHyMOxYTeZhtVeuzt7MtBOO9x/8QtYlrbNYY+AStddZZOg==' Endpoint = 'core.windows.net' } Set-ClusterQuorum @parameters ### 5. Validate the configuration With WSFC enabled and Cloud Witness configured, we can now create the base Windows Failover Cluster. This involves running Cluster Validation to ensure all cluster nodes meet requirements. Test-Cluster Once the base cluster is operational, we move on to configuring storage replication with SIOS DataKeeper. ### 6. Install SIOS DataKeeper on all three cluster nodes Because Azure does not support shared storage across AZs and regions, we use SIOS DataKeeper Cluster Edition to replicate block-level storage and create a stretched cluster. Steps: 1. Install SIOS DataKeeper Cluster Edition on SQLNode1, SQLNode2, and SQLNode3. 2. Restart the nodes after installation. 3. Ensure the SIOS DataKeeper service is running on all nodes. ### 7. Format the 20GB Disk as the F: drive Each SQL node has an additional 20GB Premium SSD, which will be used for SQL Server data storage replication. Steps: 1. Initialize the extra 20GB disk on SQLNode1. 2. Format it as the F: drive. 3. Assign the same drive letter (F:) on SQLNode2 and SQLNode3 to maintain consistency. ### 8. Create the DataKeeper job to replicate the F: drive Now that the F: drive is configured, we create a DataKeeper replication job to synchronize data between the nodes: 1. Synchronous replication between SQLNode1 and SQLNode2 (for low-latency, intra-region failover). 2. Asynchronous replication between SQLNode1 and SQLNode3 (for cross-region disaster recovery). Steps: 1. Launch DataKeeper and create a new replication job. 2. Configure synchronous replication for the F: drive between SQLNode1 and SQLNode2. 3. Configure asynchronous replication between SQLNode1 and SQLNode3. The screenshots below walk through the process of creating the DataKeeper job that replicates the F: drive between the three servers. SIOS SIOS SIOS SIOS SIOS To add the second target, right-click on the existing Job and choose “Create a Mirror.” SIOS SIOS SIOS SIOS SIOS Once replication is active, SQLNode2 and SQLNode3 will have an identical copy of the data stored on SQLNode1’s F: drive. If you look in Failover Cluster Manager, you will see “DataKeeper Volume F” in Available Storage. Failover clustering will treat this like it is a regular shared disk. SIOS ### 9. Install SQL Server on SQLNode1 as a new clustered instance With WSFC configured and storage replication active, we can now install SQL Server FCI. Steps: 1. On SQLNode1, launch the SQL Server installer. 2. Choose “New SQL Server failover cluster installation.” 3. Complete the installation and restart SQLNode1. You will notice during the installation, that the “DataKeeper Volume F” is presented as an available storage location. SIOS ### 10. Install SQL Server on SQLNode2 and SQLNode3 (Add Node to Cluster) To complete the SQL Server FCI, we must add the remaining nodes to the cluster. Steps: 1. Run SQL Server setup on SQLNode2 and SQLNode3. 2. Choose “Add node to an existing SQL Server failover cluster.” 3. Validate cluster settings and complete the installation. Once SQL Server is installed on all three cluster nodes, Failover Cluster Manager will look like this. SIOS ### 11. Update SQL Server to use a distributed network name (DNN) By default, SQL Server FCI requires an Azure load balancer (ALB) to manage client connections. However, Azure now supports distributed network names (DNNs), eliminating the need for an ALB. Steps: 1. Update SQL Server FCI to use DNN instead of a traditional floating IP. 2. Ensure name resolution works across all nodes. 3. Validate client connectivity to SQL Server using DNN. Detailed instructions on how to update SQL Server FCI to use DNN can be found in the Microsoft documentation. Add-ClusterResource -Name sqlserverdnn -ResourceType "Distributed Network Name" -Group "SQL Server (MSSQLSERVER)" Get-ClusterResource -Name sqlserverdnn | Set-ClusterParameter -Name DnsName -Value FCIDNN Start-ClusterResource -Name sqlserverdnn You can now connect to the clustered SQL instance using the DNN “FCIDNN.” ### 12. Install SQL Server Management Studio (SSMS) on all three nodes For easier SQL Server administration, install SQL Server Management Studio (SSMS) on all three nodes. Steps: 1. Download the latest version of SSMS from Microsoft. 2. Install SSMS on SQLNode1, SQLNode2, and SQLNode3. 3. Connect to the SQL Server cluster using DNN. ### 13. Test failover and switchover scenarios Finally, we validate HA and DR functionality by testing failover and switchover scenarios: 1. Perform a planned failover (manual switchover) from SQLNode1 to SQLNode2. 2. Simulate an AZ failure and observe automatic failover. 3. Test cross-region failover from SQLNode1 (East US 2) to SQLNode3 (Central US). This confirms that SQL Server FCI can seamlessly failover within AZs and across regions, ensuring minimal downtime and data integrity. ## Four nines uptime By following these steps, we have successfully deployed, configured, and tested a multi-AZ, multi-region SQL Server FCI in Azure. This architecture provides 99.99% uptime, seamless failover, and disaster recovery capabilities, making it ideal for business-critical applications. _Dave Bermingham is senior technical evangelist atSIOS Technology._ _—_ **_New Tech Forum_** _**provides a venue for technology leaders—including vendors and other outside contributors—to explore and discuss emerging enterprise technology in unprecedented depth and breadth. The selection is subjective, based on our pick of the technologies we believe to be important and of greatest interest to InfoWorld readers. InfoWorld does not accept marketing collateral for publication and reserves the right to edit all contributed content. Send all**_ _**inquiries to**_** _doug_dineley@foundryco.com_** _**.**_
09.06.2025 09:00 — 👍 0    🔁 0    💬 0    📌 0
Preview
JDK 25: The new features in Java 25 Java Development Kit (JDK) 25, a planned long-term support release of standard Java due in September, has reached the initial rampdown or bug-fixing phase with 18 features. The final feature, added June 5, is an enhancement to the JDK Flight Recorder (JFR) to capture CPU-time profiling information on Linux. JDK 25 comes on the heels of JDK 24, a six-month-support release that arrived March 18. As a long-term support (LTS) release, JDK 25 will get at least five years of Premier support from Oracle. JDK 25 is due to arrive as a production release on September 16, after a second rampdown phase beginning July 17 and two release candidates planned for August 17 and August 21. The most recent LTS release was JDK 21, which arrived in September 2023. Early access builds of JDK 25 can be downloaded from jdk.java.net. The features previously slated for JDK 25 include: a preview of PEM (Privacy-Enhanced Mail) encodings of cryptographic objects, the Shenandoah garbage collector, ahead-of-time command-line ergonomics, ahead-of-time method profiling, JDK Flight Recorder (JFR) cooperative sampling, JFR method timing and tracing, compact object headers, a third preview of primitive types in patterns, instanceof, and switch. Also, scoped values, a vector API, a key derivation function API, structured concurrency, flexible constructor bodies, module import declarations, compact source files and instance main methods, stable values, and removal of the 32-bit x86 port. JFR CPU-time profiling feature enhances the JDK Flight Recorder to capture CPU-time profiling information on Linux. The JFR is the JDK’s profiling and monitoring facility. Enhancing the JFR to use the Linux kernel’s CPU timer to safely produce CPU-time profiles of Java programs would help developers optimize the efficiency of the Java applications they deploy on Linux. CPU-time profiling on the JFR may be added for other platforms in the future. The CPU time-profiling feature is the third feature involving the JFR in JDK 25, with the others being the cooperative sampling and method timing and tracing capabilities. This is an experimental feature. With PEM encodings of cryptographic objects, JDK 25 previews a concise API for encoding objects that represent cryptographic keys, certificates, and certificate revocation into the widely used PEM format transport, and for decoding from the format back into objects. The Java platform has not had an easy-to-use API for decoding and encoding in the PEM format. A main goal of the feature is ease of use. Another goal is support for conversions between PEM text and cryptographic objects that have standard representations in the binary formats PKCS#8 (for private keys), X.509 (for public keys, certificates, and certificate revocation lists), and PKCS#8 v2.0 (for encrypted private keys and asymmetric keys). Generational Shenandoah changes the generational mode of the Shenandoah garbage collector (GC) from an experimental feature to a product feature. Previewed in JDK 24, the GC has had many stability and performance enhancements, according to the proposal. The GC in JDK 24 was intended to offer collection capabilities to improve sustainable throughput, load-spike resilience, and memory utilization Several users have reported running demanding workloads with this GC. Generational Shenandoah once was planned for JDK 21 in 2023 but was dropped because the capability was deemed not ready at the time. Ahead-of-time command-line ergonomics is intended to make it easier to create ahead-of-time (AOT) caches, which accelerate the startup of Java applications by simplifying commands needed for common use cases. Goals include simplifying the process of creating an AOT cache with no loss of expressiveness, and not introducing fundamentally new AOT workflows but making it easier to access existing ones. This proposal follows the ahead-of-time caches introduced by ahead-of-time class loading and linking in JDK 24. Ahead-of-time method profiling would improve warmup time by making method execution profiles from a previous run of an application available right away when the HotSpot JVM starts. This will enable the just-in-time (JIT) compiler to generate native code instantly upon application startup rather than having to wait for the collection of profiles. Here, goals include helping applications warm up quicker; not requiring any changes to the code of applications, libraries, or frameworks; and not introducing any new constraints on application execution. The proposal also would not introduce new AOT workflows, but would use existing AOT cache creation commands. The AOT cache introduced in JDK 24 would be extended to collect method profiles during training runs. JFR cooperative sampling would improve the stability of the JDK Flight Recorder when it asynchronously samples Java thread stacks. This would be achieved by walking call stacks only at safepoints while minimizing safepoint bias. JFR method timing and tracing would extend the JDK Flight Recorder with facilities for method timing and tracing rather than via bytecode instrumentation. Goals of this feature include allowing execution times and stack traces to be recorded for specific methods without needing source code modifications, and recording exact statistics for method invocations. Another goal is allowing methods to be selected via command-line argument, configuration files, the `jcmd` tool, and over the network via the Java Management Extensions API. Timing and tracing method invocations can help identify performance bottlenecks, optimize code, and find the root causes of bugs. Compact object headers, an experimental feature in JDK 24, would become a product feature in JDK 25. In JDK 24, this capability was introduced to reduce the size of object headers in the HotSpot JVM from between 96 bits and 128 bits down to 64 bits on 64-bit architectures. This reduces the heap size, improves deployment density, and increases data locality. Since JDK 24, compact object headers have proven their stability and performance, the proposal says. A third preview of primitive types in patterns, instanceof, and switch would enhance pattern matching by allowing primitive types in all pattern contexts and extend `instanceof` and `switch` to work with all primitive types. Originally proposed in JDK 23 and followed up in JDK 24, this would still be a preview language feature in JDK 25. Among goals are enabling data exploration by allowing type patterns for all types, whether primitive or reference, and providing easy-to-use constructs that eliminate the risk of losing information due to unsafe casts. Scoped values, to be previewed for a fifth time, allows a method to share immutable data with its callees within a thread and with child threads. Scoped values are easier to reason about than thread-local variables, according to the OpenJDK JDK Enhancement Proposal (JEP). They also have lower space and time costs, especially when used together with virtual threads and structured concurrency. Goals of the plan include ease of use, comprehensibility, robustness, and performance. The scoped values API was proposed for incubation in JDK 20, proposed for preview in JDK 21, and subsequently refined for JDK 22 through JDK 24. The feature will be finalized in JDK 25, with one change: the `ScopedValue.orElse` method no longer accepts `null` as its argument. The vector API is designed to express vector computations that reliably compile at runtime to optimal vector instructions on supported CPUs, thus achieving performance superior to equivalent scalar computations. The API will be incubated for the 10th time in JDK 25, after having been incubated in every release dating back to JDK 16. Two notable implementation changes are featured in the JDK 25 implementation of the API. First, the implementation now links to native mathematical-function libraries via the Foreign Function and Memory API rather than custom C++ code inside the HotSpot JVM, thus improving maintainability. Second, addition, subtraction, division, multiplication, square root, and fused multiply/add operations on `Float16` values now are auto-vectorized on supporting x64 CPUs. Additionally, **`VectorShuffle`** now supports access to and from `MemorySegment`. The key derivation function API provides for functions that are cryptographic algorithms for deriving additional keys from a secret key and other data. One of the goals of the API is enabling applications to use key derivation function algorithms such as the HMAC-based Extract-and-Expand Key Derivation Function and Argon2. Other goals include allowing security providers to implement key derivation function algorithms in either Java code or native code, and enabling the use of key derivation functions in key encapsulation mechanism implementations such as ML-KEM, in higher level protocols such as Hybrid Key Exchange in TLS 1.3, and in cryptographic schemes such as Hybrid Public Key Encryption. The API will be finalized in JDK 25 after being previewed in JDK 24. Structured concurrency was previewed previously in JDK 21 through JDK 24, after being incubated in JDK 19 and JDK 20. Now in its fifth preview, structured concurrency treats groups of related tasks running in different threads as single units of work. This streamlines error handling and cancellation, improves reliability, and enhances observability, the proposal states. The primary goal is to promote a style of concurrent programming that can eliminate common risks arising from cancellation and shutdown, such as thread leaks and cancellation delays. A second goal is to improve the observability of concurrent code. JDK 25 introduces several API changes. In particular, a `StructuredTaskScope` is now opened via static factory methods rather than public constructors. Also, the zero-parameter `open` factory method covers the common case by creating a `StructuredTaskScope` that waits for all subtasks to succeed or any subtask to fail. Flexible constructor bodies was previewed in JDK 22 as “statements before super(…)” as well as in JDK 23 and JDK 24. The feature is intended to be finalized in JDK 25. In flexible constructor bodies, the body of a constructor allows statements to appear before an explicit constructor invocation such as `super (…)` or `this (…)`.**** These statements cannot reference the object under construction but they can initialize its fields and perform other safe computations. This change lets many constructors be expressed more naturally and allows fields to be initialized before becoming visible to other code in the class, such as methods called from a superclass constructor, thereby improving safety. Goals of the feature include removing unnecessary restrictions on code in constructors; providing additional guarantees that state of a new object is fully initialized before any code can use it; and reimagining the process of how constructors interact with each other to create a fully initialized object. Module import declarations, which was previewed in JDK 23 and JDK 24, enhances the Java language with the ability to succinctly import all of the packages exported by a module. This simplifies the reuse of modular libraries but does not require the importing code to be in a module itself. Goals include simplifying the reuse of modular libraries by letting entire modules be imported at once; avoiding the noise of multiple type import-on-demand declarations when using diverse parts of the API exported by a module; allowing beginners to more easily use third-party libraries and fundamental Java classes without having to learn where they are located in a package hierarchy; and ensuring that module import declarations work smoothly alongside existing import declarations. Developers who use the module import feature should not be required to modularize their own code. Compact source files and instance main methods evolves the Java language so beginners can write their first programs without needing to understand language features designed for large programs. Beginners can write streamlined declarations for single-class programs and seamlessly expand programs to use more advanced features as their skills grow. Likewise, experienced developers can write small programs succinctly without the need for constructs intended for programming in the large, the proposal states. This feature, due to be finalized in JDK 25, was previewed in JDK 21, JDK 22, JDK 23, and JDK 24, albeit under slightly different names. In JDK 24 it was called “simple source files and instance main methods.” Stable values are objects that hold immutable data. Because stable values are treated as constants by the JVM, they enable the same performance optimizations that are enabled by declaring a field final. But compared to final**** fields, stable values offer greater flexibility regarding the timing of their initialization. A chief goal of this feature, which is in a preview stage, is improving the startup of Java applications by breaking up the monolithic initialization of application state. Other goals include enabling user code to safely enjoy constant-folding optimizations previously available only to JDK code; guaranteeing that stable values are initialized at most once, even in multi-threaded programs; and decoupling the creation of stable values from their initialization, without significant performance penalties. Removal of the 32-bit x86 port involves removing both the source code and build support for this port, which was deprecated for removal in JDK 24. The cost of maintaining this port outweighs the benefits, the proposal states. Keeping parity with new features, such as the foreign function and memory API, is a major opportunity cost. Removing the 32-bit x86 port will allow OpenJDK developers to accelerate the development of new features and enhancements. Separate from the official feature list, JDK 25 also brings performance improvements to the class `String`, by allowing the `String::hashCode` function to take advantage of a compiler optimization called constant folding. Developers who use strings as keys in a static unmodifiable `Map` should see significant performance boosts, according to a May 1 article on Oracle’s Inside Java website.
07.06.2025 00:03 — 👍 0    🔁 0    💬 0    📌 0
Preview
Spring Java creator unveils AI agent framework for the JVM Embabel, an open source framework for authoring AI agentic flows on the JVM, has been launched by Spring Framework founder Rod Johnson. Johnson aims for Embabel to become the natural way to integrate generative AI into Java applications, especially those built on the Spring Framework. In a web post on May 22, Johnson described Embabel as a new programming model for authoring agentic flows on the JVM that seamlessly mix LLM-prompted interactions with code and domain models. Embabel is intended not just to play catch-up with Python agent frameworks, but surpass them. “Much of the critical business logic in the world is running on the JVM, and for good reason. Gen AI enabling it is of critical importance.” Embabel is written in Kotlin and offers a natural usage model from Java, Johnson said. But once Embabel is established, plans call for creating TypeScript and Python projects based on the Embabel model. Along with close Spring integration, Johnson cited these distinguishing features of Embabel: * Embabel introduces a planning step. The framework discovers actions and goals from application code, and plans toward the most appropriate goal given user or other system input. Planning is accomplished via a non-LLM AI algorithm that provides a deterministic and explainable approach to planning. * Embabel encourages building a rich domain model in an application, typically Kotlin data classes or Java records. This ensures that prompts are type-safe, tool-able, and survive refactoring. It also allows behavior to be added to domain objects, which can be exposed as LLM tools as well as used in code. Johnson said that while Embabel embraces the Model Context Protocol, a higher-level orchestration technology is needed. The reasons include the need for explainability, discoverability, the ability to mix models, the ability to inject guardrails at any point in a flow, the ability to manage flow execution, composability of flows at scale, and safer integration with existing systems such as databases, where it is dangerous to allow write access to LLMs, Johnson noted. “It’s early, but we have big plans,” said Johnson. “We want not just to build the best agent platform on the JVM, but to build the best agent platform, period.”
06.06.2025 23:26 — 👍 0    🔁 0    💬 0    📌 0
Preview
JavaScript innovation and the culture of programming Something surprising about software is its vibrant and enduring culture. Far from being a sidebar to engineering, how programmers collaborate and learn from each other is often the heart of the story. JavaScript is, of course, one of the best examples of that phenomenon, with a culture that is at once inclusive, challenging, and rewarding. This month, we have an example of software development culture in action with the release of Angular 20 at the Google I/O conference. But the culture of programming is everywhere, infused in the way developers work and build, and especially in the open source projects we use and contribute to. That cultural resilience is a good thing, too, because I can’t be the only one finding that the more I use AI, the more I appreciate the human element of programming—the spirit, if you will. So, here’s to continuing to evolve the culture of software development while using JavaScript in ways that empower our vital human connections. ## Top picks for JavaScript readers on InfoWorld **Putting agentic AI to work in Firebase Studio** Agentic AI is the next frontier for coding, and Google’s Firebase Studio is currently one of the most advanced platforms available. Get a first look at where Firebase Studio shines, and where it’s still a little rusty. **JavaScript promises: 4 gotchas and how to avoid them** You’ve learned the basics of JavaScript promises and how to use `async`/`await` to simplify asynchronous code. Now learn four ways promises can trick you, and how to resolve them. ****8 ways to do more with modern JavaScript** ** Mastering a language is an ongoing practice driven by equal parts necessity and curiosity. From lambdas to promises, and from paradigms to AI, these features and techniques will get your train of thought rolling. **How to gracefully migrate your JavaScript programs to TypeScript** JavaScript and TypeScript are like binary stars revolving around each other; as a developer, you benefit from understanding both. Here’s a no-nonsense, practical guide to transforming your existing JavaScript programs to TypeScript. ### JavaScript news bites * Angular v20 arrives with eyes on generative AI development * Reports of Deno’s demise ‘greatly exaggerated’ * Video recap: Bringing Svelte Summit to the whole community * Bun v1.2.15 released ## More good reads and JavaScript updates elsewhere **Wake up, Remix!** Remix is being reimagined as a full-stack framework and toolset forked from Preact. Here, the Remix team explains the thinking behind turning Remix into an all-in-one, integrated approach to web development. **Your React meta-framework feels broken, here’s why ** Redwood.js is an alternative full-stack meta-framework that aims to simplify JavaScript development by avoiding over-abstraction. Here’s the scoop on why Redwood aims to be different, directly from the framework’s designers. **Video: The 3 ways JavaScript frameworks render the DOM** Solid.js’s Ryan Carniato reviews the fundamental rendering approaches used by JavaScript web frameworks. Turns out, there are only three basic approaches.
06.06.2025 09:00 — 👍 0    🔁 0    💬 0    📌 0
Preview
Adobe adds Product Support Agent for AI-assisted troubleshooting Expanding its planned suite of AI agents, Adobe introduced the new Product Support Agent, intended to simplify troubleshooting and support case management in the Adobe Experience Platform for managing customer experiences. Announced June 4 and powered by the now-available Adobe Experience Platform Agent Orchestrator, the Product Support Agent is intended to lighten operational troubleshooting by providing in-the-moment guidance and case management within the AI Assistant conversational interface. When a user asks for help with creating a support ticket, the new Product Support Agent gathers relevant contextual data from logs, metadata, user session data, and other sources, to pre-fill the support case. The user can view and approve the case before submitting it. As part of its expansion of AI agents, Adobe has also announced the general worldwide availability of its Data Insights Agent. Built on Adobe Experience Platform Agent Orchestrator, the Data Insights Agent allows users to query data directly using natural-language questions such as “What channels drove the most conversations last week.” The agent then builds and delivers a visualization in the Analysis Workspace with Adobe Customer Journey Analysis. Adobe has also announced upcoming agents to support account qualification, data engineering, site optimization, and workflow optimization.
05.06.2025 21:41 — 👍 0    🔁 0    💬 0    📌 0
Preview
Snowflake: Latest news and insights Snowflake (NYSE:SNOW) has rapidly become a staple for data professionals and has arguably changed how cloud developers, data managers and data scientists interact with data. Its architecture is designed to decouple storage and compute, allowing organizations to scale resources independently to optimize costs and performance. For cloud developers, Snowflake’s platform is built to be scalable and secure, allowing them to build data-intensive applications without needing to manage underlying infrastructure. Data managers benefit from its data-sharing capabilities, which are designed to break down traditional data silos and enable secure, real-time collaboration across departments and with partners. Data scientists have gravitated to Snowflake’s capability to handle large, diverse datasets and its integration with machine learning tools. Snowflake is designed to rapidly prepare raw data, build, train, and deploy models directly within the platform to achieve actionable insights. Watch this page for the latest on Snowflake. ## Snowflake latest news and analysis ### Snowflake customers must choose between performance and flexibility _June 4, 2025_ : Snowflake is boosting the performance of its data warehouses and introducing a new adaptive technology to help enterprises optimize compute costs. Adaptive Warehouses, built atop Snowflake’s Adaptive Compute, is designed to lower the burden of compute resource management by maximizing efficiency through resource sizing and sharing, ### Snowflake takes aim at legacy data workloads with SnowConvert AI migration tools _June 3, 2025_ : Snowflake is hoping to win business with a new tool for migrating old workloads. SnowConvert AI is designed to help enterprises move their data, data warehouses, business intelligence (BI) reports, and code to its platform without increasing complexity. ### Snowflake launches Openflow to tackle AI-era data ingestion challenges _June 3, 2025_ : Snowflake introduced a multi-modal data ingestion service — Openflow — designed to help enterprises solve challenges around data integration and engineering in the wake of demand for generative AI and agentic AI use cases. ### Snowflake acquires Crunchy Data to counter Databricks’ Neon buy _June 3, 2025_ : Snowflake plans to buy Crunchy Data,a cloud-based PostgreSQL database provider, for an undisclosed sum. The move is an effort to offer developers an easier way to build AI-based applications by offering a PostgreSQL database in its AI Data Cloud. The deal, according to the Everest Group ,is an answer to rival Databricks’ acquisition of open source serverless Postgres company Neon. ### Snowflake’s Cortex AISQL aims to simplify unstructured data analysis _June 3, 2025_ : Snowflake is adding generative AI-powered SQL functions to help organizations analyze unstructured data with SQL. The new AISQL functions will be part of Snowflake’s Cortex, managed service inside its Data Cloud providing the building blocks for using LLMs without the need to manage complex GPU-based infrastructure. ### Snowflake announces preview of Cortex Agent APIs to power enterprise data intelligence _February 12, 2025_ : Snowflake announced the public preview of Cortex Agents, a set of APIs built on top of the Snowflake Intelligence platform, a low-code offering that was first launched in November at Build, the company’s annual developer conference.
05.06.2025 17:24 — 👍 0    🔁 0    💬 0    📌 0
Preview
Automating devops with Azure SRE Agent Modern AI tools have been around for some time now, offering a wide variety of different services. Much of what’s been delivered so far has only touched the surface of what’s possible; voice recognition and transcription tools are probably the most useful. The development of agentic AI has changed things. Instead of using AI to simply generate text, we can use a natural language user interface to use context to construct workflows and manage operations. Support for OpenAPI interfaces allows us to go from user intent to actual service calls, with newer technologies such as the Model Context Protocol (MCP) providing defined interfaces to applications. ## Building agents into workflows Agentic workflows don’t even need to be generated by humans; they can be triggered by events, providing completely automated operations that pop up as natural language in command lines and in tools like Teams. Microsoft’s Adaptive Cards, originally intended to surface elements of microwork inside Teams chats, are an ideal tool for triggering steps in a long workflow managed by an agent but putting a human inside the loop, responding to reports and triggering next steps. Using agents to handle exceptions in business processes is a logical next step in the evolution of AI applications. We can avoid many of the issues that come with chatbots, as agents are grounded in a known state and use AI tools to orchestrate responses to a closed knowledge domain. A system prompt automatically escalates to a human when unexpected events occur. ## Adding agents to site reliability engineering One domain where this approach should be successful is in automating some of the lower-level functions of site reliability engineering (SRE), such as restarting servers, rotating certificates, managing configurations, and the like. Here we have a known ground state, a working stack composed of infrastructure, platforms, and applications. Microsoft describes this as agentic devops. With modern cloud-native applications, much of that stack is encoded in configuration files, even infrastructure, using tools like Azure Resource Manager or Terraform templates, or languages like Bicep and Pulumi. At a higher level, APIs can be described using TypeSpec, with Kubernetes platforms described in YAML files. All these configuration files, often stored as build artifacts in standard repositories, give us a desired state we can build on. In fact, if we’re in a Windows Server environment we can use PowerShell’s Desired State Configuration definitions as a ground state. Once a system is operating, logs and other metrics can be collected and collated by Azure’s monitoring tools and stored in a Fabric data lake where analytics tools using Kusto Query Language can query that data and generate reports and tables that allow us to analyze what’s happening across what can be very complex, distributed systems. Together these features are the back ends for SRE dashboards, helping engineers pinpoint issues and quickly deploy fixes before they affect users. ## Azure agent tools for the rest of us With its existing devops tools, Microsoft has many of the necessary pieces to build a set of SRE agents. Its existing agent tools and expanding roster of MCP servers can be mixed with this data and these services to provide alerts and even basic remediation. So, it wasn’t surprising to hear that Azure is already using something similar internally and will shortly be launching a preview of a public SRE agent. Microsoft has a long history of taking internal tools and turning them into pieces of its public-facing platform. Much of Azure is built on top of the systems Microsoft needed to build and run its cloud applications. Announced at Build 2025, Azure SRE Agent is designed to help you manage production services using reasoning large language models (LLMs) to determine root causes and suggest fixes based on logs and other system metrics. The underlying approach is more akin to traditional machine learning tools: looking for exceptions and then comparing the current state of a system with best practices and with desired state configurations to get your system back up and running as quickly as possible—even before any users have been impacted. The aim of Azure SRE Agent is to reduce the load on site reliability engineers, administrators, and developers, allowing them to concentrate on larger tasks without being distracted from their current flow. It’s designed to run in the background, using normal operations to fine-tune the underlying model to fit applications and their supporting infrastructure. The resulting context model can be queried at any time, using natural language, much like using the Azure MCP Server in Visual Studio Code. As the system is grounded in your Azure resources, results will be based on data and logs, much like using a specific retrieval-augmented generation (RAG) AI tool but without the complexity that comes with building a vector index in real time. Instead, services like Fabric’s data agent provide an API that manages queries for you. There’s even the option to use such tools to visualize data, using markup to draw graphs and charts. Making this type of agent event-driven is important, as it can be tied to services like Azure’s Security Graph. By using current Azure security policies as a best practice, it’s able to compare current state with what it should be, informing users of issues and performing basic remediations in line with Azure recommendations. For example, it can update web servers to a new version of TLS, ensuring that your applications remain online. Events can be sourced from Azure tools like Monitor, pulling alert details to drive an automated root-cause analysis. As the agent is designed to work with known Azure data sources, it’s able to use these to detect exceptions and then determine the possible cause, reporting back its conclusions to a duty site reliability engineer. This gives the engineer not only an alert but a place to start investigations and remediations. There is even the option of handling basic fixes once they are approved by a site reliability engineer. The list of approved operations is sensibly small, including triggering scaling, restarting, and where appropriate, rolling back changes. Recording what has been discovered and what has been done is important. The root-cause analysis, the problem discovery, and any fixes will be written to the application’s GitHub as an issue so further investigations can be carried out and longer-term changes made. This is good devops practice, as it brings the developer back into the site reliability discussion, ensuring that everyone involved is informed and that devops teams can make plans to keep this and any other problem from happening again. The agent produces daily reports focused on incidents and their status, overall resource group health, a list of possible actions to improve performance and health, and suggestions for possible proactive maintenance. ## Getting started with Azure SRE Agent The Azure SRE Agent is currently a gated public preview (you need to sign up to get access). Microsoft has made much of the documentation public so you can see how it works. Working with SRE Agent appears to be relatively simple, starting with creating an agent from the Azure portal and assigning it to an account and a resource group. You’ll need to choose a region to run the agent from, currently only Sweden Central, though it can monitor resource groups in any region. For now, interacting with the agent takes place in the Azure Portal. Most site reliability engineers working with Azure will have the portal open most of the time—it’s not really the best place to have chats. Hopefully Microsoft will take advantage of Teams and Adaptive Cards to bring it closer to other parts of their ecosystem. Delivering reports as Power BI dashboards would also help the SRE Agent fit into a typical service operations center. Tools like this are an important evolution of AI and generative AI in particular. They’re not chatbots, though you can chat with them. Instead, they’re grounded in real-time data and they use reasoning approaches to extract context and meaning from data, using that context to construct a workflow based on best practices and current and desired system states. Building the agent around a human-in-the-loop model, where human approval is required before any actions are taken, may slow things down but will increase trust in the early stages of a new way of working. It’ll be interesting to see how this agent evolves, as Microsoft rolls out deeper Azure integration through its MCP servers and as languages like TypeSpec give us a way to add context to OpenAPI descriptions. Deeply grounded AI applications should go a long way to deliver on the Copilot promise, providing tools that make users’ tasks easier and don’t interrupt them. They will also show us the type of AI applications we should be building as the underlying platforms and practices mature.
05.06.2025 09:00 — 👍 0    🔁 0    💬 0    📌 0
Preview
AI is powering enterprise development, GitHub says AI is becoming increasingly important in enterprise software development, particularly with the rise of accompanying agentic models, GitHub’s Martin Woodward, vice president of developer relations, said during his talk at this week’s GitHub Galaxy online conference. He also said devops was a critical factor in AI usage. In a presentation on software development and AI, titled “The AI-Accelerated Enterprise,” Woodward stressed that AI tools are being adopted in different ways. “AI has been and can be used across your entire application pipeline to kind of accelerate teams,” Woodward said. “But what we’re seeing is that the teams who are best placed with mature devops practices, they’re currently the ones who are best-positioned to take advantage of the power of AI, having processes and technology and guardrails in place to help you ship more quickly.” Referring to GitHub Copilot, Woodward noted that AI-powered programming tools are moving beyond autocomplete capabilities that help developers more quickly iterate through their code into the next phase of AI coding assistance. “We’re seeing the rise of agentic-based methods in software development and we’re also seeing AI-native ways of building software,” he said. Developers using Visual Studio Code on GitHub now have a huge range of models available to them, Woodward said. Devops also is being refined based on agentic patterns, Woodward said. He presented a slide decreeing, “Teams will get better at devops with agents,” with the slide noting that agents help developers with tasks such as fixing bugs, targeted refactoring, doing code reviews, and performing dependency upgrades. Also presented by Woodward was a slide describing the software of the future, noting that future applications will be cloud-native, centered on customer experience, and intelligent, with AI being built into customer experiences. Leading companies already are focused on customer experience, Woodward said.
04.06.2025 22:17 — 👍 0    🔁 0    💬 0    📌 0
Preview
Snowflake customers must choose between performance and flexibility Snowflake (Nasdaq:SNOW) is boosting the performance of its standard data warehouses and introducing a new adaptive technology to help enterprises optimize compute costs — but customers will have to choose one or the other. Adaptive Warehouses, built atop Snowflake’s Adaptive Compute, will lower the burden of compute resource management by maximizing efficiency through resource sizing and sharing, while the Gen 2 standard data warehouses will double analytics performance, the company said. Robert Kramer, principal analyst at Moor Insights and Strategy, sees advantages in Snowflake’s Adaptive Warehouses. “This eliminates the need for customers to guess warehouse sizes or manually configure concurrency settings. This simplifies Snowflake management and potentially reduces costs, especially for teams without dedicated cloud administrators,” he said. The new warehouses can consolidate analytics tasks into a shared pool that automatically balances usage, and this setup reduces idle compute and adapts to shifting demands, ensuring SLAs are met without constant oversight, he said. The automated resource management capability of Adaptive Warehouses, which is still in private preview, could also enable enterprises looking to drive a variety of AI and advanced analytics use cases to experiment and deliver applications for those use cases faster. The Adaptive Compute technology underlying Adaptive Warehouses is not new, and its use here is a sign of the company’s shift towards elastic and serverless infrastructure, a strategy that hyperscalers such as AWS, Google, and Microsoft have also used to strengthen their enterprise offerings. It also helps Snowflake stay competitive with vendors like Databricks, which already support automatic scaling, Kramer said. Managed compute offerings not suited for all workloads There are some practical constraints on the use of serverless databases or data warehouses that enterprises should consider, said Matt Aslett, director of advisory firm ISG. “If an enterprise needs control over physical hardware to meet specific performance requirements, then serverless is not an appropriate option. Additionally, long-running workloads may not deliver the advertised benefits in terms of cost-savings compared to ephemeral workloads,” Aslett said. “Generally, serverless databases are best suited to development and test environments as well as lightweight applications and workloads with sporadic usage,” Aslett explained, adding that he expects Snowflake to provide customers with best practice guidelines as Adaptive Warehouses move from private preview to general availability. Snowflake’s head of core platform division Artin Avanes said switching from a standard virtual warehouse to an Adaptive Warehouse is “as simple as running an alter command with no downtime required.” Avanes said the rationale behind enabling customers to switch data warehouses is that Snowflake customers often say that consolidating workloads can be disruptive and time consuming, especially when warehouse names are hard coded into pipelines and scripts. “With Adaptive Warehouses, users can simply convert their production workloads in batches, while still maintaining existing warehouse names, policies, permissions, and chargeback reporting structure,” he said. ## Gen 2 generally available For those not ready to switch, Snowflake has also made the Gen 2 update to its virtual standard data warehouse platform generally available. Gen 2 has upgraded hardware and software to effect performance enhancements — “2.1x faster analytics”, said Avanes. Comparing Adaptive Warehouses to Gen 2, Constellation Research principal analyst Michael Ni described Gen2 as a high-performance engine and Adaptive Compute as the autopilot. “Gen2 delivers raw speed—2x faster analytics and up to 4x faster DML—but Adaptive Compute is about automation. While they’re separate today, Adaptive Compute is designed to run on the best available hardware, which likely includes Gen2,” Ni added. However, Ni said, Snowflake customers currently have to choose a specific data warehouse — either Adaptive or Gen 2 — and the two functionalities cannot be combined. “For now, customers get performance today and automation tomorrow,” he said. More Snowflake news: * Snowflake launches Openflow to tackle AI-era data ingestion challenges * Snowflake’s Cortex AISQL aims to simplify unstructured data analysis * Snowflake takes aim at legacy data workloads with SnowConvert AI migration tools * Snowflake acquires Crunchy Data for enterprise-grade PostgreSQL to counter Databricks’ Neon buy
04.06.2025 15:51 — 👍 0    🔁 0    💬 0    📌 0
Preview
Naming is easy! A guide for developers There is an old joke in programming circles: > There are two hard things in programming: cache invalidation, naming things, and off-by-one errors. The first is truly hard, the third is the joke, but the second one? That one baffles me. Naming things is easy, or at least it should be. But for reasons unknown, we make it hard. Just call it what it is or what it does. But for some reason, we developers have an aversion to doing that. Here are some thoughts about why naming is hard for developers, along with some ideas for doing it right. ## Nine reasons for bad naming 1. We assume everyone knows what we know 2. Meaning drift 3. Sheer laziness 4. Too eager to abbreviate 5. Forgetting functions are verbs 6. Inconsistency 7. Going negative 8. Prefixing 9. Blah words ### We assume everyone knows what we know This is the most common reason that we name things badly. I know that EmpNo stands for EmployeeNumber, and that EmployeeNumber is the unique ID in the database. Why wouldn’t everyone else? Well, because the next poor developer who comes along might think that the EmployeeNumber is the number assigned to the employee for logging in, and has nothing to do with unique values in the database. If EmployeeNumber is the unique ID in the database, why not just call it that? How about calling it EmployeeUniqueIDInDatabase? Sure, it’s a bit of a mouthful, but no one will ever mistake it for something else, right? And if you say to me, “Nick, that’s too much typing!” I’ll give you my standard response: Lazy is no way to go through life, my friend. Plus, these days, your IDE will do all of that typing for you. A long, clear, explanatory name is always superior to an abbreviation you think is obvious but really isn’t. ### Meaning drift Sometimes the meaning of a name can be less precise than it might be, and that meaning can drift over time. You might start out with a method called SaveReceipt that puts a copy of the receipt in the database. But over time, you may add printing to the routine, and move the actual saving to a different method, and suddenly your name is lying to you. Naming it SaveReceiptToTheDatabase in the first place might make that harder to happen. ### Sheer laziness While naming things isn’t hard, it does take a bit of thought. I guess some folks just don’t want to take the time to think about naming things. I’m not even going to talk about how silly it is to use a single letter for a variable name. The only exception I’ll quarter is using i as the variable in a loop. (But I’ll argue vehemently that Index is better.) Otherwise, give a variable a really good, full name. Sure, it may take some effort, but if you stop and ask, “What, exactly, is this thing?” and then name it based on what your answer is, you’ll have a great name. For instance, if you feel the need to do this: If (EmployeeNumber > 0) and (OrderNumber > 0) { // ... } Don’t be afraid to go the extra mile: EmployeeIsValid = EmployeeUniqueIDInDatabase > 0; ThereIsAnOrder = OrderNumber > 0; ItIsOkayToProcessTheOrder := EmployeeIsValid and ThereIsAnOrder; If ItIsOkayToProcessTheOrder { // ... } That is massively more readable, and the variable names clearly explain what they represent. It would be very hard to confuse what is happening there, and it reduces the cognitive load of the next developer, who no longer has to parse complex boolean statements. ### Too eager to abbreviate Laziness isn’t good, but neither is being in a hurry. Being in a hurry might cause us to abbreviate things when there is no need to do so. Remember, the IDE will do a lot of typing for you. You might think you’re saving .876 seconds by typing acctBlnc instead of accountBalance, but really you’re just stealing precious hours from the poor guy maintaining your code. And while we are at it, whose account balance is that? The company’s? The customer’s? Who knows? Why developers are afraid of long names is a mystery to me. Don’t abbreviate anything unless it is an industry standard like URL or HTTP. Again, just type it out. ### Forgetting functions are verbs All methods should be named as verbs and should completely describe what they do. getCustomer is good, but where are you getting the customer from? What, exactly, are you getting? getCustomerInstanceFromDatabase is better. Again, if you ask yourself, “What is this function doing?” and then just name it based on your complete answer, you’ll have more maintainable code. ### Inconsistency It’s easy to be inconsistent. For instance, if you use the word Customer to mean a person standing in front of the point-of-sale system buying something, then make sure that is what you call them everywhere in the system. Don’t use the word Client to describe them, ever. Don’t call them Buyer in some other module. Use the same term for the same thing consistently, throughout your repository. ### Going negative As I mentioned a couple weeks ago, keep names positive, particularly Booleans (if you must use them). Names like isNotValid and denyAccess become abominations. For example: if (!IsNotValid) or (!denyAccess) {   // ... } There is a reason we don’t use double negatives in the English language. You also should avoid them in your code. ### Prefixing Back in the day, Hungarian notation was all the rage. All names had a prefix that defined what they were in addition to the name. This has gone out of vogue, as it got complex. I prefer that the name be expressive enough to allow the maintainer to surmise what it is. For instance, EmployeeCount is obviously an integer, and FirstName is obviously a string. Some people like to prefix their variable names with a letter to indicate the role that a variable plays in a method—for example, ‘l’ for local variables, ‘a’ for method arguments or parameters. and so on. I frown on this kind of thing. If your methods are so big that you can’t tell at a glance what role a variable is playing, then you need to refactor. ### Blah words Another thing to avoid is using words that have no real meaning but seem important somehow. Avoid words like Helper, Handler, Service, Util, Process, Info, Data, Task, Stuff, or Object. These are “blah words,” or naming junk food—empty words that serve no purpose. What method do you write that isn’t helpful? Which ones don’t handle something? What in your app isn’t actually data? How much code do you write that doesn’t perform a task? ## Naming is easy Naming things is easy, or it should be. Like many things in life, it can all go well if you avoid doing bad things more than worrying about doing good things. Good naming dramatically reduces the cognitive load when maintaining code. By making the code clearer, it helps developers avoid mistakes and introducing bugs. The mere seconds it takes to stop and think about a name can save literally hours down the road. Coding for clarity and maintainability is always the way to go. Naming things properly, completely, and clearly is a huge part of writing good code. Besides, to paraphrase the famous saying, “Name things like the person maintaining your code is a sleep-deprived psychopath with your home address.”
04.06.2025 09:00 — 👍 0    🔁 0    💬 0    📌 0
Preview
Kotlin cozies up to Spring Framework JetBrains is deepening its collaboration with the Spring platform team, with the goal of making the Kotlin language a top choice for professional server-side work. The JetBrains-Spring partnership, announced May 22, is intended to make Kotlin a more natural and powerful choice for building Spring applications, JetBrains said. Spring is a well-established framework for developing enterprise Java applications. As part of the partnership, JetBrains is building a newer and faster version of its reflection library, kotlinx.reflect, to improve performance in scenarios relying heavily on reflection, such as serialization and dependency injection. Key areas of the collaboration include: * Providing null safety for Kotlin and Spring apps by improving Kotlin support for null safety across the framework. This will strengthen type safety in Kotlin code. * Delivering the new Bean Registration DSL (domain-specific language) to provide a foundation for better support for lambda and DSL-based bean definition. * Making Core Spring learning materials available in Kotlin. Kotlin already shines building Spring applications, JetBrains said, thanks to features like named and default parameters, which remove the need for the builder pattern and other overload-related boilerplate. Kotlin also encourages modular design through the use of extension functions and top-level functions, according to the company. The Spring team, meanwhile, has supported Kotlin features such as coroutines, Kotlin extensions, and configuration DSLs. So far, 27% of Spring developers have used Kotlin, JetBrains said.
03.06.2025 22:26 — 👍 0    🔁 0    💬 0    📌 0
Preview
Snowflake acquires Crunchy Data for enterprise-grade PostgreSQL to counter Databricks’ Neon buy Snowflake has announced its intent to acquire US-based cloud-based PostgreSQL database provider Crunchy Data for an undisclosed sum, in an effort to offer developers an easier way to build AI-based applications by offering a PostgreSQL database, to be dubbed Snowflake Postgres, in its AI Data Cloud. The timing of the deal, according to Ishi Thakur, analyst at Everest Group, makes it abundantly clear that this is Snowflake’s answer to rival Databricks’ acquisition of open source serverless Postgres company Neon to integrate PostgreSQL architecture into its Data Intelligence Platform. Historically, both of the data warehouse providers have been embroiled in stiff competition for a larger share of the data analytics and AI market, and this has led to the vendors announcing new and similar offerings in close proximity. The biggest example of the rivalry is the companies’ adoption of different open-source table formats for managing large-scale data in data lakes and lakehouses, Snowflake choosing Apache Iceberg tables and Databricks’ adoption of Delta Live tables. The two vendors had also raced to open source their closed-sourced unified governance catalogs, Polaris and Unity. However, Constellation Research’s principal analyst Michael Ni pointed out that the Crunchy Data and Neon acquisitions are just another round in the Snowflake-Databricks chess match that has transcended the big data and analytics space. “This isn’t about big data analytics anymore — it’s about becoming the AI-native data foundation unifying analytics, operational storage, and machine learning,” Ni said. However, Moor Insights and Strategy principal analyst Robert Kramer pointed out, though both are trying to add PostgreSQL to their stacks, their strategies differ. “Snowflake’s focus is on enterprise readiness, integration, and governance targeting large enterprises, and Databricks is prioritizing a serverless, cloud-native PostgreSQL optimized for AI agent development and low-latency transactions, appealing to developers and startups,” Kramer said. ## Creating a data intelligence platform Snowflake’s decision to offer PostgreSQL inside the AI Data Cloud, according to Bradley Shimmin, lead of the data and analytics practice at The Futurum Group, is about further blending operational and analytical workloads within the same platform, something that most data vendors are trying to do, and are calling a data intelligence platform. These kinds of acquisition open the broader data and application development tech landscape and market segment to vendors, Shimmin said. They are being driven by the trend in enterprises to increasingly rethink their application development practices to incorporate not just generative AI, but to also bring in data more freely to support AI-driven use cases, Shimmin added. The decision to offer its own version of Postgres, despite the popularity of the open source version among developers for its flexibility, lower cost, and AI features, according to Kramer, is rooted in Snowflake’s strategy to alleviate issues such as lack of security, compliance, and scalability in the open source version. Snowflake Postgres will help enterprises build AI applications while keeping their data safe and reliable, he added. Constellation Research’s Ni expects Snowflake Postgres to “go down well” with the Postgres community, as it does not seek to create a fork of PostgreSQL, but instead carry on the work already done by Crunchy. ## Why did Snowflake choose Crunchy Data? Snowflake, which had a choice of companies to acquire to integrate PostgreSQL into its offerings, choose Crunchy Data mainly because of the community’s trust in the company and its offerings, analysts said. “Crunchy Data wasn’t just a tech buy—it was a trust buy. Snowflake wanted battle-tested Postgres, not a startup experiment,” said Ni. Moor Insights and Strategy’s Kramer seconded Ni, and said that Crunchy Data is known for its strong security, scalability, and compliance features, essential for mission-critical applications in regulated industries. “The company has a proven track record with large enterprises and government agencies, offers developer-friendly tools, and provides performance metrics and connection pooling right out of the box. These strengths align with Snowflake’s goal of providing a PostgreSQL solution that meets enterprise customer needs,” Kramer added. Crunchy Data’s experience and success with regulated industries also aligns with Snowflake’s path to increase its focus on vertical AI offerings, and should help it win workloads in government, finance, and healthcare industries, Ni said. Snowflake Postgres, the offering planned after the close of the Crunchy Data acquisition, is expected to be in private preview soon, Snowflake said. It did not offer any timeline for its general availability. The cloud-based data warehouse vendor has said it will support existing Crunchy Data customers, as well as make what it called “strong commitments” to the Postgres community.
03.06.2025 20:17 — 👍 0    🔁 0    💬 0    📌 0
Preview
Snowflake takes aim at legacy data workloads with SnowConvert AI migration tools Snowflake is hoping to win business with a new tool for migrating old workloads, SnowConvert AI, that it claims can help enterprises move their data, data warehouses, business intelligence (BI) reports, and code to its platform without increasing complexity. Powered by Snowflake’s Cortex AI Agents, the suite can halve the time taken to migrate workloads, the company said. SnowConvertAI includes three tools: an AI-powered migration assistant, AI-powered code verification, and AI-powered data validation. While the AI-powered migration assistant will help enterprises move data to Snowflake from other data warehouses such as Oracle, Teradata, and Google BigQuery or from other cloud data platforms, the other two tools will help in automatically converting and validating code, ETL tools, and BI reports. Marlanna Bozicevich, research analyst at IDC, said, “By automating code conversion from legacy systems, SnowConvert significantly reduces the time, cost, and risk associated with migrating to Snowflake.” Typically, enterprises could encounter challenges such as schema mismatches, code incompatibilities, data corruption, and workflow disruptions during data migration. SnowConvert AI’s code verification tool reduces manual review time by providing detailed explanations and remediation suggestions for conversion errors directly within development environments, Bozicevich said. The fact that SnowCovert AI is free will attract enterprises, as high costs in other areas have been a major pain point for Snowflake customers, she said. The Futurum Group’s lead for data and analytics practice, Bradley Shimmin, said the automated data validation tool will drive value for enterprises as they typically have to test that the logic, transformations, and operations are correctly translated to the new platform’s syntax and semantics manually. But enterprises may be drawn to other vendors offering their own data migration services, including Informatica, which was recently acquired by Salesforce, or cloud services providers, such as AWS and Microsoft. However, the most comparable to SnowConvert AI, according to Bozicevich, is Databtricks’ BladeBridge-driven tool, which offers AI-powered insights into the scope of conversion, configurable code transpiling, LLM-powered conversion, and easy validation of migrated systems. Constellation Research principal analyst Michael Ni described the launch of SnowConvert AI as a “land-grab” strategy for Snowflake. “Snowflake isn’t just courting cloud budgets. It’s going after prospects and their workloads who feel stranded on older systems. Free SnowConvert AI weaponizes migration as a go-to-market strategy and makes modernization too easy to ignore,” Ni added. SnowConvert AI’s AI-powered code verification and data validation tool are in preview. The company expects to release the data migration assistant soon, it said.
03.06.2025 18:30 — 👍 0    🔁 0    💬 0    📌 0
Preview
C# 14 introduces file-based apps Taking a lesson from scripting languages such as Python and JavaScript, Microsoft has introduced a file-based apps capability for the C# language, which is intended to streamline C# development. Introduced in .NET 10 Preview 4, the new feature allows developers to run a stand-alone C# (.cs) file directly with the command, `dotnet run app.cs`. Developers no longer need to create a project file or scaffold an entire application to test a test snippet, run a quick script, or experiment with an idea, wrote Damian Edwards, principal architect at Microsoft, in a May 28 blog post announcing the feature. Previously, running C# code using the dotnet CLI has required a project structure that included a .csproj file. Developers can get started with the feature by downloading .NET 10 Preview 4. File-based apps lower the entry barrier to trying out C# and make the language a more-attractive choice for learning, prototyping, and automation scenarios, Edwards said. Developers get a quick start while no project file is required, there is “first-class” CLI integration, and the capability scales to real applications. There is no separate dialect or runtime; when a script grows up, it can evolve into a full-fledged project using the same language, syntax, and tools. With .NET 10 Preview 4, file-based apps also support a set of file-level directives to declare packages, SDKs, and properties (which are stored in project files for project apps) without leaving a .cs file. Microsoft with `dotnet run app.cs` believes it is making C# more approachable while preserving the power and depth of the .NET ecosystem. Upcoming .NET previews will aim to improve the experience of working with file-based apps in Visual Studio Code, with enhanced IntelliSense for new file-based directives, improved performance, and debugging support, Edwards said. For the command line, Microsoft is looking into support for file-based apps with multiple files and ways to make running file-based apps faster. Microsoft asks developers to try out the capability and send feedback to GitHub.
03.06.2025 16:29 — 👍 0    🔁 0    💬 0    📌 0
Preview
Snowflake’s Cortex AISQL aims to simplify unstructured data analysis Snowflake is adding generative AI-powered SQL functions to help data analysts and their organizations analyze unstructured data with SQL. These new AISQL functions will be part of Snowflake’s Cortex, a fully-managed service inside its Data Cloud providing the building blocks for using LLMs without the need to manage complex GPU-based infrastructure. It already includes serverless functions that can be called from SQL or Python to analyze data or build AI-based applications. AISQL builds on these serverless functions to enable analysis of unstructured data, improve query performance and eliminate the need for data analysts to rely on data engineers and developers, said Christian Kleinerman, EVP of product at Snowflake. The ability to query unstructured data is important for enterprises looking for more accurate business insights and faster decision-making. The ability to access unstructured data directly with SQL syntax is not a new capability for Snowflake but these generative AI-powered functions makes the task easier, said Constellation Research principal analyst Michael Ni. Before the introduction of AISQL, enterprises could use various ways to access unstructured data via SQL — using Document AI to load data in documents, using the TEXT column or creating a table with a FILE column and using SQL to run queries against it, although with some limitations. Google’s BigQuery ML also allows enterprises to use SQL to write queries on the results of machine learning models prepared on unstructured data No more waiting for data engineers But more importantly, Ni said, AISQL could eliminate the need for data analysts to wait for data engineers or scientists. “By embedding generative AI into familiar SQL syntax, Snowflake enables data analysts to execute tasks like sentiment analysis, image classification, and document parsing without writing Python or managing ML pipelines — operationalizing AI at the query layer, not just in the lab,” he said. Another benefit of AISQL, according to Bradley Shimmin, lead of the data and analytics practice at The Futurum Group, is how it can help make Snowflake a unified query engine for enterprises to analyze all types of data. Snowflake is not the only data warehousing software provider looking to merge unstructured data and structured data for analytics, Shimmin said: other data warehouse vendors such as Databricks, Google, and Oracle have either already introduced a way to do it or are developing something. But they need to do more in the analytics space to drive value for enterprises, especially with SQL, perhaps bringing in retrieval augmented generation (RAG) methodologies or increasing the accuracy and quality of generated SQL statements, he said. IBM is one vendor doing more in the SQL field, Shimmin said: It recently introduced an update with watsonx.data where the company enhances unstructured data sources destined for RAG pipelines by adding query-able structured data. “Users can then blend SQL and semantic search to optimize data access and accuracy,” he said. Cortex AISQL uses large language models (LLMs) from Anthropic, Meta, Mistral, and OpenAI among others, to generate SQL functions. On the performance front, Snowflake claims it can reduce query response time by 30-70% depending on datasets and also save up to 60% of cost when filtering or joining data. Cortex AISQL is currently in public preview.
03.06.2025 15:55 — 👍 0    🔁 0    💬 0    📌 0
Preview
Snowflake launches Openflow to tackle AI-era data ingestion challenges Snowflake (Nasdaq:SNOW) has introduced a new multi-modal data ingestion service — Openflow — designed to help enterprises solve challenges around data integration and engineering in the wake of demand for generative AI and agentic AI use cases. Ingestion of unstructured data, such as audio and images, of course, is critical to any advanced analytics or AI use case as it complements structured data to produce more context and insights for large language models. To that extent, Openflow drives value for Snowflake and its customers as it supports batch, streaming, and change data capture (CDC) pipelines from both structured and unstructured sources, according to Marlanna Bozicevich, research analyst at IDC. “When combined with Snowpipe Streaming, file-based ingest, and third-party connector support, Openflow also provides a scalable ‘data-in-motion’ experience across any data system,” Bozicevich said. The research analyst also expects Openflow’s data streaming ingestion capabilities to be handy for enterprises as real-time processing is set to become more crucial with the proliferation of agentic AI. “Data integration and data engineering continue to be the biggest challenges in AI and analytics initiatives,” said David Menninger, Executive Director of software research at ISG. According to Menninger, to build an accurate generative AI-driven application or agentic application quickly, enterprises need to gather all their data — both structured and unstructured, transform and harmonize it. It is even better if this entire process can be automated while offering observability and governance. Snowflake’s EVP of product, Christian Kleinerman, pointed out that Openflow does all the above without much intervention as it is a managed service — unlike the existing Snowflake connectors which have to be maintained by enterprises for data ingestion. ## Support for unstructured data ingestion So far, Snowflake lagged behind other data platform vendors in data integration capabilities, especially being largely incapable of moving and processing unstructured data as it relied mostly on SQL processing and partners, Menninger pointed out. Another advantage for enterprises is the reduction of cost, complexity, and maintenance overhead of using data ingestion tools, according to Chris Deaner, managing director of the technology and experience practice at consulting firm West Monroe. Previously, when Snowflake had limited native ingestion capabilities, enterprises had to add tools like Fivetran or Matillion to their data engineering processes, Deaner said. ## Openflow’s origins and how it works Openflow is based on open source Apache NiFi — a dataflow system based on the concepts of Flow-based programming aimed at securely automating event streams, and generative AI data pipelines and distribution. To integrate NiFi into its product stack, Snowflake last year acquired Datavolo — a company founded by NiFi co-creators that offered data ingestion based on open-source technology. Openflow, which gets its extensibility and observability features from NiFi, works by ingesting, transforming, and persisting data to Snowflake tables, from where it can be used for AI and analytics. However, unlike most data ingestion services or tools, Openflow’s data transformation process includes semantic chunking and these chunks can be later used for retrieval by AI-based applications or models, the company said. To accelerate the data transformation phase, Openflow uses Arctic large language models (LLMs) for steps, such as summarization of chunks and generation of descriptions of images within documents, it added. The service also takes note of any metadata changes, especially authorization metadata, at source and persists them in Snowflake. Openflow faces competition from Databricks’ Lakeflow, which also has the capability to ingest, transform, and integrate data, including unstructured and streaming data. Lakeflow, which connects to Databricks’ Data Intelligence platform, also gets governance capabilities via the data analytics platform provider’s Unity Catalog, said Bradley Shimmin, lead for the data and analytics practice at The Futurum Group. ## Ability to build customer connectors Although Openflow is a managed service, enterprises and data professionals will be able to build their own customer connectors within the service, according to Snowflake’s Kleinerman. “Within this managed service, developers and data engineers can use hundreds of first-party Openflow processors (NiFi building blocks) to build custom connectors in minutes,” Kleinerman said, adding that developers can also use the Apache NiFi SDK to build custom processors and deploy them in Openflow. Snowflake is also partnering with major vendors, such as Salesforce, ServiceNow, Oracle, Microsoft, Adobe, Box, and Zendesk, for accelerating data ingestion via Openflow. These partnerships, according to Shimmin, add a level of enterprise-grade assurance for customers that data is going to move smoothly and at scale between two systems. ## Availability and pricing Enterprises have the options of running Openflow inside their Snowflake virtual private cloud (VPC) via Snowpark Container Services or a VPC supported by AWS, Azure, and Google Cloud. “The option to choose a VPC supported by a hyperscaler will offer enterprise customers flexibility and choice over where their integration pipelines are deployed and where the runtimes are,” said Saptarshi Mukherjee, director of product management at Snowflake. “It also enables greater customizations for private networking topologies, and allows customers to leverage their existing cloud provider pricing, while pre-processing data locally to adhere to specific data privacy regulations,” Mukherjee added. Currently, Openflow implementation via Snowpark Container Services, Azure, and Google Cloud is in private preview. However, the ability to implement on a VPC via AWS has been made generally available. In deployments where a hyperscaler is involved, enterprises will pay for the compute and infrastructure to the hyperscaler and Snowflake will levy charges for data ingestion and telemetry.
03.06.2025 13:00 — 👍 0    🔁 0    💬 0    📌 0