Shane McAllister

**Introduction**
----------------

Amazon CodeWhisperer is trained on billions of lines of code and can generate code suggestions — ranging from snippets to full functions — in real-time, based on your comments and existing code. AI code assistants have revolutionized developers’ coding experience, but what sets Amazon CodeWhisperer apart is that MongoDB has collaborated with the AWS Data Science team, enhancing its capabilities!

:youtube[]{vid=euVzChXRO9w}

At MongoDB, we are always looking to enhance the developer experience, and we've fine-tuned the CodeWhisperer Foundational Models to deliver top-notch code suggestions — trained on, and tailored for, MongoDB. This gives developers of all levels the best possible experience when using CodeWhisperer for MongoDB functions. 

This tutorial will help you get CodeWhisperer up and running in VS Code, but CodeWhisperer also works with a number of other IDEs, including IntelliJ IDEA, AWS Cloud9, AWS Lambda console, JupyterLab, and Amazon SageMaker Studio. On the [Amazon CodeWhisperer site][1], you can find tutorials that demonstrate how to set up CodeWhisperer on different IDEs, as well as other documentation.

*Note:* CodeWhisperer allows users to start without an AWS account because usually, creating an AWS account requires a credit card. Currently, CodeWhisperer is free for individual users. So it’s super easy to get up and running.

**Installing CodeWhisperer for VS Code** 

CodeWhisperer doesn’t have its own VS Code extension. It is part of a larger extension for AWS services called AWS Toolkit. AWS Toolkit is available in the VS Code extensions store. 

 1. Open VS Code and navigate to the extensions store (bottom icon on the left panel).
 2. Search for CodeWhisperer and it will show up as part of the AWS Toolkit.
![Searching for the AWS ToolKit Extension][2]
 3. Once found, hit Install. Next, you’ll see the full AWS Toolkit
    Listing
![The AWS Toolkit full listing][3]
 4. Once installed, you’ll need to authorize CodeWhisperer via a Builder
    ID to connect to your AWS developer account (or set up a new account
    if you don’t already have one).
![Authorise CodeWhisperer][4]



**Using CodeWhisperer**
-----------------------


Navigating code suggestions 

![CodeWhisperer Running][5]

With CodeWhisperer installed and running, as you enter your prompt or code, CodeWhisperer will offer inline code suggestions. If you want to keep the suggestion, use **TAB** to accept it. CodeWhisperer may provide multiple suggestions to choose from depending on your use case. To navigate between suggestions, use the left and right arrow keys to view them, and **TAB** to accept.

If you don’t like the suggestions you see, keep typing (or hit **ESC**). The suggestions will disappear, and CodeWhisperer will generate new ones at a later point based on the additional context.

**Requesting suggestions manually**

You can request suggestions at any time. Use **Option-C** on Mac or **ALT-C** on Windows. After you receive suggestions, use **TAB** to accept and arrow keys to navigate.

**Getting the best recommendations**

For best results, follow these practices.

 - Give CodeWhisperer something to work with. The more code your file contains, the more context CodeWhisperer has for generating recommendations.
 - Write descriptive comments in natural language — for example
```
// Take a JSON document as a String and store it in MongoDB returning the _id
```
Or
```
//Insert a document in a collection with a given _id and a discountLevel
```
 - Specify the libraries you prefer at the start of your file by using import statements.
```
// This Java class works with MongoDB sync driver.
// This class implements Connection to MongoDB and CRUD methods.
```
 - Use descriptive names for variables and functions
 - Break down complex tasks into simpler tasks

**Provide feedback**
----------------

As with all generative AI tools, they are forever learning and forever expanding their foundational knowledge base, and MongoDB is looking for feedback. If you are using Amazon CodeWhisperer in your MongoDB development, we’d love to hear from you. 

We’ve created a special “codewhisperer” tag on our [Developer Forums][6], and if you tag any post with this, it will be visible to our CodeWhisperer project team and we will get right on it to help and provide feedback. If you want to see what others are doing with CodeWhisperer on our forums, the [tag search link][7] will jump you straight into all the action. 

