Laxman Vijay

twitter

facebook

instagram

linkedin

Your privacy is important to us. We promise not to send you spam!

Get inspired from our coverage of the latest trends and breakthroughs in the world of gaming and AI.

Learn the newest gaming tech updates with our weekly newsletter


Bard is Google’s version of conversational AI similar to ChatGPT which has taken the internet by storm over the past few months. This is due to the nature of human like conversational abilities by these AI systems, more and more people finding it using for a variety of tasks.

When it comes to conversational AI, Google is undisputed given the amount of research and development they have done over the years in this field. Bard is the next addition in their lineup. Although given the timing, Bard is simply recognised as a competitor to ChatGPT rather than a flagship product from Google.

Bard is based on the Language Model for Dialogue Application or LaMDA which was released 2 years also by Google. 

“Bard seeks to combine the breadth of the world’s knowledge with the power, intelligence and creativity of our large language models. It draws on information from the web to provide fresh, high-quality responses” according to the [announcement blog](https://blog.google/technology/ai/bard-google-ai-search-updates/) from Google.

This new product adds to Google’s portfolio of AI models including LaMDA, PaLM, Imagen and MusicLM. All these provides more tools to enhance generational AI and impacting the creativity space. 

As of now, there is no demo version of Bard similar to how [ChatGPT has one.](http://chat.openai.com) However, Google says, these new features will be integrated into Google search soon. 

Also, Google plans to release developer APIs from next month starting with Language API powered by LaMDA and followed by other models soon.

Google introduces Bard which is a conversational AI similar to ChatGPT.

Google introduces Bard, Its answer to ChatGPT


[Vercel](https://vercel.com) has been continuously updating and innovating their product lineups. From introducing a [scheduler last month](https://vercel.com/guides/how-to-setup-cron-jobs-on-vercel) to introducing [Next 13.2](https://nextjs.org/blog/next-13-2) - the latest stable version of Next.js, they are on a roll. And now they have announced the latest interesting update on one of their products.

Turborepo, the build system from Vercel is migrating from [Go](https://go.dev/) to [Rust](https://www.rust-lang.org/) incrementally. Although Go is still a integral part of the tool, it is slowly migrating away from it. One of the most important aspects of Turborepo is the support for [monorepos](https://monorepo.tools/).

Turborepo improves development speeds by offering multiple features like incremental builds, parallel execution and remote caching.

Turborepo is inspired from [esbuild](https://esbuild.github.io/), the awesome build tool for javascript written in Go. Naturally Vercel chose Go as their language for Turborepo.

Language migration is a demanding task. There's *a lot* to consider and the decision shouldn't be taken lightly. But instead of simply comparing the pros, cons and other aspects of a language (those doesn’t matter in a large scale most of the time), it is important to consider certain design choices and the scenarios the language is envisioned to be used for.

Go's strength is network computing in data centers and it **excels** at this task, powering these workloads at the world's largest scales. The goroutine-per-request model, Context API, and the standard library inclusion of server infrastructure is testament to this community focus. Go is also particularly simple in its syntax. Although, sometimes the syntax can be quite limiting and weird, it works most of the time.

The Turborepo team points out the same as their reason for the switch: “Additionally, Go favors simplicity over expressiveness. A side effect of that decision means more errors are caught at runtime where other languages might catch them at compilation. With a service running in a data center, you can roll back, fix, and roll forward at your convenience. But, when building software that users install, the cost of each mistake is higher. For us, it's worth using tools that prioritize up-front correctness. We fully recognize the mismatch of **Go's priorities** and **what we are prioritizing** as a problem that we created for ourselves to solve.”

That’s quite an interesting case to know. But does rust emphasize on compile time errors. **You bet!**

Unlike Go, which is focussed on networks, servers and large scale systems, Rust focusses on correctness over abstraction which provides a lot more control in aspects like process management, file systems, os, etc. 

Since being a software that is shipped to client devices, it makes sense.

“Rust's type system and safety features allow us to put guardrails in place in our codebase where we need them. The language's expressiveness allows our developers to encode constraints that catch errors at compile time rather than in GitHub issues.”

One more reason is the ability to interop with C/C++. A majority of low level libraries are still developed and maintained in C and C++. But newer developers want a safe language and also some ability to interface with those languages. Rust provides exactly that.

Rust has an unsafe alter ego is that the underlying computer hardware is inherently unsafe. If Rust didn’t let you do unsafe operations, you couldn’t do certain tasks.Rust has a FFI interface. It provides a keyword “extern” to allow rust code to invoke C code. Here is an example from the [rust book](https://doc.rust-lang.org/book/ch19-01-unsafe-rust.html#using-extern-functions-to-call-external-code):

```
extern "C" {
    fn abs(input: i32) -> i32;
}

fn main() {
    unsafe {
        println!("Absolute value of -3 according to C: {}", abs(-3));
    }
}
```

## Rust makes us happy

Another important aspect the team provides is since Rust allows them to be flexible and does not get in their way, it makes the team happy. It is not unique to Turborepo team. In fact, Rust is the most desired language for the past 4 years in [Stack Overflow surveys](https://insights.stackoverflow.com/survey).  

Rust finds its way into a majority of web and other software tooling these days partly because of the correctness and dev satisfaction.

Let’s see how this turns out for the Turborepo team.

Here is the announcement blog: [https://vercel.com/blog/turborepo-migration-go-rust](https://vercel.com/blog/turborepo-migration-go-rust)

The build system is starting to incrementally adopt Rust in their project

Go

Turborepo migrates from Go to Rust

Follow us

Most read articles

Learn the newest gaming tech updates with our weekly newsletter