Using a first-of-its-kind dataset, researchers believe they've amassed "the first systematic, nationwide evidence that buyer agents do in fact steer clients away from properties that offer low buyer commissions.

DataDigest: Yes, buyer agents steer clients, new study claims

By Rob Curran IQVIA Holdings posted 7% third-quarter net-income growth as sales of its analytic and research services to laboratories grew. The

IQVIA Net Up on Strong Demand for Life-Sciences Services

WeWork shares tanked over 35% in premarket trading on Wednesday after media reports that the flexible workspace provider was planning to file for bankruptcy as early as next week.

WeWork shares sink on reports of imminent plans for bankruptcy filing

You should not place undue reliance on these forward-looking statements, which speak only as of the date hereof, and Western Digital undertakes no obligation to update or revise these forward-looking statements to reflect new information or subsequent ...

Western Digital Announces Upsize And Pricing Of $1.4 Billion Convertible Notes Offering

Artificial intelligence has been all the rage in almost every industry. This #OverlandPark company hopes to capitalize on that with its new offering. #AI #healthcare

Netsmart's new offering aims to add efficiency, alleviate labor shortages in health care

With the increasing complexity of data sources scattered across a hybrid, multi-cloud data estate, enterprises require a high-quality and secure data foundation. Learn how data mesh & data fabric can work together to achieve data-driven success.

Finding Your Ideal Data Architecture: Data Fabric, Data Mesh or Both?

The spin-off flash business will adopt a new business name and Western Digital will focus on hard drive sales.

Western Digital to Spin Off Flash Business Into New Company

The integration of data science in mobile app development brings several benefits for both users and developers.

How Data Science Transforms Mobile App Development

"Our HDD and Flash businesses are both well positioned to capitalize on the data storage industry's significant market dynamics, and as separate companies, each will have the strategic focus and resources to pursue opportunities in their respective markets.

Western Digital to Form Two Independent Public Companies Focused on Data Storage Growth in HDD and Flash Markets

Western Digital Corp. said it’s splitting itself into two separate public companies, both focused on data storage. The company will separate its HDD and flash businesses to better position each franchise for growth and to build innovative technology products,

Western Digital to Split Into Two Public, Data-Storage Companies

DataWeave

dataweave

This Article is going to accelerate your Mule development through easy shortcuts is an IDE provided by for building and testing integrations, This blog contains some useful shortcuts and tips to ease your development and play around by creating the custom shortcuts Anypoint Studio Mulesoft #Tip 1 Organize in just a click 🥳 ctrl + shift + f Usage: used to beautify, organize, justify the code, ( works for all, json, xml, java) Select the entire block/ part of code and then use this shortcut Before After #Tip 2 Ease your task with Autocomplete 😎 Isn't it boring to type the entire code all by yourself? Thanks to Anypoint Studio's code completion feature, you now have a friend working alongside you. Works with: JAVA, Dataweave, and pretty much everything ctrl + space bar Write a part of code, and then press ctrl + space to see the auto-generated suggestions to proceed further Usually, the suggestions are auto prompted but now you know the shortcut of how to get it #Tip 3  Zoom in/Zoom out  🕵 When it comes to Mule flows, you can zoom in and out, but it's not as simple as pinching in and out Works with mule flows ctrl +     //zoom in
ctrl -     // zoom out #Tip 4 Search within Everything 🔍 Everything? yes when I mean everything I literally mean everything Search within settings You might have your favorite settings but now you forgot where it exists? You might need to change something, but you need to click a lot to find it and change it, you don't know where exactly to change it, well there is one single solution for all these problems. ctrl + 3 The shortcut will display a magic search box, where you can easily search for your favorite settings This works for searches within settings, but if you want to search within a code file, well you have a well-known shortcut for that Search within file ctrl + f Use this shortcut in code files to search within the code/file Use this shortcut in message flow to search within the Mule components Palette Search References ctrl + alt + g this command can be used to search for all the references, select a part of text and use this shortcut to search within the references #Tip 5 🕵🏻‍♀️ Finding its Pair Finding the other matching socks as well as the matching bracket within large files is difficult, but now you can do it with just a click! ctrl + shift + p Set the pointer on the opening bracket and use this shortcut, its going to find out the closing bracket and move the pointer for you. It works with xml, java in anypoint studio, #Tip 6 🔁 Switching between tabs As a mule developer, it’s quite a task to shift between multiple files all the time, a shortcut to easily switch between tabs could be super helpful, ctrl + page dn    // for next tab
ctrl + page up    // for previous tab ✨in the further points we are going to see how to edit and customize these shortcuts, #Tip 7 💥 Standard Shortcuts Below are a few standard daily usage shortcuts, To run the mule flow ctrl + f11 
    (or)
ctrl + alt + x , m ⚠️ if you are using the second command then , first press the ctrl + alt + x and then press ‘m’ key To debug the mule flow ctrl + alt + d , m ⚠️ first press the ctrl + alt + d and then press ‘m’ key to debug the flow To run the Munit ctrl + shift + m , r To debug the Munit ctrl + shift + m , d Shift easily between message flow / Global elements / Configuration xml alt + f7 A box appears like this, by which we can shift easily between them New API Specification file ctrl + alt + m , s New Mule configuration file ctrl + alt + m , n New Mule Project ctrl + alt + m , p New RAML API Fragment File ctrl + alt + m , f #Tip 8 Shortcuts to OPEN Open Flow There could be multiple flows within the mule project, to open one within all of them, we can just, use this shortcut and search for the flow to find it easily. ctrl + shift + f Open search dialogue ctrl + h Open API Resource ctrl + shift + p #Tip 9 Perspective 🕹️ This is one of my favorite commands. To change the mule perspective lot of times, we choose to reset the perspective, one shortcut to perform it, is Alt + w , r , r , r To use the command, press alt + w combinedly and then press ‘r’ key for three times #Tip 10 Custom shortcuts 🛠️ Is your favorite shortcut not listed? Or do you want to create one for your own use? You can make your own custom shortcuts. Fortunately, there is a way to accomplish this: Window → Preferences → General → Keys Search for the one you wish Now you can change the shortcut the way you wish!!! Glad you liked all these shortcuts. Feel free to reach out to me for suggestions/ comments : linkedIn: www.linkedin.com/in/mohammad-jani Mail: janiprogramming@gmail.com

10 Anypoint Studio Shortcuts You Need To Know

10 atajos de Anypoint Studio que necesitas saber