We can’t wait to see your thoughts and impressions of MongoDB and Amazon CodeWhisperer together. 


  [1]: https://aws.amazon.com/codewhisperer/resources/#Getting_started
  [2]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt1bfd28a846063ae9/65481ef6e965d6040a3dcc37/CW_1.png
  [3]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/bltde40d5ae1b9dd8dd/65481ef615630d040a4b2588/CW_2.png
  [4]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt636bb8d307bebcee/65481ef6a6e009040a740b86/CW_3.png
  [5]: https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/bltf1e0ebeea2089e6a/65481ef6077aca040a5349da/CW_4.png
  [6]: https://www.mongodb.com/community/forums/
  [7]: https://www.mongodb.com/community/forums/tag/codewhisperer

Getting Started with MongoDB and AWS Codewhisperer



<div class="introduction">

With Covid19 putting an end to in-person events, we wanted to engage directly with developers utilizing the recently announced MongoDB Realm public preview, and so the Realm Hackathon was conceived. This would be MongoDB's first digital Hackathon and we were delighted with the response. In the end, we ended up with nearly 300 registrations, which culminated in 23 teams coming together over the course of a day and half of learning, experimenting, and above all, having fun! The teams were predominantly European given the timezone of the Hackathon, but we did have participants from the US and also the Asia Pacific region, too.

During the Hackathon, we engaged in  
-   Team forming
-   Idea pitching
-   Q&A with the Realm Enginnering team behind many of the Realm SDKs
-   and of course, developing!

With 23 teams, there was a huge variation in concepts and ideas put forward for the Hackathon. From Covid19-influenced apps to chatbots to inventory tracking apps, the variety was superb. On the final morning, all teams had an opportunity to pitch their apps competitively and we (the judges) were highly impressed with the ingenuity, use of Realm, and the scope of what the teams accomplished in a 24-hour period. In the end, there can only be one winner, and we were delighted to award that title to Team PurpleBlack.

Team PurpleBlack created a MongoDB Realm-based mobile asset maintenance solution. Effective asset maintenance is critical to the success of any utility company. The solution included an offline iOS app for field technicians, a MongoDB Charts dashboard, and email notifications for administrators. Santaneel and Srinivas impressed with their grasp of Realm and their ambition to build a solution leveraging not only Realm but MongoDB Atlas, Charts, and Triggers. So, we asked Team PurpleBlack to share their experience in their own words, and we're thrilled to share this with you.

>Guest post - by Santaneel Pyne of Team PurpleBlack - The MongoDB Realm Hackathon Experience!

<img src="https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/article/hackathon/team_purpleblack.png" class="align-center" alt="Team PurpleBlack" />

## THE MOTIVATION

Hackathons are always a fantastic experience. They are fun, exciting, and enriching all at the same time. This July, I participated in the first Realm Hackathon organised by MongoDB. Earlier in the year, while I was going through a list of upcoming Hackathons, I came across the Realm Hackathon. I was keen on participating in this hackathon as this was about building offline mobile apps. I am a Solution Architect working with On Device Solutions, and enterprise mobile apps are a key focus area for me. For the hackathon, I had teamed up with Srinivas Divakarla from Cognizant Technology Solutions. He is a technical lead and an experienced Swift developer. We named our team PurpleBlack. It is just another random name. Neither of us had any experience with MongoDB Realm. This was going to be our opportunity to learn. We went ahead with an open mind without too many expectations.

## THE 'VIRTUAL' EXPERIENCE

