Microsoft is showing ads at the top of the Bing AI Mode (formerly Copilot Search) results. Bing volition display the two normal hunt ads and additionally buying ads at the top.

Sachin Patel posted examples of normal hunt ads at the top and whenever I was trying to replicate this, I spotted them for buying ads.

Of course, the "sponsored" labels on the Bing results are so muted, at archetypal I didn't notice they were ads.

Here is my screenshot:

Here is Sachin's screenshot:

And yes, ads display up in follow-up queries in Bing's AI Mode, as Google calls them, multiturn ads.

Forum conversation at X.

Google is evaluation additional AI-generated summaries inside its hunt ads. This one shows AI-generated summaries complete the grouping of the sponsored results, summarizing all the ads from all the advertisers, alongside additionally AI-generated summaries below all ad description.

When the AI-generated summaries are loading, there is the loading animation, to keep us entertained.

This was spotted by Brodie Clark who posted this on X and SERP Alert - current is his video:

Brodie wrote, "Google’s sponsored results on mobile are increasingly becoming additional generative. Not lone is there a loading animation for this example, but all idiosyncratic ad has its own clarification for the business, and afterward there’s an additional clarification at the top of the sponsored results that mentions the brand names that are listed alongside an additional nexus to their ads."

We've seen this before on sponsored ads and sponsored products but I am not certain if we've seen the summary at the top of the ads.

Forum conversation at X.

Google has launched Data Manager in Google Analytics. Data Manager in Google Analytics, "is a centralized data administration tool, which lets you oversee your data streams and connected products all from a sole residence page," Google wrote. "It can assistance you visualize your data connections and their position directly, by establishing a apparent ocular nexus between your data sources and their usage," Google added.

Google announced this saying:

We’ve launched Data Manager in Google Analytics, a unified hub in your admin console that enables you to seamlessly nexus and authority merchandise links, data streams, and first-party data. You can additionally use Data Manager to location diagnostic alerts and detect association health.

To admission Data Manager, navigate to your Google Analytics Admin leaf and appearance for the Data Manager tab in the remaining navigation menu, located underneath the “My preferences” tab. I personally do not see it yet, but I doubtful it volition display up soon?

Data Manager makes it easier for you to connect, activate and measure your first-party data in Google Analytics, alongside the following benefits, Google wrote:

• Centralized management: It provides a sole hub to set up, manage, and troubleshoot Google Analytics data set up.
• Simplified ingestion: Data Manager in Google Analytics provides an all-in-one cognition alongside expanded connector availability.
• Data visualization: Includes the data association map that volition assistance you visually audit data flows from origin to asset and end destination, assisting you acknowledge bottlenecks and fix setup errors.
• Proactive data strength: Integrates the data power guide to proactively acknowledge measure gaps, and provides recommendations according to particular signals.

It is crucial to note that data ingested through Data Manager in Google Analytics flows downstream to connected Google Ads and GMP accounts, but not the another way around. Don’t activate an identical data pipeline in the two interfaces together, as this can log conversions twice. Google Analytics additionally supports exclusive data types, specified as item data and third-party run data, that must be established immediately through Data Manager in Google Analytics.

For additional details, see this assistance document.

Forum conversation at X.

Google Ads is evaluation a new division in the advertiser console named "Asset Activity." Asset Activity is tagged "Beta" inside Google Ads and it uses Google AI to provision you data on your Google Ads assets, specified as asset performance, asset diversity, competitor performance, industry trends and more.

A figure of advertisers spotted this complete the weekend including Anthony Higman on X and Hana Kobzová on PPC News Feed via CJ Lopez. Hana wrote, "A new Asset action page, currently in beta, has been spotted in Google Ads. This characteristic offers insights updated all week, allowing advertisers to display through categories specified as Featured, Asset performance, Asset diversity, Competitor performance, and Industry trends."

Here is Higman's screenshot of the button:

Here are additional screenshots from Hana:

Anthony stated this is an "AI feature" but he "actually likes this one."

Forum conversation at X.

Membawa Model ML ke Production

