For over two decades, Google has helped lead the invention of modern cloud systems—defining, designing and deploying warehouse-scale computing as the foundation for reliable, performant, and secure global-scale information services delivered to billions of users around the world. This leadership involves significant innovation across a broad range of systems technologies, including distributed systems, storage systems, databases, analytics, operating systems, wide area and data center networking, cluster computing, ML, video acceleration and more.

Today, we are announcing a significant step in continuing Google’s tradition of innovation and charting its path into the future: the formation of SystemsResearch@Google (SRG). SRG will be a new research team, positioned in the heart of Google’s Cloud and Infrastructure engineering organization, with the mission of shaping the future of hyperscaler systems design for Google and its ecosystem. It is focused on inventing, incubating, and infusing new concepts, designs, and technologies into Google’s applications, systems, and data centers. The team’s position will allow seamless engagement with engineering and product teams, enabling joint exploration in concert with transformative workloads. Beyond Google, the SRG team will look to forge strong relationships with external research communities working on the most pressing systems-research problems.

Critical research at a pivotal time

We are at a time of enormous transition and opportunity, as nearly all large-scale computing is moving to cloud infrastructure, classical technology trends are hitting limits, new programming paradigms and usage patterns are taking hold, and most levels of systems design are being restructured. We are seeing wholesale change with the introduction of new applications around ML training and real-time inference to massive-scale data analytics and processing workloads fed by globally connected edge and cellular devices. This is all happening while the performance and efficiency gains we’ve relied on for decades are slowing dramatically from generation to generation. And while reliability is more important than ever as we deploy societally-critical infrastructure, we are challenged by increasing hardware entropy as underlying components approach angstrom scale manufacturing processes and trillions of transistors.

In the last twenty years, much of the world’s population has gained real-time access to the world’s information and to one another in ways that were previously the stuff of science fiction. The next decade will see computing and associated capabilities undergo an even more profound transformation, bringing real-time insights, sensing, and actuation to trillions of network-connected devices spanning all of the world’s population. Doing so will require fundamental advances in security, reliability, programming models, data analysis, systems for machine learning, networking, storage systems, hardware architecture, and software systems.

SystemsResearch@Google will be co-led by David Culler and Hank Levy, who bring a combination of academic and industrial experience, plus a long history of successful and impactful research in computer systems. Culler is the former Chair of EECS at UC Berkeley, where he worked to create the Division of Data Sciences and became its founding Dean. His research has focused on parallel architectures, clusters, embedded wireless networks, planetary-scale internet services, and sustainability design. He was the founding faculty director of Intel Research Berkeley, co-founded two startups, and worked with Sun Microsystems for a decade. Levy is the former Chair of Computer Science & Engineering at University of Washington, where he worked to create the Paul G. Allen School and became its founding Director. His research has focused on operating systems, distributed systems, computer architecture, and hardware multithreading. Before UW, Levy spent a decade at Digital Equipment Corporation (DEC), where he worked on operating systems and early-generation clustered computer systems; he has also co-founded two startups. Culler and Levy are both Members of the National Academy of Engineering and Fellows of the IEEE and the ACM.

SRG will be located across sites in Google’s Bay Area and Seattle facilities. We are currently building the SRG team, bringing together leading networked systems thinkers from around the world and inside Google. If you are interested in learning more please reach out to us at systemsresearch@google.com.

Time to go outside again, I guess. I’ll need a sun hat. Sunscreen. Maybe some new sandals? What else?

With the Recommendations AI service, I might be reminded to grab a reusable water bottle and a swimsuit. Or some after-sun aloe lotion. Good thing, cause I’ll need it.

Recommendations AI is a solution that uses machine learning to bring product recommendations to their shoppers across any catalog or client list. This service is part of our full suite of Retail solutions. When you integrate with the Retail API, you get the benefit of Google’s Product Discovery. Integrating once to reap the benefits over and over. Recommendations is the starting point, and you can easily extend into Retail Search and Vision Product Search in the upcoming future. 