If you are an experienced Java developer and you want to know how to get ahead in these unprecedented times, then adding digital transformation skills to your resume will give you the boost you want. In this article, I will define digital transformation and discuss how to leverage your Java expertise to gain an advantage in this high-demand area. What is digital transformation? According to Gartner, it’s “the process of exploiting digital technologies and supporting capabilities to create a robust new digital business model”. This is about making it easy for businesses to connect data from any system, no matter where it resides, in order to create connected experiences, faster. The challenges and benefits for businesses The challenge that businesses face is that their data is fragmented. It's drawn from multiple sources and is frustratingly difficult to process, which, for companies that rely on timely and accurate data to operate competitively, is far from optimal. So by connecting systems and unifying data, businesses can easily compose connected experiences while maintaining security and control. This enables them to unlock capabilities to build solutions that deliver exponentially increasing value and innovate at scale. Digital transformation under Covid-19 Businesses care a great deal about digital transformation and have been implementing methods to achieve it for many years. However, in these challenging times, the need for business transformation is even more urgent and made so by the demand to provide services and products online. The current covid-19 pandemic has accelerated organizations' efforts to adapt quickly to changing consumer behavior, and those businesses that succeed will continue to flourish. In contrast, those that fail to adapt quickly enough will fall behind and risk failure. Java professionals and digital transformation The demand for Java professionals with digital transformation expertise has skyrocketed during the last few months. As businesses rapidly shift their efforts to adapt to the new normal, they have a greater need to unlock and unify their data. They know that it empowers their business to create connected data experiences faster and in a more scalable way that satisfies their customers. The enabler of this digital transformation is the modern API. Modern APIs are the enablers of digital transformation As Java developers, we know what an API is and how to create one. When we refer to modern APIs, though, we have a specific incarnation in mind. It's a RESTful API that encompasses features above and beyond the representation of data. It is discoverable, reusable, and self-serviceable. It is easy to govern and designed in accordance with a solid architectural approach that promotes innovation at scale. It's more than just a simple RESTful API; it's a modern API supported by an API platform. The role that Java plays There are many platforms available that provide the Java professional with the capabilities to build APIs and integration solutions. Many of you may have used Camel or Spring integration. You may have built microservices and SOAP services. These are all solid approaches to integration that have been used for many years by businesses to access and unify data. However, none of these solutions provide the governance, scalability, reuse, and rapid development required by a business looking to transform quickly. This is where the API-led connectivity approach comes in. What is API-led connectivity? API-led connectivity is an architectural approach that emphasizes reuse, discoverability, self-service, and governance for every API created as part of an application network. It's the modern approach used by companies who want to liberate and unify data stored in siloed systems. It relies on three-tier of APIs that abstract over data systems and provides a ubiquitous way to access and aggregate data. How to leverage my Java knowledge? APIs developed as part of an API-led connectivity architecture rely on the Java-based runtime named the Mule runtime. They are designed and built to execute on the runtime and are deployed to isolated containers or virtual machines. As a Java developer, your knowledge of software development best practices, JVM concepts such as multithreading, and the experience you gained while architecting and building SOAP web services and microservices is invaluable. It gives you an enormous head start over those without that background. All APIs built to run on the Mule runtime are Java applications under the hood. They are built from smaller building blocks of Java libraries that collaborate to form the logic required to provide the service of the API itself. Mule APIs are always RESTful APIs. Developing those RESTful APIs is achieved via a graphical interface consisting of visual representations of the execution flows that represent the collaboration of building blocks. These flows incorporate the integration logic that unifies data and orchestrates calls to other APIs in the API-led connectivity architecture. Interesting challenges for the Java professionals Considering that the typical business that adopts the API-led connectivity approach is a large international entity, which has millions of customers, the challenge for the Java professional when building Mule APIs is focused on a number of key areas, they include, but are not limited to: The Java developer: Developing non-trivial and highly performant APIs that are capable of serving 10,000’s (or more) requests per second For these non-trivial applications, troubleshooting issues with multi-threading, performance, garbage collection, and the typical issues Java developers face while developing high-performance Java applications. The Java architect: Interpreting enterprise integrations patterns in terms of API-led connectivity’s three-tiered structure such that a business process is translated into the system, process and experience APIs. Design an API-led connectivity architecture that respects its fundamental principles such that APIs are sufficiently granular to be reusable while ensuring that resources are efficiently utilized. The Java data expert: the challenge is transforming data using a functional programming language (DataWeave) that is designed and optimized for data manipulation. There are many more interesting challenges and opportunities waiting for the Java professional who has Mule integration skills. What are my next steps? If you are interested in learning more, please consider watching my meetup (also in ), in which I will be discussing opportunities for Java professionals in digital transformation using MuleSoft’s API-led connectivity approach and how to receive free professional training and certification to really give you a boost in the demanding new world of digital transformation. Mule Integration for Java Professionals Spanish Also published here .

Keeping Up With Digital Transformation: Career Advice For Java Professionals

mapping is a key element in integration. Most of the prominent integration tools provide different capabilities for data mapping. In this article I thought of sharing on how data mapping can be achieved in Kumologica. Kumologica uses JSONata as the base for data mapping. JSONata is a Lightweight query and transformation language for data. It supports complex queries expression which can be achieved with minimal syntax and has a location path semantics of Xpath 3.1. Data JSON For more info on JSONata you may refer the following link. https://jsonata.org/ To understand the Kumologica data mapping lets create an which will accept a JSON data as an API request which will be mapped to a new JSON data structure and provide as API response. The request JSON data will also be sorted in descending order when mapping is done. Kumologica data mapper node will achieve both mapping and sorting function together. API Now let’s get started. Pre-requisite Downloaded and Installed Kumologica Designer.(Required) https://kumologica.com/download.html Walkthrough on tutorial.(Optional). https://medium.com/@kumologica Developing an API Open the Kumologica Designer and project. create a new Drag and drop node from the palette on to the designer canvas. EventListener Configure the node with the Source as . as and as EventListener API Gateway Verb POST path /employee. Drag and drop an node from the palette on to the designer. datamapper On the section of the datamapper node paste the following Sample Input [
       { : , : },
          { : , : },
       { : , : },
          { : , : }

    ] "Candidate_Name" "Arun" "Candidate_Age" "25" "Candidate_Name" "John" "Candidate_Age" "32" "Candidate_Name" "Sarah" "Candidate_Age" "22" "Candidate_Name" "Harry" "Candidate_Age" "28" On the section of the datamapper node paste the following mapping expression. Mapping $sort(
       $map(
           msg,
           (
               function($l){
                   { : $l.Candidate_Name, : $l.Candidate_Age
       
                   }

    }
           )

    ),
       function($l,$r){$l.Emp_Age < $r.Emp_Age}
    ) "EmpName" "Emp_Age" On the Result section (Bottom) of the datamapper node you could see the resultant output that would be generated by the node after running the mapping expression against the sample input JSON data provided. Following is the resultant output . [
        { : , : },
        { : , : },
        { : , : },
        { : , : }
    ] "EmpName" "Jhon" "Emp_Age" "32" "EmpName" "Harry" "Emp_Age" "28" "EmpName" "Arun" "Emp_Age" "25" "EmpName" "Sarah" "Emp_Age" "22" As you can see the output shown has mapped the JSON request to a new structure and also sorted the records in descending order. Result 6. Now Drag and drop the node on to the canvas. EventListener End 7. Open the settings for and configure the payload as and leave rest of the values as default. EventListener End msg.payload 8. Wire the EventListener node to Datamapper node and Datamapper node to EventListenerEnd node. The final flow would like as given below. Deployment Now let’s deploy the flow to AWS lambda. Before deployment select the AWS profile under the cloud tab. Also ensure that your AWS profile selected is having associated. If proper role is not associated the flow will fail to deploy to AWS. Kumologica Designer Role Now Click . Deploy Once the deployment is completed you will get the endpoint url to invoke the service from any of your favourite client. The url will look like as shown below. https://t7cq0rkdk.execute-api.ap-southeast-1.amazonaws.com/test/employee Conclusion The mapping mechanism in Kumologica was easy and follows function chaining which allows to build sophisticated query expressions with minimal syntax. The designer gives quick preview without deploying and running the whole flow which saves a lot of time. JSONata expression language looks more or less similar to Mulesoft Dataweave. So If you are familiar with dataweave then JSONata would require zero or minimal learning curve. If you want to try out this application you can clone the repo using the below given Github url or import the flow json into your project workspace in designer. https://github.com/ab73863/kumologica-datamapper References https://kumologica.com/ https://jsonata.org/