This was our first fully online hackathon experience. The hackathon was spread across two days and it was hosted entirely on Zoom. The first day was the actual hack day and the next day was for presentations and awards. There were a couple of introductory sessions held earlier in the week to provide all participants a feel of the online hackathon. After the first session, we created our accounts in [cloud.mongodb.com](https://www.mongodb.com/cloud) and made sure we had access to all the necessary tools and SDKs as mentioned during the introductory session. On the day of the hackathon, we joined the Zoom meeting and were greeted by the MongoDB team. As with any good hackathon, a key takeaway is interaction with the experts. It was no different in this case. We met the Realm experts - Kraen Hansen, Eduardo Lopez, Lee Maguire, Andrew Morgan, and Franck Franck. They shared their experience and answered questions from the participants.

<img src="https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/article/hackathon/screen1.jpg" class="align-center" alt="Hackathon Zoom Sceen" />

By the end of the expert sessions, all participants were assigned a team. Each team was put into a private Zoom breakout room. The organisers and the Realm experts were in the Main Zoom room. We could toggle between the breakout room and the Main room when needed. It took us some time to get used to this. We started our hacking session with an end-to-end plan and distributed the work between ourselves. I took the responsibility of configuring the back-end components of our solution, like the cluster, collections, Realm app configurations, user authentication, functions, triggers, and charts. Srinivas was responsible for building the iOS app using the iOS SDK. Before we started working on our solution, we had allocated some time to understand the end-to-end architecture and underlying concepts. We achieved this by following the [task tracker iOS app tutorial](https://docs.mongodb.com/realm/tutorial/ios-swift/). We had spent a lot of time on this tutorial, but it was worth it as we were able to re-use several components from the task tracker app. After completing the tutorial, we felt confident working on our solution. We were able to quickly complete all the backend components and then
started working on the iOS application. Once we were able to sync data between the app and the MongoDB collections, we were like, "BINGO!" We then added two features that we had not planned for earlier. These features were the email notifications and the embedded charts. We rounded-off Day 1 by providing finishing touches to our presentation.

Day 2 started with the final presentations and demos from all the teams. Everyone was present in the Main Zoom room. Each team had five minutes to present. The presentations and demos from all the teams were great. This added a bit of pressure on us as we were slotted to present at the end. When our turn finally arrived, I breezed through the presentation and then the demo. The demo went smoothly and I was able to showcase all the features we had built.

<img src="https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/article/hackathon/screen2.jpg" class="align-center" alt="Hackathon Zoom Screen" />

Next was the countdown to the award ceremony. The panel of judges went into a breakout room to select the winner. When the judges were back, they announced PurpleBlack as the winner of the first MongoDB Realm Hackathon!!

## OUR IDEA

Team PurpleBlack created a MongoDB Realm-based mobile asset maintenance solution. Effective asset maintenance is critical to the success of any utility company. The solution included an offline iOS app for field technicians, a MongoDB Charts dashboard, and email notifications for Maintenance Managers or Administrators. Field technicians will download all relevant asset data into the mobile app during the initial synchronization. Later, when they are in a remote area without connectivity, they can scan a QR code fixed to an asset to view the asset details. Once the asset details are confirmed, an issue can be created against the identified asset. Finally, when the technicians are back online, the Realm mobile app will automatically synchronize all new issues with MongoDB Atlas. Functions and triggers help to send email notifications to an Administrator in case any high-priority issue is created. Administrators can view the charts dashboard to keep track of all issues created and take follow-up actions.

<img src="https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/article/hackathon/screen3.png" class="align-center" alt="App Flow" />

To summarise, our solution included the following features:  
-   iOS app based on Realm iOS SDK
-   Secure user authentication using email-id and password
-   MongoDB Atlas as the cloud datastore
-   MongoDB Charts and embedded charts using the embedding SDK
-   Email notifications via the SendGrid API using Realm functions and triggers

A working version of our iOS project can be found in our [GitHub
repo.](https://github.com/divakarlasrinivas/PurpleBlack)

This project is based on the Task Tracker app with some tweaks that helped us build the features we wanted. In our app, we wanted to download two objects into the same Realm - Assets and Issues. This means when a user successfully logs into the app, all assets and issues available in MongoDB Atlas will be downloaded to the client. Initially, a list of issues is displayed.

<img src="https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/article/hackathon/screen5.png" class="align-center" alt="App with list of issues" />

From the issue list screen, the user can create a new issue by tapping the + button. Upon clicking this button, the app opens the camera to scan a barcode/QR code. The code will be the same as the asset ID of an asset. If the user scans an asset that is available in the Realm, then there is a successful match and the user can proceed to the next screen to create an asset. We illustrate how this is accomplished with the code below:

``` Swift
func scanCompleted(code: String)
   {
         currentBarcode = code
         // pass the scanned barcode to the CreateIssueViewController and Query MongoDB Realm
         let queryStr: String =  "assetId == '"+code+"'";
         print(queryStr);
         print("issues that contain assetIDs: \(assets.filter(queryStr).count)");
         if(assets.filter(queryStr).count > 0 ){
          scanner?.requestCaptureSessionStopRunning()
          self.navigationController!.pushViewController(CreateIssueViewController(code: currentBarcode!, configuration: realm.configuration), animated: true);
          } else {
           self.showToast(message: "No Asset found for the scanned code", seconds: 0.6)
         }

   }
```

In the next screen, the user can create a new issue against the identified asset.

<img src="https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/article/hackathon/screen6.png" class="align-center" alt="Issues &amp; Assets" />

To find out the asset details, the Asset object from Realm must be queried with the asset ID:

``` Swift
required init(with code: String, configuration: Realm.Configuration) {

   // Ensure the realm was opened with sync.
   guard let syncConfiguration = configuration.syncConfiguration else {
         fatalError("Sync configuration not found! Realm not opened with sync?");
   }

   let realm = try! Realm(configuration: configuration)
   let queryStr: String =  "assetId == '"+code+"'";
   scannedAssetCode = code
   assets = realm.objects(Asset.self).filter(queryStr)

   // Partition value must be of string type.
   partitionValue = syncConfiguration.partitionValue.stringValue!

   super.init(nibName: nil, bundle: nil)
}
```

Once the user submits the new issue, it is then written to the Realm:

``` Swift
func submitDataToRealm(){
   print(form.values())

   // Create a new Issue with the text that the user entered.
   let issue = Issue(partition: self.partitionValue)
   let createdByRow: TextRow? = form.rowBy(tag: "createdBy")
   let descriptionRow: TextRow? = form.rowBy(tag: "description")
   let priorityRow: SegmentedRow<String>? = form.rowBy(tag: "priority")
   let issueIdRow: TextRow? = form.rowBy(tag: "issueId")

   issue.issueId = issueIdRow?.value ?? ""
   issue.createdBy = createdByRow?.value ?? ""
   issue.desc = descriptionRow?.value ?? ""
   issue.priority = priorityRow?.value ?? "Low"
   issue.status = "Open"
   issue.assetId = self.scannedAssetCode

   try! self.realm.write {
         // Add the Issue to the Realm. That's it!
         self.realm.add(issue)
   }

   self.navigationController!.pushViewController(TasksViewController( assetRealm: self.realm), animated: true);

}
```

The new entry is immediately synced with MongoDB Atlas and is available in the Administrator dashboard built using MongoDB Charts.

<img src="https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/article/hackathon/screen7.png" class="align-center" alt="Data in charts" />

## WRAPPING UP

Winning the first MongoDB Realm hackathon was a bonus for us. We had registered for this hackathon just to experience the app-building process with Realm. Both of us had our share of the "wow" moments throughout the hackathon. What stood out at the end was the ease with which we were able to build new features once we understood the underlying concepts. We want to continue this learning journey and explore MongoDB Realm further.

Follow these links to learn more -  
-   [GitHub Repo for Project](https://github.com/divakarlasrinivas/PurpleBlack)
-   [Realm Tutorial](https://docs.mongodb.com/realm/tutorial/)
-   [Charts Examples](https://github.com/mongodb/charts-embedding-examples)
-   [Sending Emails with MongoDB Stitch and SendGrid](https://medium.com/@histechup/sending-emails-with-mongodb-stitch-and-sendgrid-b201a4ca38e9)

To learn more, ask questions, leave feedback, or simply connect with other MongoDB developers, visit our [community forums.](https://developer.mongodb.com/community/forums/) Come to learn. Stay to connect.

>Getting started with Atlas is easy. Sign up for a [free MongoDB Atlas](https://mongodb.com/cloud/atlas) account to start working with all the exciting new features of MongoDB, including Realm and Charts, today!

In July, MongoDB ran its first digital hackathon for Realm. Our winners, team "PurpleBlack," share their experience of the Hackathon in this guest post.

The MongoDB Realm Hackathon Experience

 
Leafsteroids is a MongoDB Demo showing the following services and integrations
------------------------------------------------------------------------
![Leafsteroids Architecture](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt26770d2ea3d3004a/649227e9d40ad065f56824c2/Screenshot_2023-06-19_at_18.14.15.png)

**Atlas App Services**  
All in one backend. Atlas App Services offers a full-blown REST service using Atlas Functions and HTTPS endpoints.  

**Atlas Search**  
Used to find the player nickname in the Web UI. 

**Atlas Charts**  
Event & personalized player dashboards accessible over the web. Built-in visualization right with your data. No additional tools required. 

**Document Model**  
Every game run is a single document demonstrating rich documents and “data that works together lives together”, while other data entities are simple collections (configuration). 

**AWS Beanstalk** Hosts the Blazor Server Application (website). 

**AWS EC2**  
Used internally by AWS Beanstalk. Used to host our Python game server. 

**AWS S3** 
Used internally by AWS Beanstalk. 

**AWS Private Cloud**  
Private VPN connection between AWS and MongoDB. 

![leafsteroids_demo](https://images.contentstack.io/v3/assets/blt39790b633ee0d5a7/blt321f845875f27d15/6491d63975c2ae28f20612e5/leafsteroids_AdobeExpress.gif)  

**At a MongoDB .local Event and want to register to play Leafsteroids? [Register Here](https://github.com/mongodb-developer/leafsteroids)**

You can build & play Leafsteroids yourself with the following links

## Development Resources 
|Resource|	Link|
|---|---|
|Github Repo	|[Here](https://github.com/mongodb-developer/leafsteroids)|
|MongoDB TV Livestream	|[Here](https://www.mongodb.com/developer/videos/aws-cloud-connect-leafsteroids/)|
|MongoDB & AWS	|[Here](https://www.mongodb.com/mongodb-on-aws)|
|MongoDB on the AWS Marketplace	|[Here](https://aws.amazon.com/marketplace/pp/prodview-pp445qepfdy34)|


Leafsteroid Resources

Andrew Morgan

Missed Realm Sync in use — building and architecting a Mobile Chat App meetup event? Don't worry, you can catch up here.

Realm Sync in Use — Building and Architecting a Mobile Chat App Meetup

This meetup talk will focus on the benefits of JWT authentication and how to easily implement CosyncJWT within a Realm application.

Easy Realm JWT Authentication with CosyncJWT

Missed the first of our new Realm Meetups on SwiftUI Best Practices with Realm? Don't worry, you can catch up here.

SwiftUI Best Practices with Realm

Ian Ward

Katherine Maughan

## TL;DR

[Realm](https://www.mongodb.com/realm) is an easy-to-use, offline-first database that lets mobile developers build better apps faster.

Since the acquisition by MongoDB of Realm in May 2019, MongoDB has continued investing in building an updated version of our mobile database; culimating in the Realm Core Database 6.0.

We're thrilled to announce that it's now out of beta and released; we look forward to seeing what apps you build with Realm in production. The Realm Core Database 6.0 is now included in the 10.0 versions of each SDK: Kotlin/Java, Swift/Obj-C, Javascript on the node.js & React Native, as well as .NET support for a variety of UWP platforms and Xamarin. Take a look at the docs [here](https://docs.mongodb.com/realm/get-started/introduction-mobile/).

> **Build better mobile apps with Atlas Device Sync**: Atlas Device Sync is a fully-managed mobile backend-as-a-service. Leverage out-of-the-box infrastructure, data synchronization capabilities, built-in network handling, and much more to quickly launch enterprise-grade mobile apps. [Get started now by build: Deploy Sample for Free](https://www.mongodb.com/realm/register?tck=devhub_realmcoredatabase6)!

## A New Architecture

This effort lays a new foundation that further increases the stability of the Realm Database and allows us to quickly release new features in the future.

We've also increased performance with further optimizations still to come. We're most excited that:

-   The new architecture makes it faster to look up objects based on a primary key
-   iOS benchmarks show faster insertions, twice as fast sorting, and ten times faster deletions
-   Code simplifications yielded a ten percent reduction in total lines of code and a smaller library
-   Realm files are now much smaller when storing big blobs or large transactions

## Frozen Objects

With this release, we're also thrilled to announce that Realm now supports Frozen Objects, making it easier to use Realm with reactive frameworks.

Since our initial release of the Realm database, our concept of live,thread-confined objects, has been key to reducing the code that mobile developers need to write. Objects are the data, so when the local database is updated for a particular thread, all objects are automatically updated too. This design ensures you have a consistent view of your data and makes it extremely easy to hook the local database up to the UI. But it historically came at a cost for developers using reactive frameworks.

Now, Frozen Objects allows you to work with immutable data without needing to extract it from the database. Frozen Objects act like immutable objects, meaning they won't change. They allow you to freeze elements of your data and hand it over to other threads and operations without throwing an exception - so it's simple to use Realm when working with platforms like RxJava & LiveData, RxSwift & Combine, and React.

### Using Frozen Objects

Freeze any 'Realm', 'RealmList', or 'RealmObject' and it will not be possible to modify them in any way. These Frozen Objects have none of the threading restrictions that live objects have; meaning they can be read and queried across all threads.

As an example, consider what it would look like if you were listening to changes on a live Realm using Kotlin or .NET, and then wanted to freeze query results before sending them on for further processing. If you're an iOS developer please check out our blog post on [RealmSwift integration with Combine](https://developer.mongodb.com/article/realm-cocoa-swiftui-combine).

The Realm team is proud to say that we've heard you, and we hope that you give this feature a try to simplify your code and improve your development experience.

::::tabs
:::tab[]{tabid=".NET"}
``` csharp
var realm = Realm.GetInstance();
var frozenResults = realm.All<Person>()
  .Where(p => p.Name.StartsWith("Jane"))
  .Freeze();

Assert.IsTrue(results.IsFrozen());
Task.Run(() =>
{
   // it is now possible to read objects on another thread
   var person = frozenResults.First();
   Console.WriteLine($"Person from a background thread:  {person.Name}");
});
```
:::
:::tab[]{tabid="Kotlin"}
``` Kotlin
val realm: Realm = Realm.getDefaultInstance();
val results: RealmResults<Person> = realm.where<Person>().beginsWith("name", "Jane").findAllAsync()
results.addChangeListener { liveResults ->
   val frozenResults: RealmResults<Person> = liveResults.freeze()
   val t  = Thread(Runnable {
      assertTrue(frozenResults.isFrozen())

      // It is now possible to read objects on another thread
      val person: Person = frozenResults.first()
      person.name
      })
   t.start()
   t.join()
}
```
:::
::::

Since Java needs immutable objects, we also updated our Java support so all Realm Observables and Flowables now emit frozen objects by default. This means that it should be possible to use all operators available in RxJava without either using `Realm.copyFromRealm()` or running into an `IllegalStateException:`

``` Java
val realm = Realm.getDefaultInstance()
val stream: Disposable = realm.where<Person>().beginsWith("name", "Jane").findAllAsync().asFlowable()
   .flatMap { frozenPersons ->
      Flowable.fromIterable(frozenPersons)
             .filter { person -> person.age > 18 }
             .map { person -> PersonViewModel(person.name, person.age) }
             .toList()
             .toFlowable()
   }
   .subscribeOn(Schedulers.computation())
   .observeOn(AndroidSchedulers.mainThread)
   .subscribe { updateUI(it) }
   }
```

If you have feedback please post it in Github and the Realm team will check it out!

-   [RealmJS](https://github.com/realm/realm-js)
-   [RealmSwift](https://github.com/realm/realm-cocoa)
-   [RealmJava](https://github.com/realm/realm-java)
-   [RealmDotNet](https://github.com/realm/realm-dotnet)


## A Strong Foundation for the Future

The Realm Core Database 6.0 now released with Frozen Objects and we're
now focused on adding new features; such as new types, new SDKs,
andunlocking new use cases for our developers.

Want to Ask a Question? Visit our [Forums](https://developer.mongodb.com/community/forums/c/realm/).

Want to make a feature request? Visit our [Feedback Portal](https://feedback.mongodb.com/forums/923521-realm).

Want to be notified of upcoming Realm events such as our iOS Hackathon in November2020? Visit our [Global Community Page](https://live.mongodb.com/realm-global-community/).

>Safe Harbor
The development, release, and timing of any features or functionality described for our products remains at our sole discretion. This information is merely intended to outline our general product direction and it should not be relied on in making a purchasing decision nor is this a commitment, promise or legal obligation to deliver any material, code, or functionality.

Explaining Realm Core Database 6.0 and Frozen Objects

Realm Core Database 6.0: A New Architecture and Frozen Objects

Ferdinando Papale

Nikola Irinchev

Missed Realm .NET for Xamarin (best practices and roadmap) meetup event? Don't worry, you can catch up here.

Realm .NET for Xamarin (Best Practices and Roadmap) Meetup

Jason Flax

Missed Realm SwiftUI Property wrappers and MVI architecture meetup event? Don't worry, you can catch up here.