The Recommendations solution is fully managed, global-scale and powered by deep learning, so you can focus on a great shopping experience and let someone else worry about the infrastructure.

Compared to baseline recommendation systems used by customers, Recommendations AI showed double digit uplift in conversion and clickthrough rates in A/B experiments controlled by the customers. You can optimize for click-through, conversion or session revenue, and fine tune the models to make sure you omit out-of-stock items or duplicates, for example.

So how does it work, and how do you get started? Read on, and we’ll walk you through the pipeline, starting with the data you already have to placement in your online store. 

Formula: Data -> Model -> Placement

You start with your catalog, the list of all the things (postcards, movies, pie recipes) that you want to show your customers. Then you ingest your PII-redacted user events -this is the historic event data like home page views, add to cart events and more along with real time user events. This user event is joined with the product catalog and items that allows us to construct the sequence of shoppers’ activity, thus being able to predict what the shopper has a high propensity to purchase next. The user events can come from both online activity across devices or offline store purchases

The recommendation model will return a list of products, which are the recommendations. The brains of the operation, if you will. This model is trained using all the data that you ingest, using the latest neural network models and techniques that Google has built expertise over the years in flagship products like Youtube and News, that allows us to uncover shopper intent,  so it can best predict the right recommendations to show to the right people.

Every model outputs a list of product identifiers, but where do they go? They go into placements, the spots, panels, carousels on your customer’s journey interacting with your brand that you’ve set aside to highlight recommendations. A model can send recommendations to one or more placements, but each placement only receives information from one recommendation model. Your pages will then need to render the products with the right images, text or other metadata, using the product ID that is returned by the model.

What do recommendations look like?

Let’s start by browsing our postcard-selling website, where I’ve been buying some vintage California postcards already. The recommendations algorithm has caught on to my interest, showing me other potential cards to purchase based on my history:

Put your data to work

To get started we need to bring your data into the recommendation model, so it can understand your customers, your inventory, and your sales patterns. 

The model takes in the product catalog you use, and metadata about those products to better understand nuances in assortment, pricing and variables like size and style. You might already have this data stored in BigQuery or Merchant Center, and hence we provide easy integrations that you can leverage to get started even faster.

As for the user events, don’t worry if you already have systems in place to capture web and mobile activity. We make it easy to bring in your real time event logs by providing seamless integrations with Google Tag Manager, Javascript pixel, or even historic events from Cloud Storage, BigQuery or using inline API or JSON, so you can immediately train the models on this imported  data. All this allows you to kickstart integrating with Recommendations AI in a matter of days.

The models then construct a sequence of activities that the user went through and joins with the products that the user engaged with. Once your data is ready to go, it takes a few days to train the model. Next onto making the data work for you.

Quickly customize your model

Setting up your own recommendations project in the console gives you the ability to choose what sort of model to train (based on what recommendations you want to generate) and your objective. Are you optimizing for click-through rate–more people click on the recommendation links or products–or for conversion rate–more people choose or buy what was suggested or revenue ?

Different models can be optimized for different optimization goals.; the GCP console explains what each one can do and how you can choose to optimize it.

Let’s unpack some of this terminology real quick.

We’ve got three model types:

• Recommended for you – Means we think these are items you’ll want to buy, based on your history; this is usually used on a home page to showcase items.
• Others you may like – Means if you’re browsing the page of a water bottle, we will recommend  alternative brands of water bottles that you may like as well as a backpack, based on your engagement  history.
• Frequently bought together – Means that when anyone buys sunscreen, we notice that they often also buy aloe lotion, so we will surface those items when someone adds any one of them to their cart.

And then we have three business objectives that the models optimize for:

• Click-through rate – How frequently did somebody click on a recommended item?
• Conversion rate– How frequently did somebody add a recommended item to their cart?
• Revenue per session – How much money did the recommendations generate for you?

Deliver anywhere along the journey

Now that you’re all set up in the Retail AI console, you can test out the recommendations in the console, even before you deploy to production.

You can integrate Recommendations into your frontend by calling the Predict APIt. The placements of recommendations will report data back into the dashboard and you can analyze and measure success for future iterations. 