How To Do Data Mapping in Kumologica

Many of us must have asked this question in various forums and communities — “What are some of the SaaS startups in India?”. While the data is scattered all over, we felt that there wasn’t a single place where one could find this data. There are several hundreds of SaaS companies. This list had just a few dozen startups in 2014 and was a side project on our blog. Thanks to community comments, it grew huge. Now to make it even bigger, we are publishing it on Medium. We truly hope that this helps a bunch of potential startup talent, investors, marketers and many more. This is a continuously evolving list. Please drop in a comment with your SaaS startup or recommendation and I will add it. If you are interested to improve this listing by categorizing startups into product categories or such, reach out to Tejaswi: tej466@gmail.com A _CRM for Small Businesses_ _Revolutionise Customer Support on Social Media_ _Integrated Application Suite for Business & Schools_ _Appointment Scheduling Software_ _Online CRM, Invoicing, Project Management & Timesheets Software_ AgileCRM Airwoot Applane Appointy Apptivo Around.io Social Media Tool for Online Sellers B _Customer Segmentation & Marketing Automation for Ecommerce_ _Online Invoicing System & Online Billing Software_ Betaout Billbooks Build a Bazaar Ecommerce Software to build an Online Store C _Voice Broadcasting & SMS Marketing Software_ _All in One Marketing Software_ _Customer Engagement Management Solutions_ _Human Resource Management System_ _Workflow Automation Software_ _Subscription Billing & Recurring Billing Solution_ _Coaching Classes Management Software_ _Sales CRM for Small Teams_ _Full Stack DevOps Platform_ _Social Work Management Platform_ _Collaborative Spreadsheet Tool_ _Competitive Intelligence for Enterprises and Teams_ _Plug and Play Predictive Customer Analytics Platform_ _Big Data Analytics_ CallHub Canvass Capillary cavinHR Cavintek ChargeBee ClassPro ClinchPad CloudMunch CollaborateCloud CollateBox Contify CustomerLabs Crayon Data Crowdfire Social Media Engagement App for Twitter & Instagram CRMnext CRM Software Solutions for Banking, Insurance, Financial Services & Media D _Easy-to-access data APIs_ _Project Collaboration Software For Small Business & Teams_ _Clinic and Practice Management Software for Doctors_ _Full Stack ERP for E-Commerce_ Dataweave DeskAway DocEngage Dsysh Dquip Lead & Sales Management Software E _HRM Software_ _HR and Payroll Software_ _Business Phone System from the Cloud_ EmployWise Emportant Exotel Explara Online Event Ticketing & Registration Platform F _School Management Software_ _Practice Management Software For CA, CPA, Accounting Firms_ _eCommerce Marketing Automation Software_ _Online GRC Solution for Audit Risk Compliance_ _Big Data Analytics_ _Online Contact Form Builder_ _Online Collaboration, Communication and Real Time Feedback Tool_ _ECommerce website solution_ _Online Customer Support & Helpdesk Solution_ Fedena Firmzen Firecart FixNix Formcept FormGet Framebench FreKart Freshdesk FusionCharts JavaScript Charts for Web, Mobile & Apps G _Cloud Based HR & Payroll Software for SMEs_ _Cloud Based Productivity Platform for work_ GreyTip Gridle GrownOut Automated Referrals Hiring Process H _Platform to code, learn, compete and discover best jobs for developers_ _Platform for programmers to hone skills and for companies to recruit_ _Global Visitor Management Solution_ _Web based Hotel Management System, PMS Software_ HackerEarth HackerRank Happy Visitor Hotelogix Hive Email Based Collaboration Software HRStop Hosted Human Resource Management/Information System I _Online multi channel customer support and helpdesk solution_ Impel Indix Product Intelligence Platform for Brands, Retailers & Developers J _Psychometric Test Online Software_ Jombay JusPay Online Payment Solution K _DIY Ecommerce Platform for Indian SMEs_ _Help Desk and Customer Service Software_ _Business Process Management Tool & Workflow Software_ KartRocket Kayako KiSSFLOW Kreato CRM CRM software for SMBs L _Big Data Analytics Solution_ _Lead Management Software_ _Marketing Automation & Lead Management Software_ LatentView LeadPrime LeadSquared Lybrate Healthcare Platform Connecting Patients and Doctors M _Multichannel Ecommerce Platform_ _Attachments Management System_ _Online Skill Assessment Platform_ _One-stop Technology Solution Dedicated to Events_ _Computational Financial Analytics Platform_ _Cloud-based Training Solution_ _iBeacon Proximity Marketing and Analytics Platform_ _Targeted Marketing Platform for Mobile Apps_ _Software for DMC & Tour Operators_ MartJack MetisMe Mettl MeraEvents MilkorWater MindTickle MobStac MoEngage Moxiter MyOperator Cloud Based Phone System for Small Businesses N Nittio Learn Learning automation for businesses O _Open Source ERP and CRM_ _Sales Force Automation Software_ _PaaS-Based Cloud Application Development Platform_ _Cloud Based Accounting Application_ Odoo OpusViz OrangeScape Owlgrin Ozonetel Cloud Communication Application Provider P _Telecom Operations Management_ _An Online Gamification Platform_ _SMS & Voice API to Build Apps_ _Real time Customer Analytics_ _Point of Sales System for Restaurants_ _Online Medical Practice Management Software_ _Cloud Based Physician Practice Management Solution_ _Online Accounting Software for SMBs_ _DaaS Provider for Large-Scale Data Needs_ Pervazive Playlyfe Plivo Plumb5 Posist Practo Praxify ProfitBooks Prompt Cloud ProofHub Online Project Management Software Q Qubole Big Data as a Service (BDaas) Platform R _SEO Management Platform_ _Online Accounting & Billing_ _Online Recruiting and Resume Management_ RankWatch ReachAccountant RecruiterBox Relecura Platform for Patent/Portfolio Analysis & IP Business Intelligence S _Web Based CRM Software Platform_ _Social Commerce Store Builders_ _Content Protection and Anti-Scrapping Solution_ _ECommerce Store Building Platform_ _A Social Media Monitoring & Analytics Platform_ _Social Media Marketing and Monitoring Platform_ _Mobile-first ECommerce Platform_ _HR & Payroll Management Software_ _Help Desk Software_ SalesBabu SellMojo ShieldSquare Shopnix Simplify360 SocialAppsHQ StoreHippo sumHR SupportBee Synergita Talent and Performance Management Software T : _Create chatbots with no Programming Knowledge at all_ Tars Typito : Make video editing simple and accessible for all U _Ecommerce Product Discovery & Recommendation Platform_ _Ecommerce Management Software & Fulfillment Solutions_ _Solving Mystery Of App Uninstalls_ _Social Media Analytics_ Unbxd UniCommerce Uninstall.io Unmetric UsersDelight Customer Engagement and Growth Tool for Website & Mobile App V _Free People Search Technology_ _Actionable & Intelligent Video Analytics Suite_ _Viral Marketing and Customer acquisition Platform_ Vibe Vidooly ViralMint VWO A/B Testing Tool and Conversion Optimization Platform W _Customer Engagement Tool for Websites_ _ERP School Management and Administrative Software_ _How To Guides for Websites_ _Hosted CRM for SMEs_ _Ecommerce Software to Build an Online Store_ WebEngage Web-School WhatFix WindCRM WorldMart workXmate Cloud ERP Software for SMEs X Y Z : CRO Software with A/B Testing, Heatmaps, Funnel Analysis & Form Analytics. _ECommerce Platform for SMBs_ _Cloud Based Human Resource Management Software_ _Cloud Based Accounting Software_ _Enterprise grade solution for shortening of URLs, branding a domain & gathering statistics_ Zarget Zepo ZingHR ZipBooks ziplr Zoho Online Business, Network, and IT Infrastructure Management Applications 0–9 99tests Software Testing Community