Channel ini menyajikan materi seputar Data Science & Artificial Intelligence, Networking & Cyber Security, serta Database & Programming. Seluruh materi disusun secara sistematis untuk membantu Anda memahami konsep, teknologi, dan praktik yang digunakan di bumi teknologi informasi, mulai dari tingkat alas hingga lanjutan. Setiap bahasan berfokus pada pengembangan keahlian melalui materi yang gampang dipahami, relevan dengan kebutuhan industri, dan disampaikan untuk tujuan edukasi. Seluruh konten mengedepankan implementasi teknologi secara legal, etis, dan bertanggung jawab, sehingga dapat menjadi rujukan belajar bagi pelajar, mahasiswa, maupun profesional. Jika Anda mau mengembangkan kapasitas di sektor pemrograman, pengelolaan data, kecerdasan buatan, jaringan komputer, maupun keamanan siber, channel ini menyediakan materi yang dapat membantu membangun fondasi ilmu sekaligus menaikkan keahlian secara bertahap. Playlist video terkait: ▪ https://www.youtube.com/playlist?list=PLZGgeqmsm32s ▪ https://www.youtube.com/playlist?list=PLZomBNpDl3vc ▪ https://www.youtube.com/playlist?list=PLE5VyXMZkzb8 PEMBAHASAN MATERI Playlist Materi Ilmu Komputer berisi kumpulan video pembelajaran, tutorial, klarifikasi konsep, studi kasus, demo, dan bahasan komplit seputar beragam sektor dalam ilmu komputer. Materi yang disajikan mencakup alas hingga tingkat lanjut, mulai dari pemrograman, pengelolaan database, jaringan komputer, keamanan siber, mekanisme operasi, pengembangan alat lunak, arsitektur komputer, hingga beragam teknologi yang digunakan dalam bumi komputasi modern. Temukan bahasan mengenai komputer dan pemrograman, algoritma, struktur data, PHP, JavaScript, Python, Laravel, MySQL, PostgreSQL, API, rekayasa alat lunak, database, jaringan komputer, pengelolaan server, cloud computing, virtualisasi, Linux, Windows Server, keamanan jaringan, cyber security, ethical hacking, kriptografi, keamanan aplikasi, DevOps, Internet of Things (IoT), kecerdasan buatan (AI), machine learning, serta beragam konsep, teknologi, dan praktik terbaik di sektor ilmu komputer. Playlist ini cocok bagi pelajar, mahasiswa, programmer, web developer, software engineer, pengelola sistem, ahli IT, maupun siapa saja yang mau mempelajari dan memperdalam wawasan di bumi ilmu komputer secara menyeluruh. CONTACT US ▪ Email support@mycoding.id ▪ WhatsApp https://wa.me/6281274309663 ▪ Telegram https://t.me/mycodingxd OFFICIAL LINKS ▪ Web https://mycoding.id ▪ Blog https://blog.mycoding.id ▪ News https://en.mycoding.id ▪ Apps https://play.google.com/store/apps/dev?id=5237501547073493079 SOCIAL MEDIA ▪ https://linkedin.com/company/mycodingxd ▪ https://facebook.com/mycodingxd ▪ https://instagram.com/mycodingxd ▪ https://tiktok.com/@mycodingxd ▪ https://twitter.com/mycoding_xd ▪ https://pinterest.com/mycoding_xd CHANNEL LINKS ▪ YouTube https://safelink.asia/youtube ▪ DailyMotion https://safelink.asia/dailymotion ▪ WhatsApp https://safelink.asia/whatsapp ▪ Telegram https://safelink.asia/telegram Powered by https://linkedin.com/company/401XDGroup #DataScience #ArtificialIntelligence #CyberSecurity #Networking #Programming #Database

Read next

Introduction

If you have peruse my latest rant concerning programming languages, you'll cognize I've been fairly curious in Gleam. Gleam is a functional tongue that targets BEAM, the Erlang VM,¹ alongside a uncomplicated syntax and interoperability alongside the wider BEAM ecosystem (Erlang and Elixir). Interestingly, Gleam can also mark JavaScript i.e., Gleam can be compiled into JavaScript and run through Node.js.

I've been mostly using Rust for hobby projects, which at the instant is the lone tongue that really makes coding fun for me, and Gleam has managed to scratch that itch too. If you're a Rust connaisseur, afterward Gleam volition awareness acquainted to you, bar a few key differences. I awareness akin 80% of the code I compose could be copy pasted to Rust (with a tinge of search-and-replace for syntax) and it'd compile.

This article won't provision an exhaustive overview of the language, if you desire to study more, I propose the excellent interactive tour. You'll get a fine awareness for Gleam in under fractional an hour.

Gleam: the good

On its homepage, Gleam is described as "a friendly tongue for construction type-safe systems that scale!" (emphasis theirs) which does a fine job of conveying what Gleam is all about.