On top of that you can use the recommendations for other parts of your customer’s journey. Email promotions, storefront kiosks, display ads or follow-up notifications can include recommendations based on past activity and cart contents. The model gives you useful product recommendations for a wide variety of touchpoints and steps in the purchasing process.

More best practices, and guides, are available inside our documentation.

How to get started

Training your own models can be tedious, time-consuming, and expensive. On top of that it requires deeper data science expertise to set up. Let us do it instead!

You can see how IKEA Retail uses Recommendations AI in this recent talk and blog from the Google Cloud Retail Summit..

To get started today you’ll need to make a Cloud project and enable the Retail API, which then allows you to access all the recommendation tools in one menu. Bring in your catalog and purchasing data, define a placement or two, and you can start putting recommendations on your site in a matter of days.

In today’s era of data-driven applications, leveraging advanced machine learning and artificial intelligence services like computer vision has become increasingly important. One such service is the Vision API, which provides powerful image analysis capabilities. In this blog, we will explore how to create a Computer Vision application using Spring Boot and Java, enabling you to unlock the potential of image recognition and analysis in your projects. The application UI will accept as input, public URLs of images that contain written or printed text, extract the text, detect the language and if it is one of the supported languages, it will generate the English translation of that text.

Spring Boot and Google Cloud

Spring Boot is a powerful open-source framework for creating Spring-based applications. It simplifies development by providing auto-configuration, starter dependencies, and embedded servers. It also offers production-ready features like metrics and health checks. With Spring Boot, you can focus on writing code and deploying efficient applications without worrying about complex configuration or dependencies. Apart from the well-known features that make it an ideal choice for enterprise apps, a new exciting development is the official support for Native Image Builder using GraalVM, enabling the creation of native standalone executables without the need for a Java Runtime and are leaner and offer a super fast startup experience. Try Spring Native on Google Cloud.

The Spring Cloud GCP library makes it easy for Spring Boot applications to use Google Cloud services. It provides Spring Boot APIs for over a dozen Google Cloud services. This means you can take advantage of the benefits of Google Cloud services without having to learn separate Google Cloud client libraries. It is very easy to migrate or create a new Spring Boot application in Google Cloud. With just one command, you can bootstrap your production-ready Spring Boot project structure and start making code changes for your requirement. Refer to the documentation for a full list of features. 

Prerequisites

Before diving into the development process, make sure you have the following prerequisites in place:

1. A Google Cloud account with a project created and billing enabled 
2. Vision API, Translation, Cloud Run, and Artifact Registry APIs enabled
3. Cloud Shell activated
4. Cloud Storage API enabled with a bucket created and images with text or handwriting in local supported languages uploaded (or you can use the sample image links provided in this blog)

Refer to the documentation for steps on how to enable Google Cloud APIs.

Bootstrapping a Spring Boot project

To get started, create a new Spring Boot project using your preferred IDE or Spring Initializr. Include the necessary dependencies, such as Spring Web, Spring Cloud GCP, and Vision AI, in your project’s configuration. Alternatively, you can use Spring Initializr from Cloud Shell using the below steps to bootstrap your Spring Boot application easily:

1. Open a Cloud Shell terminal and make sure it is pointing to the correct project and that you are authorized (if not you can use the command below to set the right project):

gcloud config set project <PROJECT_ID>

2. Run the following command to create your Spring Boot project:

curl https://start.spring.io/starter.tgz -d packaging=jar -d dependencies=cloud-gcp,web,lombok -d baseDir=spring-vision -d type=maven-project -d bootVersion=3.0.1.RELEASE | tar -xzvf -

spring-vision is the name of your project, change it per your requirement.
bootVersion is the version of Spring Boot, make sure to update it if required at the time of your implementation.
type is the version of project build tool type, you can change it to gradle if preferred.

This creates a project structure under “spring-vision” as below:

pom.xml contains all the dependencies for the project (dependencies you configured using this command are already added in your pom.xml).
src/main/java/com/example/demo has the source classes .java files.
resources contain the images, XML, text files and the static content the project uses that are maintained independently.
application.properties enable you to maintain the admin features to define profile specific properties of the application.

Configuring the Vision API

Once you have the Vision API enabled, you have the option to configure the API credentials in your application. You can optionally use Application Default Credentials for setting up authentication. In this demo implementation however I have not implemented the use of credentials.

Implementing the vision and translation services

Create a service class that interacts with the Vision API. Inject the necessary dependencies and use the Vision API client to send image analysis requests. You can implement methods to perform tasks like image labeling, face detection, recognition, and more, based on your application’s requirements. In this demo, we will use handwriting extraction and translation methods. For this make sure you include the following dependencies in pom.xml

<dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-gcp-starter-vision</artifactId>
</dependency>

<dependency>
      	      <groupId>com.google.cloud</groupId>
            	<artifactId>google-cloud-translate</artifactId>
   	</dependency>

Clone / Replace the following files from the repo and add them to the respective folders / path in the project structure:

1. Application.java (/src/main/java/com/example/demo)
2. TranslateText.java (/src/main/java/com/example/demo)
3. VisionController.java (/src/main/java/com/example/demo)
4. index.html (/src/main/resources/static)
5. result.html (/src/main/resources/templates)
6. pom.xml

The method extractTextFromImage in the service org.springframework.cloud.gcp.vision.CloudVisionTemplate lets you extract text from your image input. The method getTranslatedText from the service com.google.cloud.translate.v3 lets you pass the extracted text from your image and get the translated text in the desired target language as response (if the source is in one of the supported languages list). 

Building the REST API

Design and implement the REST endpoints that will expose the Vision API functionalities. Create controllers that handle incoming requests and utilize the Vision API service to process the images and return the analysis results.

In this demo, our VisionController class implements the endpoint, handles the incoming request, invokes the Vision API and Cloud Translation services and returns the result to the view layer. Implementation of the GET method for the REST endpoint is as follows:

@GetMapping("/extractText")
  public String extractText(String imageUrl) throws IOException {
    String textFromImage =
   this.cloudVisionTemplate.extractTextFromImage(this.resourceLoader.getResource(imageUrl));


    TranslateText translateText = new TranslateText();
    String result = translateText.translateText(textFromImage);
    return "Text from image translated: " + result;
  }

The TranslateText class in the above implementation has the method that invokes the Cloud Translation service:

String targetLanguage = "en";
 TranslateTextRequest request =
         TranslateTextRequest.newBuilder()
             .setParent(parent.toString())
             .setMimeType("text/plain")
             .setTargetLanguageCode(targetLanguage)
             .addContents(text)
             .build();
     TranslateTextResponse response = client.translateText(request);
     // Display the translation for each input text provided
     for (Translation translation : response.getTranslationsList()) {
       res = res + " ::: " + translation.getTranslatedText();
        System.out.printf("Translated text : %s\n", res);
     }

With the VisionController class, we have the GET method for the REST implemented.

Integrating Thymeleaf for frontend development

When building an application with Spring Boot, one popular choice for frontend development is to leverage the power of Thymeleaf. Thymeleaf is a server-side Java template engine that allows you to seamlessly integrate dynamic content into your HTML pages. Thymeleaf provides a smooth development experience by allowing you to create HTML templates with embedded server-side expressions. These expressions can be used to dynamically render data from your Spring Boot backend, making it easier to display the results of image analysis performed by the Vision API service.

To get started, ensure that you have the necessary dependencies for Thymeleaf in your Spring Boot project. You can include the Thymeleaf Starter dependency in your pom.xml:

<dependency>

      <groupId>org.springframework.boot</groupId>

      <artifactId>spring-boot-starter-thymeleaf</artifactId>

    </dependency>

In your controller method, retrieve the analysis result from the Vision API service and add it to the model. The model represents the data that will be used by Thymeleaf to render the HTML template. Once the model is populated, return the name of the Thymeleaf template that you want to render. Thymeleaf will take care of processing the template, substituting the server-side expressions with the actual data, and generating the final HTML that will be sent to the client’s browser. Example:

return new ModelAndView("result", <<YOUR RESULT>>);

In the case of the extractText method in VisionController, we have returned the result as a String to and not added to the model. But we have invoked the GET method extractText method on the index.html on page submit.

<form action="/extractText">

        Web URL of image to analyze:

        <input type="text"

               name="imageUrl"

               value=""

        <input type="submit" value="Read and Translate" />

</form>

With Thymeleaf, you can create a seamless user experience, where users can upload images, trigger Vision API analyses, and view the results in real-time. Unlock the full potential of your Vision AI application by harnessing the power of Thymeleaf for frontend development.

Deploying your Spring Boot application with Cloud Run

Write unit tests for your service and controller classes to ensure proper functionality under the /src/test/java/com/example folder. Once you’re confident in its stability, package it into a deployable artifact, such as a JAR file, and deploy it to Cloud Run,  a serverless compute platform on Google Cloud. In this step, we will focus on deploying your containerized Spring Boot application using Cloud Run.

a. Package your application by executing the following steps from Cloud Shell(make sure the terminal is prompting at the project root folder)

Build:

./mvnw package

Once the build is successful, run locally to test:

./mvnw spring-boot:run

b. Containerize your Spring Boot Application with Jib:

Instead of manually creating a Dockerfile and building the container image, you can use the Jib utility to simplify the containerization process. Jib is a plugin that integrates directly with your build tool (such as Maven or Gradle) and allows you to build optimized container images without writing a Dockerfile. Before proceeding, you need to enable the Artifact Registry API (Use of Artifact Registry is encouraged over container registry). Then Run Jib to build a Docker image and publish to the Registry:

$ ./mvnw com.google.cloud.tools:jib-maven-plugin:3.1.1:build -Dimage=gcr.io/$GOOGLE_CLOUD_PROJECT/vision-jib

Note: In this experiment, we did not configure the Jib Maven plugin in pom.xml, but for advanced usage, it is possible to add it in pom.xml with more configuration options

c. Deploy the container (that we pushed to Artifact Registry in the previous step) to Cloud Run. This is again a one-command step:

gcloud run deploy vision-app --image gcr.io/$GOOGLE_CLOUD_PROJECT/vision-jib --platform managed --region us-central1 --allow-unauthenticated --update-env-vars

You can alternatively do this from the UI as well. Navigate to the Google Cloud Console and locate the Cloud Run service. Click on “Create Service” and follow the on-screen instructions. Specify the container image you previously pushed to the registry, configure the desired deployment settings (such as CPU allocation and autoscaling), and choose the appropriate region for deployment. You can set environment variables specific to your application. These variables can include authentication credentials (API keys etc.), database connection strings, or any other configuration needed for your Vision AI application to function correctly. When the deployment is completed successfully, you should get an endpoint to your application.

For our demo, the endpoint Cloud Run created for us is: https://vision-app-********-uc.a.run.app

Playing with your Vision AI app

For demo purposes, you can use the image URL below for your app to read and translate: 
https://storage.googleapis.com/img_public_test/tamilwriting1.jfif

Conclusion

Congratulations! You have successfully created a Vision AI application using Spring Boot and Java. With the power of Vision AI, your application can now perform sophisticated image analysis, including labeling, face detection, and more. The integration of Spring Boot provides a solid foundation for building scalable and robust Google Cloud Native applications. Continue exploring the vast capabilities of Vision AI, Cloud Run, Cloud Translation and more to enhance your application with additional features and functionalities. To learn more, check out the Vision API, Cloud Translation, and GCP Spring docs. Try out the same experiment with the Spring Native option!! Also as a sneak-peak to Gen-AI world, checkout how this API shows up in Model Garden.

Job seekers can often feel lost or disconnected—like the right opportunity is out there, but they don’t know where or how to look. Employers face a similar challenge when trying to attract the right candidates. Many companies, especially large enterprises, face a talent shortage across a range of critical roles.