Massive List of 100+ SaaS Companies in India

How I Use AI in Frontend Development

3 Quick Ways to Optimize RecyclerView

RecyclerView অপ্টিমাইজ করার 3টি দ্রুত উপায়

3 schnelle Möglichkeiten zur Optimierung von RecyclerView

Tres formas rápidas de optimizar RecyclerView

3 façons rapides d'optimiser RecyclerView

रीसाइक्लरव्यू को अनुकूलित करने के 3 त्वरित तरीके

RecyclerView を最適化する 3 つの簡単な方法

RecyclerView를 최적화하는 3가지 빠른 방법

3 maneiras rápidas de otimizar o RecyclerView

3 быстрых способа оптимизировать RecyclerView

RecyclerView'ı Optimize Etmenin 3 Hızlı Yolu

3 cách nhanh chóng để tối ưu hóa RecyclerView

优化 RecyclerView 的 3 种快速方法

Most of the time when I’m developing applications, I default to using some form of SQL. Whether it’s a simple application using SQlite or something a bit more robust that I plan to scale out with MySQL, it’s inevitably some flavor of SQL. However, when starting new projects over the past few years I’ve been trying to make sure I have experience with document databases and have spent more time using in C#. MongoDB In this article, I’ll guide you through some basics for being able to insert data using MongoDB in C#. We’ll keep it light and to the point, so let’s dive into a brief overview of MongoDB in C# followed by some code examples in C#! Overview of MongoDB in C# MongoDB is a widely used NoSQL database that provides a flexible and scalable solution for data storage. One of the key benefits of MongoDB is its document-oriented nature so instead of using tables with fixed schemas like in traditional relational databases, MongoDB stores data in collections of JSON-like documents. This can allow for a more flexible and dynamic data model, especially in scenarios where data structures can vary. In C#, you can seamlessly integrate MongoDB into your applications because MongoDB provides a native driver for C#. This simplifies the process of interacting with the database and provides a comfortable development experience for C# developers. Well, mostly. If you’re used to using SQL connections, SQL command objects, and classes to access your data, it’s a little bit more cumbersome. But this is coming from the perspective of someone who prefers to write raw SQL queries in their data access layer. I suspect if you didn’t have this bias then working with their API, especially for filtering, would feel pretty intuitive. DataReader One big thing you’ll want to keep in mind if you’re coming from a relational database background is understanding the primary differences between relational and document databases. In the former, we generally denormalize data across tables and, in the latter, we write the data as a document that we’d like to read back without having to join. These types of databases aren’t designed to join data like we do with relational databases, so it’s something to be aware of! Follow Along with MongoDB in C# Content I always try to make sure I provide multiple modes of content when I’m able to. Below, you’ll find a YouTube video walking through examples of MongoDB in C# for inserting records: https://youtu.be/0fB9qg-oR04?embedable=true Of course, if you’d rather play around with some working code (aside from ensuring you have your own database), you can find the example code on my . You should be able to clone it, set up your connection string properly, change your database and collection names as needed, and then rock and roll! Dev Leader GitHub repository here Inserting Documents into MongoDB in C# In this section, I’ll explain how to insert documents into MongoDB using C#. We’ll look at code examples using the and methods. We’ll see these methods in their synchronous and asynchronous forms! Remember, you will need to ensure you have the “MongoDB.Driver” NuGet package installed in your project for the following code examples to work. InsertOne InsertMany Using the InsertOne and InsertOneAsync Methods To insert a single document into a MongoDB collection synchronously, use the method. This method is straightforward and is executed immediately, blocking the current thread until the operation completes. Here’s a basic example: InsertOne using MongoDB.Bson;
using MongoDB.Driver;

// Connect to MongoDB instance
var client = new MongoClient("mongodb://localhost:27017");

// Select database
var database = client.GetDatabase("testDatabase");

// Select collection (sort of like a SQL "table")
var collection = database.GetCollection<BsonDocument>("myCollection");

var document = new BsonDocument
{
    { "name", "John" },
    { "age", 30 }
};

// Insert document into collection
collection.InsertOne(document); In this example: We first establish a connection to the MongoDB instance and select our database and collection. Then, we create a object, which represents the document we want to insert. BsonDocument Finally, we call on our collection object, passing in the document. This inserts the document into the specified collection. InsertOne For asynchronous operations, you can use . This method is especially useful in applications that require non-blocking operations, such as web applications or services, to maintain responsiveness. Here’s how to use it: InsertOneAsync using MongoDB.Bson;
using MongoDB.Driver;
using System.Threading.Tasks;

// just like the former example
var client = new MongoClient("mongodb://localhost:27017");
var database = client.GetDatabase("testDatabase");
var collection = database.GetCollection<BsonDocument>("myCollection");

var document = new BsonDocument
{
    { "name", "Jane" },
    { "age", 28 }
};

// Asynchronously insert document
await collection.InsertOneAsync(document, cancellationToken: CancellationToken.None); In this asynchronous example: The setup is similar to the synchronous version, but we use with . This tells the program to continue with other work that doesn’t depend on the completion of the insert operation. await InsertOneAsync Take note that you can pass in a cancellation token here which is a best practice for async code Note that both and methods throw exceptions if the insert operation fails, so you should use try-catch blocks to handle potential errors gracefully. InsertOne InsertOneAsync Using the InsertMany and InsertManyAsync Methods The method synchronously inserts a list of document objects into the specified collection. This is useful when you have multiple documents ready to be stored and want to execute the operation in a single call. Here’s an example: InsertMany using MongoDB.Bson;
using MongoDB.Driver;
using System.Threading.Tasks;

// just like the former example
var client = new MongoClient("mongodb://localhost:27017");
var database = client.GetDatabase("testDatabase");
var collection = database.GetCollection<BsonDocument>("myCollection");

var documents = new List<BsonDocument>
{
    new BsonDocument("name", "John").Add("age", 30),
    new BsonDocument("name", "Jane").Add("age", 25),
    new BsonDocument("name", "Doe").Add("age", 28)
};

collection.InsertMany(documents); In this example, we first get a reference to our collection. Then, we of objects, each representing a document to insert. Finally, we call with our list of documents. This method will insert all documents in the list into the MongoDB collection in one operation. create a list BsonDocument InsertMany For asynchronous operations, particularly useful in applications where responsiveness is crucial or when dealing with I/O-bound tasks, you can use the method. This method works similarly to , but it performs the operation asynchronously. Here’s an example: InsertManyAsync InsertMany using MongoDB.Bson;
using MongoDB.Driver;
using System.Threading.Tasks;