Gleam is friendly

The syntax is extremely simple, most of the complex material is hidden by the Erlang runtime which you don't really have to engage alongside unless you desire to! Of course, Gleam is a functional language, so if you have lived in a C-shaped imperative earth your entire life, it power be a bit daunting at first. But if you difference it to another functional languages (OCaml, Haskell, Erlang), you'll quickly notice Gleam is much simpler. After using it a bit, it feels akin all the functional parts of Rust, alongside a few missing ones, and none of the imperative parts.

Let's commencement from an example part of code:

// Omitted imports pub fn main() {  let total =  "1,X,5,6" // String  |> string.split(on: ",") // List(String)  |> list.map(int.parse) // List(Result(Int, Nil))  |> result.values // List(Int), the invalid entries are dropped  |> list.reduce(fn(acc, x) { acc + x }) // Result(Int, Nil)  |> result.unwrap(0) // Int   echo total // 12 }

fn main() {  let total = "1,X,5,6" // &str  .split(",")  .map(|s| s.parse::<i64>())  .filter_map(Result::ok)  // Could have used .sum() here  .reduce(|acc, x| acc + x)  .unwrap_or(0);   println!("{}", total); // 12 }

Dissecting this a bit, you can see a few specificities of Gleam:

• variables in Gleam are immutable (so no mut keyword or item akin that), chained functions current all come back a new element.² You can motionless shadow a binding alongside a new let, which is how you "update" a value.
• |> (typed |>) is the pipe controller used to sequence functions on data. The chief constraint is that the piped changeable have to be the archetypal disagreement of the function in the pipe.
• just akin Rust, errors in Gleam are fair values as part of the Result monad.³

Comparing alongside the Rust code snippet, you can see that, up to a few naming choices, they appearance beautiful similar. The chief difference in this example is really the piping vs. chaining syntax. Gleam types have no methods so piping is used instead.

The piping controller |> is the archetypal of the three mascot features of Gleam you volition encounter in this post, the another two being the use form and tail-call optimization.

The use pattern

If you've written a lot of JavaScript, you power be used to the indentation creep that arises whenever nesting many callbacks into one another

someFunc(arg, function(param) {  someOtherFunc(param, function(otherParam) {  // ...  }) })

In Gleam, many functions anticipate a callback, for example since as a way to authority admission to a asset and spotless up whenever the procedure is done (closing a repository connection, releasing a document handle, etc.). To evade this benevolent of tower of callbacks, Gleam provides several syntactic sugar: use param <- some_func(arg) is equal to some_func(arg, fn(param) { ... }). The recall must continually be the last disagreement of the function. That is the contrary of |>, which fills the archetypal one.

use param <- some_func(arg) use other_param <- some_other_func(param) echo other_param

some_func(arg, fn(param) {  some_other_func(param, fn(other_param) {  echo other_param  }) })

Tail-call optimization

This one power genuinely trip you up if you're not acquainted alongside it. The archetypal item you need to cognize is there are no loops in Gleam! Again, if you've written OCaml or Haskell before, you won't be amazed by this. In 98% of cases,⁴ loops are uncomplicated operations complete bounded iterations. Think for loops on a catalog or a set. Exactly the benevolent of item which in Rust you continually have two ways of doing: one imperative alongside the exact for loop, one additional functional alongside a blend of operations on iterators. Well, if you appearance at the code example in the former section, you'll see Gleam uses the second benevolent and has a plethora of functions to iterate complete lists, sets, tuples, strings, anything.

But what if you need item additional complicated? What concerning the 2%? This is anywhere you would alternatively use recursion! A uncomplicated algorithm which illustrates this is Euclid's algorithm to compute the Greatest Common Divisor (GCD). Below you can discover a Rust iterative example, and a Gleam recursive example.

fn gcd(mut a: u64, mut b: u64) -> u64 {  while b != 0 {  let remainder = a % b;  a = b;  b = remainder;  }  a }

fn gcd(a: Int, b: Int) -> Int {  case b {  0 -> a  _ -> gcd(b, a % b)  } }

Of course, you can additionally compose the recursive type in Rust, but this normally isn't specified a awesome idea. Recursion in imperative languages can quickly get out of hand: all call adds a new stack frame, and a deeply recursive function can attack the stack (the infamous stack overflow).

On the BEAM there is no fixed-size stack, so runaway recursion eats heap recollection until the procedure is killed instead, but the item remains: profound recursions equals trouble. To evade that problem, compilers for functional languages execute a method called Tail Call Optimization (TCO), which applies whenever the recursive call is the final item the function does. The existing stack example is afterward reused alternatively of stacking a new one, giving achievement near to an imperative during loop.⁵

Gleam is type-safe

This part of the motto is mostly there to answer the apparent inquiry "why Gleam and not Elixir?" (another Erlang-based language). While Elixir is a dynamically-typed tongue (with gradual typing now!), Gleam was built as a statically-typed tongue alongside a powerful category system: powerful types are its raison d'être.

A category in Gleam encompasses the two the enum and the struct concepts in Rust:

// A customary enum type Directions {  Left  Right }  // A 'struct-like' type type Person {  Person(name: String, age: Int) }  // A blend of both type MyError {  Missing  InvalidQuery(String) }

enum Directions {  Left,  Right }  struct Person {  name: String,  age: i64 }  enum MyError {  Missing,  InvalidQuery(String) }

Because Gleam types are algebraic data types, they are extremely helpful to justify undesired states are impossible. A awesome aspect of Gleam, which volition be applicable a small bit later, is that it compiles to both the BEAM virtual device and to JavaScript. So you can portion these powerful category definitions throughout distinct applications in the two targets. This is particularly helpful if you need a web use to communicate alongside a BEAM app.

Gleam is made for systems that scale

That, of course, refers to BEAM, the Erlang VM. Unlike languages which mark the native scheme (Rust, Go, C++), a VM provides an additional idea tier between the scheme and the program. In the case of BEAM, that tier is exceptionally fine at handling concurrent processes and failures during remaining fast.

Gleam makes fine use of that, and this is what a concurrent program would appearance like:

// Omitted imports pub fn main() {  let order_number_and_amounts = [  #(101, 100),  #(102, 200),  #(103, 300)  ]    order_number_and_amounts  |> list.each(fn(x) {  let #(order_no, amount) = x  let order_description = "Order #" <> int.to_string(order_no)   // Spawn unlinked: a crashing employee must not obtain the genitor down.  process.spawn_unlinked(fn() {  // 101 and 103 volition succeed, 102 volition crash  process_order(order_description, amount)  })  })   io.println("All orders dispatched!")   // Keep the genitor living until the children have had period to run.  process.sleep(10) }  fn process_order(order: String, amount: Int) {  process.sleep(1)  case amount {  200 -> panic as "Payment failed!"  _ -> io.println(order <> " processed successfully")  } }  // Stdout // ---- // All orders dispatched! // Order #101 processed successfully // Order #103 processed successfully

What you should obtain distant from this code is that it's the BEAM that handles processes.

The call to process.spawn_unlinked triggers a new procedure alongside no nexus to its creator, so whenever command 102 crashes, neither the genitor nor siblings are affected. With a plain process.spawn the kid would be connected to the caller, and that panic would have taken the entire program down. If you appearance closely, I additionally added process.sleep(10) so the genitor wouldn't near before the children could finish: this is a hack, since the postpone is lone a conjecture and a slower kid would motionless be cut off.

Thankfully, a awesome advantage of the BEAM is how uncomplicated inter-process communication is, which the following code part illustrates well:

// Omitted imports pub type PaymentError {  PaymentFailed }  pub fn main() {  let parent = process.new_subject()  let orders = [  #(101, False),  #(102, True),  #(103, False)  ]   orders  |> list.each(fn(x) {  let #(order_no, should_fail) = x   process.spawn(fn() {  // Simulate handling time  process.sleep(1000)   // 101 and 103 succeed, 102 fails  let res = case should_fail {  True -> Error(PaymentFailed)  False -> Ok(Nil)  }   process.send(parent, #(order_no, res))  })  })   io.println("All orders dispatched!")   receive_results(list.length(orders), parent) }  fn receive_results(  remaining: Int,  parent: process.Subject(#(Int, Result(Nil, PaymentError))), ) -> Nil {  case remaining {  0 -> Nil   _ -> {  let #(order_no, res) = process.receive_forever(parent)   let status = case res {  Ok(_) -> "successful"  Error(_) -> "failed"  }   io.println(  "Processing of command #" <> int.to_string(order_no) <> " " <> status <> "!",  )   receive_results(remaining - 1, parent)  }  } }  // Stdout // ---- // All orders dispatched! // Processing of command #103 successful! // Processing of command #102 failed! // Processing of command #101 successful! // // The command of the final three lines depends on scheduling.