For global companies like Johnson & Johnson (J&J), their online career website is an important recruiting tool. It’s the “front door” for talent that could make a vital difference in the company’s future and drive innovation for years to come.

However, career sites are often underutilized. If a job seeker doesn’t find a good job match with a quick search, they will likely move on. Too often, that represents a lost opportunity for both the company and the job seeker that could have been avoided with better search results.

“Partnering with Jibe and using Cloud Talent Solution for our career site allows us to do a much better job matching opportunity to talent on a very large scale.”

—Sjoerd Gehring, Global VP of Talent Acquisition, Johnson & Johnson

While J&J receives approximately 1 million applications for 25,000 positions each year, the percent of applicants that were highly qualified for open positions was low.

Although the company always has a variety of open jobs on its career site, it noticed that even when strong matches existed between online job seekers and available positions, search results often didn’t highlight or even display the right opportunities. The user interface wasn’t intuitive enough, and job seekers couldn’t easily find their ideal positions.

As J&J began to reevaluate recruiting to take a more relationship-centric and digitally-driven approach, the company began working with Jibe, a career-site solutions provider.

Jibe introduced J&J to Cloud Talent Solution, which uses machine learning to better match job listings with job seekers’ interests and qualifications. Using Cloud Talent Solution, companies can build a compelling career-site search experience that helps candidates easily find the jobs most relevant to them. With smarter job searches and recommendations, J&J improved the effectiveness of its career site in just a few weeks.

“Jibe and Google make it easy for a large company to make a real difference in the candidate experience without investing a lot of time, money, or internal resources,” says Sjoerd Gehring, Global VP of Talent Acquisition at Johnson & Johnson. “Now that we’re using Cloud Talent Solution, our career site search results are exponentially better.”

Transforming job searches with better matches

Cloud Talent Solution better connects job seekers with jobs, because it understands the nuances of job titles, descriptions, industry jargon, and skills, matching job seeker preferences with relevant listings based on sophisticated classifications and relational models. It helps decipher job seeker queries and employer job postings, removing the manual effort of optimizing job content for search.

By using the Jibe platform to integrate Cloud Talent Solution with its career site, job seekers are more easily finding what they’re looking for and J&J is filling business critical roles more efficiently.

Since integrating Cloud Talent Solution, J&J has seen a 41% increase in high-quality job applicants per search and a nearly 45% increase in click-through rate on its career site.

“Partnering with Jibe and using Cloud Talent Solution for our career site allows us to do a much better job matching opportunity to talent on a very large scale,” adds Sjoerd. “We’re able to take a more personal approach and really connect with job seekers, which is a win.”

“Today’s job seekers expect a prospective employer’s career site to work like the other cloud services they use. Using Google’s machine learning and artificial intelligence, we can help customers like J&J get better search results and return jobs that candidates are more likely to apply to.”

—Joe Essenfeld, Founder & CEO, Jibe

Connecting people with opportunities

J&J is now offering job seekers experiences in line with what they have come to expect as consumers—searching for a job should be as easy as searching for flights, restaurants, products, and other services. Because candidates are familiar with the experience, their level of interaction and engagement goes up, creating a larger pipeline of qualified candidates and filling jobs faster.

“Today’s job seekers expect a prospective employer’s career site to work like the other cloud services they use,” says Joe Essenfeld, Founder & CEO at Jibe. “Using Google’s machine learning and artificial intelligence, we can help customers like J&J get better search results and return jobs that candidates are more likely to apply to.”

A new digital revolution for recruiting

J&J continues to work with Jibe and Google to offer new features which make its career site even more effective. By offering job seekers a transformative, engaging experience, J&J is a more attractive and visible employer, increasing the value of its brand. It’s also continuously improving its recruiting process with end-to-end visibility and feedback from interactions with a million people every year.

“Transforming our career site with Jibe and Cloud Talent Solution directly impacts our ability to attract high-quality talent and hire those candidates faster,” adds Sjoerd. “Lots of people are looking for their dream job, and if it’s here at J&J, we want them to find it quickly and easily.”