// just like the former example
var client = new MongoClient("mongodb://localhost:27017");
var database = client.GetDatabase("testDatabase");
var collection = database.GetCollection<BsonDocument>("myCollection");

var documents = new List<BsonDocument>
{
    new BsonDocument("name", "John").Add("age", 30),
    new BsonDocument("name", "Jane").Add("age", 25),
    new BsonDocument("name", "Doe").Add("age", 28)
};

await collection.InsertManyAsync(documents); In this asynchronous version, we use before calling , ensuring that the operation completes before moving on to the next line of code. This is especially important in web applications or services where blocking the main thread could lead to poor performance or user experience. await InsertManyAsync Best Practices for Efficiently Inserting Data This article is focused on the API usage of inserting data into MongoDB using C#, but I wanted to touch on a few other points. To improve the efficiency of data insertion in MongoDB, you can consider the following best practices: Batch Inserts: Instead of inserting one document at a time, you can batch multiple documents together and insert them in a single operation using InsertMany. This reduces the overhead of multiple round-trips to the database. Use Indexes: Indexes can significantly improve the insert performance by speeding up the search for the correct position to insert the new document. Ensure that you have appropriate indexes defined on the fields commonly used for insertion. Consider Sharding: If you have a large amount of data to insert, sharding can distribute the data across multiple servers, improving insertion performance. Write Concern: The default write concern in MongoDB is Acknowledged, which waits for an acknowledgment from the server. If you are performing bulk insertions and do not require immediate acknowledgment, you can set a lower write concern to improve performance. Consider Asynchronous Operations: Asynchronous operations can improve the responsiveness of your application by allowing multiple insert operations to be executed concurrently. Aside from asynchronous versions of these APIs which were mentioned earlier, I won’t be covering these other topics in more detail in this article. Stay tuned for upcoming articles where I cover these topics along with other functionality, such as updating documents in MongoDB and deleting records! Wrapping Up MongoDB in C# To recap, in this article, we explored the topic of writing data to MongoDB in C# using InsertOne and InsertMany APIs. We saw both the synchronous and asynchronous versions of these APIs in functional code examples. Some of the key takeaways: Understanding relational database vs document database characteristics Best practice considerations for performance Synchronous vs asynchronous APIs for inserting data to MongoDB in C# You should continuously improve your skills and stay updated with the latest technologies! If you found this useful and you’re looking for more learning opportunities, consider and check out my ! subscribing to my free weekly software engineering newsletter free videos on YouTube

Simplified Guide For Inserting Data Into MongoDB Using C#

In this article, I aim to share my experience standardizing the ETL process within frameworks like Spark and Flink, particularly for those not using data processing frameworks like dbt. Context Data processing is a comprehensive field that encompasses the regular processing of substantial information volumes in both batch and stream modes. These procedures, often referred to as ETL processes, are developed using a variety of programming languages and frameworks. Typically, the main stages of data processing are as follows: Data is collected from various sources for subsequent processing. Reading data: The data undergoes various transformations and manipulations to attain the required structure and format. Transformation: The transformed data is then stored in the target storage. Writing: Schematically, it is represented as shown in the diagram: Challenges After the main stages are implemented, several other stages can be added to enhance and refine the process: This stage involves verifying data compliance with requirements and expectations, including data cleaning to ensure accuracy and completeness. Data quality check: The registration process tracks and documents available data sets. It may also involve data and metadata management for effective data organization. Data registration in the data catalog: This allows visualization of relationships between data assets and ETL processes to understand dependencies. It can help identify potential data quality issues and improve overall data quality. Building data lineage: Additional processing may define the level of data confidentiality and criticality, ensuring proper data protection and security. Data classification: Each of the stages mentioned can be implemented using various technologies and tools, allowing flexibility in choosing the right solution for each specific stage of data processing. Solution Reading data The first step in the ETL process involves reading data from the source. Various types of sources may be used at this stage, such as files, databases, message brokers, and more. The data may also come in different formats, such as CSV, JSON, Parquet, Delta, Hudi, etc. Here is some boilerplate code for reading data from these different sources (implemented as Strategy pattern): from abc import ABC, abstractmethod
from pyspark.sql import SparkSession, DataFrame

# Define the strategy interface
class ReadStrategy(ABC):
    @abstractmethod
    def read_data(self) -> DataFrame:
        pass

# File System Read Strategy - represents a file system reading    
class FileSystemReadStrategy(ReadStrategy):
    def __init__(self, spark: SparkSession, path: str):
        self.spark = spark
        self.path = path
    
    @abstractmethod
    def read_data(self):
        pass
    
# Implement the strategy for CSV
class CSVReadStrategy(FileSystemReadStrategy):
    def read_data(self) -> DataFrame:
        return self.spark.read.format("csv").option("header", "true").load(self.path)


# Implement the strategy for Delta
class DeltaReadStrategy(ReadStrategy):
    def read_data(self) -> DataFrame:
        return self.spark.read.format("delta").load(self.path)

# Implement the strategy for Parquet
class ParquetReadStrategy(ReadStrategy):
    def read_data(self) -> DataFrame:
        return self.spark.read.format("parquet").load(self.path)

# Context class
class DataReader:
    def __init__(self, read_strategy: ReadStrategy):
        self.read_strategy = read_strategy

    def read(self) -> DataFrame:
        return self.read_strategy.read_data() Usage example: spark = SparkSession.builder.appName("our-ETL-job").getOrCreate()
path = "path-to-our-data"
src_df = DataReader(DeltaReadStrategy(spark, path)).read() This approach offers several benefits: It enables the alteration of the reading strategy (source format). It facilitates the addition of new reading strategies without modifying existing code. Each strategy can have its unique parameters. For example, CSV may have a delimiter, while Delta may have a version, etc. Instead of providing a path, we can create a dedicated class, like , which can hold all necessary data reading parameters. ReadConfig It allows the incorporation of additional logic into strategies without affecting the main code. For instance: We can call by default for a file source. input_file_name() If we have a data catalog, we can check whether the table exists there and register it if not. Each strategy can be tested individually. Transformation After reading the data, it must be transformed. This can include various operations like filtering, aggregating, and joining. Since the transformation process can be complex and time-consuming, it's crucial to standardize it for ease of understanding. From my experience, using the method of the DataFrame API is an effective way to standardize this process. This method lets us chain multiple transformations, enhancing code readability. Each transformation can be declared as a separate pure function, performing a specific transformation, and can be tested independently. transform import pyspark.sql.functions as F
from pyspark.sql import DataFrame

desired_columns = ["name", "age", "country"]

def with_country_code(df: DataFrame) -> DataFrame:
    return df.withColumn("country_code", F.when(F.col("country") == "USA", "US").otherwise("Other"))

def with_age_category(df: DataFrame) -> DataFrame:
    return df.withColumn("age_category", F.when(F.col("age") < 18, "child").when((F.col("age") >= 18) & (F.col("age") < 65), "adult").otherwise("senior"))

def filter_adult(df: DataFrame) -> DataFrame:
    return df.filter(F.col("age_category") == "adult")

def select_columns(columns: list) -> callable[[DataFrame], DataFrame]:
    def inner(df: DataFrame) -> DataFrame:
        return df.select(columns)
    return inner

transformed_df = (src_df
                  .transform(with_country_code)
                  .transform(with_age_category)
                  .transform(filter_adult)
                  .transform(select_columns(desired_columns))
                  ) Writing The last stage in the ETL process is writing the transformed data into the target storage, which could be a file system, a database, or a message broker. The loading phase may also incorporate extra steps like data validation, data registration, and data lineage. For this stage, we can apply the same methods as reading data, but with writing strategies. from abc import ABC, abstractmethod
from pyspark.sql import DataFrame, SparkSession

class WriteStrategy(ABC):
    @abstractmethod
    def write_data(self, df: DataFrame):
        pass

class FileSystemWriteStrategy(WriteStrategy):
    def __init__(self, spark: SparkSession, path: str, format: str, mode: str = "overwrite"):
        self.spark = spark
        self.path = path
        self.format = format
        self.mode = mode

    def write_data(self, df: DataFrame):
        df.write.format(self.format).mode(self.mode).save(self.path)

class DataWriter:
    def __init__(self, write_strategy: WriteStrategy):
        self.write_strategy = write_strategy

    def write(self, df: DataFrame):
        self.write_strategy.write_data(df) Usage example: path = "path-to-our-data"
writer = DataWriter(FileSystemWriteStrategy(spark, path, "delta"))
writer.write(transformed_df) Conclusion This implementation standardizes the ETL process, making it more comprehensible and maintainable. It facilitates the addition of new reading and writing strategies without modifying existing code. Each strategy can possess unique parameters, and additional logic can be incorporated into strategies without disrupting the main code. The approach also enables separate testing of each strategy. Moreover, we can introduce additional stages to the ETL process, such as data quality checks, data registration in the data catalog, building data lineage, and data classification.

Dev Standards for Spark-jobs

স্পার্ক-জবসের জন্য ডেভ স্ট্যান্ডার্ড

Entwicklungsstandards für Spark-Jobs

Estándares de desarrollo para trabajos Spark

Normes de développement pour les tâches Spark

स्पार्क-नौकरियों के लिए विकास मानक

Spark ジョブの開発標準

Spark 작업을 위한 개발 표준

Padrões de desenvolvimento para trabalhos Spark

Стандарты разработки для Spark-заданий

Spark işleri için Geliştirme Standartları

Tiêu chuẩn dành cho nhà phát triển cho công việc Spark

Spark 作业的开发标准

This blog will cover holistically: (a) What data warehousing is (b) Data modeling approaches for Data warehouse (c) Data warehouse on AWS, and lastly (d) Data warehousing for reducing operational load using Managed Service. Let’s understand from a layman’s perspective “ ” What a Data warehouse is As per - Wikipedia a data warehouse (DW or DWH), also known as an enterprise data warehouse (EDW), is a system used for reporting and data analysis and is considered a core component of . Data warehouses are central repositories of integrated data from one or more disparate sources. They store current and historical data in one single place that is used for creating analytical reports for workers throughout the enterprise. This is beneficial for companies as it enables them to interrogate and draw insights from their data and make decisions. business intelligence In basic terms, it is the art of collecting, storing, and efficiently providing insights (business intelligence) to help a business become a data-driven organization. In some sense it’s another transaction database but one that is optimized for analytical workloads. As per the above diagram, data is collected from the source, transformed per usage (ETL/ELT), and stored in DWH/Data mart and Insights exposed via business intelligence tools. All looked simple back in the days of on-prem setup when ELT (ETL vs ELT), Cloud DWH (AWS Redshift, Google Big Query, Snowflake, Databricks), and other Managed Data solutions were non-existent, which lately simplified and scaled the reach of DWH. In this blog let’s understand every aspect one at a time. For simplicity let’s go with the premise that there is no infinite compute & storage and that the transactional system can’t process analytical queries efficiently. This is where an efficient way was required to design a data warehouse that is optimal in storage, efficiently handles analytical queries (Slicing/dicing/Cube, etc), and provides required latency. For all this, two theoretical design model for came into the picture by: Datawarehouse design (a) Bill Inmon – Top Down approach (EDW) and (b) Ralph Kimball – Bottom-up approach (Data mart). Inmon’s approach is to build at a global scale centrally and factor in slow build whereas Kimball's way is to make an independent data mart by silo and connect together later. Let’s not dive into which model is best or which to choose. In my case, in a nutshell, both models work and it totally depends on the use case and maturity of the organization. Another key point in this design is the “Data Representation”, Dimensional modeling using Star Schema, Snowflake schema, or a Hybrid of Star and snowflake which is a key pivot of faster querying and dimensionality. The only key takeaway is despite infinite logistics, a good Datawarehouse design can solve a multi-dimensional problem. So, better not to ignore it. The next step in is the platform of choice which can vary from on-premise (Teradata, IBM DB2, Oracle, etc) to Cloud DW (Snowflake, Redshift, BigQuery, etc). Building a traditional data warehouse is complex, and ongoing management and maintenance can be challenging and expensive. In the next section, we will dive into how to build with AWS Redshift (no argument if on-prem is better or Cloud or which cloud DWH is better). Building a DW Amazon Redshift is a fully managed petabyte scale enterprise-grade data warehouse that provides exceptional performance for analytics queries which is simple to use and cost effective. Amazon Redshift reduces the operational overhead required with traditional data warehouses by automating tasks such as patching, backups, and hardware provisioning. You can configure an Amazon Redshift cluster where you can customize the infrastructure and performance baselines for your data warehouse. Amazon Redshift also provides Redshift Spectrum, Datashare, Redshift ML, and Serverless setup which allows you to use Amazon Redshift cluster beyond DWH. The way to Setup, Define what services to leverage for data collection (AWS DMS, DynamoDB, EMR, Glue, Kinesis, S3, SSH Host, etc) Define a way to interact (Query analysis tools and Management Interfaces) Understand Redshift MPP architecture (Distributed, shared-nothing) Launch Cluster (DC2, DS2, or RA3) with required data size, growth, node, and query performance Design database schema as per use case or DWH implementation with required Data type, schema type, compression, buffer, encoding Loading data using COPY for different file types, INSERT for minimal alter, and ANALYZE & VACUUM for maintenance Perform query optimization and performance enhancement Leverage S3 using Spectrum for external table and Data share for zero-copy Use Redshift ML for deep insights Leverage AWS Quicksight for BI tooling to get insights. So far it makes sense to use Cloud DWH but ?  The image below explains how Data Lakes and Data Warehouses work together seamlessly. AWS RDS serves as the data source, providing a cost-effective and durable solution, that feeds into . The data is then transformed using ETL processes and onboarded into Redshift. Additional AWS services such as Athena, Glue, Spectrum, Lake Formation, and others play a crucial role in bridging the gap to create a comprehensive Data Solution. How does this fit in the Big scheme of things DWH + Data Lake/Managed Services for Data solution Amazon S3 In conclusion, this blog covers the fundamentals of Data Warehousing, delves into the implementation approach both theoretically and with a focus on the tech stack. We also gain a bird's-eye view of how it seamlessly integrates into the broader landscape of data solutions.

Understanding How Data Warehousing on AWS Works

AWS-এ ডেটা গুদামজাতকরণ কীভাবে কাজ করে তা বোঝা

Verstehen, wie Data Warehousing auf AWS funktioniert

Comprender cómo funciona el almacenamiento de datos en AWS

Comprendre le fonctionnement de l'entreposage de données sur AWS

यह समझना कि AWS पर डेटा वेयरहाउसिंग कैसे काम करती है

AWS でのデータ ウェアハウジングの仕組みを理解する

AWS의 데이터 웨어하우징 작동 방식 이해

Compreendendo como funciona o armazenamento de dados na AWS

Понимание того, как работает хранилище данных в AWS

AWS'de Veri Ambarlamanın Nasıl Çalıştığını Anlamak

Tìm hiểu cách hoạt động của kho dữ liệu trên AWS

了解 AWS 上的数据仓库的工作原理

Hello everyone, my name is Dmitrii Ivashchenko, and I'm a Software Engineer at MY.GAMES. In this article, we'll talk about developing a user interface in Unity based on states and markup of elements. Intro First of all, it should be noted that we'll be talking in the context of the (uGUI) technology, which is still recommended for Runtime . The approach described is not applicable to , , or other UI building systems. Unity UI according to the documentation UI Toolkit IMGUI Most often in projects, you'll come across UI implementation built on View classes inherited from and peppered with a large number of fields. This approach provides full control over the behavior of the UI, but it also makes it necessary to write a large amount of code at the View and Presenter levels (depending on the architecture used). Unity MonoBehaviour SerializeField Often, as project development continues, these classes swell to incredible sizes, and the components on GameObject themselves are covered with a huge number of links to internal objects: Modifying components like this is also not enjoyable: to get a reference to a new element in a class, you need to add , recompile the code, find the new field in the prefab component, and drag the necessary object into it. As the project grows, the compile time, the number of fields, and the complexity of organizing prefabs also increase in turn. SerializeField As a result, we end up with bulky and overloaded subclasses of (or a large number of small ones, depending on your preference). MonoBehaviour It's also worth considering that any changes to the behavior of such a UI is a task for the programmer, and that task comes with all the associated costs: code review, resolving merge conflicts, code coverage with tests, and so on. I'd like to highlight the implementation of windows with multiple states. I have seen many variations, which can be divided into two approaches: First, any change in the window state occurs . To change the color of text, change an image, play an animation, move an object on the screen — all the involved objects and parameters require a corresponding , and then a large amount of code is written to make it work according to the requirements. Naturally, only a programmer can handle this, and the implementation turns out to be lengthy, expensive, and super-efficient (often much more efficient than anyone can notice). using code SerializeField Another approach can be described as the “ ”. In addition to the View class, an Animator Controller is created and controlled through parameters. A new Animator appears in the new window, and so on, until the FPS when displaying windows begins to drop. all-powerful Animator Now that we've highlighted some of the difficulties of working with uGUI, I would like to talk about a different approach to solving this problem. Stateful UI During my work on one of my pet-projects, I developed a library for structured UI development in Unity. Later, my team and I tested it on production and we were pleased with the results. . The source code for the library is available for download on GitHub Stateful Component The key element of the library is the component. This component is placed on the root GameObject of each screen and contains all the necessary references to internal elements, distributed across tabs: StatefulComponent Each link is named based on  its . From a code perspective, the set of roles is a regular . Separate sets of roles are prepared for each type of UI element (buttons, images, texts, etc.): role enum public enum ButtonRole { ... }
public enum ImageRole { ... }
public enum TextRole { ... }
... Roles are generated directly from the component, and there is no need to manually edit the . Waiting for recompilation when creating a role is also not necessary, as these elements can be used immediately after creation. enum enum To simplify merge conflicts, enumeration values are calculated based on the names of the elements: [StatefulUI.Runtime.RoleAttributes.ButtonRoleAttribute]
public enum ButtonRole
{
    Unknown = 0,
    Start = -1436209294, // -1436209294 == "Start".GetHashCode()
    Settings = 681682073,
    Close = -1261564850,
    Quests = 1375430261,
} This allows you to avoid breaking serialized values in prefabs if you and your colleagues happen to simultaneously create new roles for buttons in different branches. Each type of UI element (buttons, texts, images) is located on its own tab: By using roles, the complete markup of all elements inside the prefab is achieved. Sets of are no longer needed to access images and texts, and it is enough to have one reference to and know the role of the desired image in order to, for example, replace its sprite. SerializeField StatefulComponent The types of elements that are currently accessible are: Buttons, Images, Toggles, Sliders, Dropdowns, VideoPlayers, Animators Texts, including and UnityEngine.UI.Text TextMeshProUGUI TextInputs, including and UnityEngine.UI.InputField TMP_InputField Objects — for references to arbitrary objects. There are corresponding methods for working with annotated objects. In the code, you can use a reference to or inherit the class from : StatefulComponent StatefulView public class ExamplePresenter
{
    private StatefulComponent _view;

    public void OnOpen()
    {
        _view.GetButton(ButtonRole.Settings).onClick.AddListener(OnSettingsClicked);
        _view.GetButton(ButtonRole.Close).onClick.AddListener(OnCloseClicked);
        _view.GetSlider(SliderRole.Volume).onValueChanged.AddListener(OnVolumeChanged);
    }
}

public class ExampleScreen : StatefulView
{
    private void Start()
    {
        SetText(TextRole.Title, "Hello World");
        SetTextValues(TextRole.Timer, hours, minutes, seconds);
        SetImage(ImageRole.UserAvatar, avatarSprite);
    }
} Texts and Localization The tab with texts, in addition to the role and link to the object, contains the following columns: Code: a text key for localization Localize checkbox: an indicator that the text field is subject to localization Value: the current text content of the object Localized: the current text found by the key from the Code field The library does not include a built-in subsystem for working with translations. To connect your localization system, you'll need to create an implementation of the interface. This can be constructed, for example, based on your Back-end, ScriptableObjects, or Google Sheets. ILocalizationProvider public class HardcodeLocalizationProvider : ILocalizationProvider
{
    private Dictionary<string, string> _dictionary = new Dictionary<string, string>
    {
        { "timer" , "{0}h {1}m {2}s" },
        { "title" , "Título do Jogo" },
        { "description" , "Descrição longa do jogo" },
    };

    public string GetPhrase(string key, string defaultValue)
    {
        return _dictionary.TryGetValue(key, out var value) ? value : defaultValue;
    }
} By clicking on the Copy Localization button, the contents of the Code and Value columns will be copied to the clipboard in a format suitable for pasting into Google Sheets. Internal Components Often, in order to facilitate reuse, separate parts of the UI are extracted into separate prefabs. also allows us to create a hierarchy of components, where each component only works with its own child interface elements. StatefulComponent On the Inner Comps tab, you can assign roles to internal components: Configured roles can be used in code similarly to other types of elements: var header = GetInnerComponent(InnerComponentRole.Header);
header.GetButton(ButtonRole.Close).onClick.AddListener(OnCloseClicked);
header.SetText(TextRole.Title, "Header Title");

var footer = GetInnerComponent(InnerComponentRole.Footer);
footer.GetButton(ButtonRole.Continue).onClick.AddListener(OnContinueClicked);
footer.SetText(TextRole.Message, "Footer Message"); Containers To create a list of similar elements, you can use the component. You need to specify the prefab for instantiation and the root object (optional). In Edit-mode, you can add and remove elements using : ContainerView StatefulComponent It's convenient to use for marking up the content of instantiated prefabs. In Runtime, you can use the methods , , or to populate the container: StatefulComponent AddInstance<T> AddStatefulComponent FillWithItems var container = GetContainer(ContainerRole.Players);

container.Clear();

container.FillWithItems(_player, (StatefulComponent view, PlayerData data) =>
{
    view.SetText(TextRole.Name, data.Name);
    view.SetText(TextRole.Level, data.Level);
    view.SetImage(ImageRole.Avatar, data.Avatar);
}); If the standard does not suit you for creating objects, you can override this behavior, for example, for instantiation using Zenject: Object.Instantiate() StatefulUiManager.Instance.CustomInstantiateMethod = prefab =>
{
    return _diContainer.InstantiatePrefab(prefab);
}; Internal Components and Containers provide static and dynamic nesting for , respectively. StatefulComponent We've considered the markup of prefabs, localization, and instantiation. Now it's time to move on to the most interesting part — developing UIs based on states. States We'll consider the concept of state as a named set of changes to a prefab. The name in this case is a role from the enum, and examples of changes to the prefab can be: StateRole Enabling and disabling a GameObject Replacing sprites or materials for Image objects Moving objects on the screen Changing texts and their appearance Playing animations And so on — you can add your own types of object manipulations A set of changes (State Description) can be configured on the States tab. A configured state can be applied directly from the inspector: A configured state can be applied from code using the method: SetState switch (colorScheme)
{
    case ColorScheme.Orange:
        SetState(StateRole.Orange);
        break;
    case ColorScheme.Red:
        SetState(StateRole.Red);
        break;
    case ColorScheme.Purple:
        SetState(StateRole.Purple);
        break;
} On the Tools tab, when the parameter is enabled, you can configure the State that will be applied immediately upon object instantiation. Apply Initial State On Enable Using states allows for a significant reduction in the amount of code required at the View class level. Simply describe each state of your screen as a set of changes in the and apply the necessary State from the code depending on the game situation. StatefulComponent State Tree Actually, developing a UI based on states is incredibly convenient. So much so that, over time, it leads to another problem — as the project evolves, the list of states for a single window can grow to an unruly length, and thus becomes difficult to navigate. In addition, there are states that only make sense in the context of some other states. To solve this problem, Statful UI has another tool: State Tree. You can access it by clicking on the State Tree Editor button in the States tab. Let's suppose we need to create a reward window for a chest. The window has 3 phases: Animated introduction of the chest (state ) Intro Looping appearance of three different types of rewards from the chest (states , , and , depending on the state, which triggers an animation of the reward appearing from the chest) Money Emoji Cards Reward Display of all awarded rewards in a single list (state ) Results Parent states (in this example ) are applied every time child states are called: Reward Managing a configured comes down to a minimal amount of simple and understandable code that populates the components with necessary data and switches states at the right moment: StatefulComponent public void ShowIntro()
{
    SetState(StateRole.Intro);
}

public void ShowReward(IReward reward)
{
    // Update the inner view with the reward
    reward.UpdateView(GetInnerComponent(InnerComponentRole.Reward));

    // Switch on the type of reward
    switch (reward)
    {
        case ICardsReward cardsReward: SetState(StateRole.Cards); break;
        case IMoneyReward moneyReward: SetState(StateRole.Money); break;
        case IEmojiReward emojiReward: SetState(StateRole.Emoji); break;
    }
}

public void ShowResults(IEnumerable<IReward> rewards)
{
    SetState(StateRole.Results);

    // Fill the container with the rewards
    GetContainer(ContainerRole.TotalReward)
        .FillWithItems(rewards, (view, reward) => reward.UpdateView(view));
} Stateful API & Documentation Roles are intended to provide a convenient and unambiguous way to name links and states for later use in the code. However, there are situations where describing a state would require a name that is too long, and it would be more convenient to leave a small comment about what this link points to, or what behavior the state reflects. For such cases, each link and state in a allows you to add a description: StatefulComponent You may have already noticed the Copy API and Copy Docs buttons on each tab — these copy information for the selected section. In addition to those, there are similar buttons in the Tools tab — these copy information for all sections at once. When you click the Copy API button, the generated code for managing this object will be copied to the clipboard. Here's an example for our rewards window: StatfulComponent // Insert the name of the chest here
SetText(TextRole.Title, "Lootbox");

// Button to proceed to the reward issuance phase
GetButton(ButtonRole.Overlay);

// Button to display information about the card
GetButton(ButtonRole.Info); 

// Container for displaying the complete list of awarded rewards
GetContainer(ContainerRole.TotalReward);

// Insert the card image here
SetImage(ImageRole.Avatar, null);

// Animated appearance of a chest
SetState(StateRole.Intro); When you click the Copy Docs button, the documentation for this prefab will be copied to the clipboard in Markdown format: ### RewardScreen

Buttons:
    - Overlay - Button to proceed to the reward issuance phase
    - Info - Button to display information about the card

Texts:
    - Title - Insert the name of the chest here

Containers:
    - TotalReward - Container for displaying the complete list of awarded rewards

Images:
    - Avatar - Insert the card image here

States:
    - Intro - Animated appearance of a chest
    - Cards - Displaying rewards in the form of a card
    - Money - Displaying rewards in the form of game currency
    - Emoji - Displaying rewards in the form of an emoji
    - Results - Displaying a complete list of issued rewards It's obvious that making a mistake when implementing this screen with such detailed instructions is quite difficult. You can easily maintain up-to-date information about your UI organization in the project's knowledge base. At the same time, Stateful UI allows for delegating the creation of UI prefabs. In fact, state-based markup allows for fully testing the prefab's behavior before passing it on to programmers. This means that , technical designers, or even separate UI developers can prepare prefabs. Furthermore, since an API is created between the code and prefab, programming and configuring prefabs can be done in parallel! All that is required is to formulate the API in advance. But, even if the task of configuring prefabs remains with programmers, using Stateful UI significantly speeds up this work. game designers Conclusion As we have seen, Stateful UI significantly simplifies working with UI element states. Long cycles are no longer needed to create SerializeFields, recompile code, and search for references amongst a huge number of View class fields. In the View classes themselves, it's no longer necessary to write a large amount of code for repetitive operations such as turning objects on and off or changing text color. The library allows for a consistent approach to organizing layouts in a project, marking objects within prefabs, creating states, linking them to UI elements, and providing an API and documentation for UI management. It also allows for delegating the creation of UI prefabs and speeds up work with them. Moving forward, the project roadmap includes the following items: Expanding the capabilities of States, supporting new types of UI changes in Description, such as new types of animations, playing sounds in states, and so on Adding support for color palettes for coloring text and images Adding support for lists of items with GameObjects reuse Supporting a larger number of Unity UI elements Automating the unloading of added texts for localization Implementing a Test Framework. Since we have exhaustive markup of our prefabs, we can create easy-to-set-up ScriptableObject-based scenarios in the following format: Click the button ButtonRole.Settings Check the text in to be equal to "some value" TextRole.SomeText Check the image in to ensure it is equal to a certain sprite ImageRole.SomeImage A tutorial system. Similarly to testing, marked layout allows creating ScriptableObject-based tutorial scenarios in the form of instructions like "Show pointer on the button ". ButtonRole.UpgradeHero . You're welcome to create issues or contribute to the library! The project source code is available on GitHub

Stories, News & Mentions about DATAWEAVE

Dataweave’s Stories on HackerNoon

Dataweave's News & Mentions