METADROB - Provider of a virtual store development platform for the metaverse.

METADROB - Company Profile - Tracxn

Metadrob | 3,252 followers on LinkedIn. Create your own Virtual e-commerce store | A Virtual e-commerce store creation platform enables you to provide your customers with an immersive and interactive virtual shopping experience. Metadrob allows retailers to build an interactive 3D virtual ...

Metadrob | LinkedIn

Metadrob was named in the “Innovative Companies to Watch in 2023” list by Alltech Magazine. Metadrob is a virtual e-commerce store creation platform that enables

Metadrob: No-code Virtual Showroom Creation Platform

We&#x27;re checking to see if you&#x27;re a bot · Please email support@f6s.com if you think you&#x27;re getting this screen in error · © 2023 F6S Network Limited. All rights reserved. F6S is a registered trademark

About Metadrob - Retail company in India

You need to enable JavaScript to run this app

Metadrob

Learn about Metadrob Jaipur office. Search jobs. See reviews, salaries &amp; interviews from Metadrob employees in Jaipur.

Metadrob Jaipur Office | Glassdoor

Metadrob Pvt. Ltd. - ... Job Overview:We are seeking dynamic and enthusiastic individuals to join our sales team as Sales Executives. As a fresher, you will have the opportunity to learn and develop essential sales skills while contributing to our company&#x27;s growth.

SALES EXECUTIVE - Metadrob Pvt. Ltd. | Jaipur, Rajasthan

Metadrob is Framing the new Business opportunities for ...

With Indeed, you can search millions of jobs online to find the next step in your career. With tools for job search, resumes, company reviews and more, were with you every step of the way.

How much does Metadrob Pvt. Ltd. in Jaipur, RJ pay?

The Metaverse, a virtual reality space where people can interact, socialize, and engage in various activities, is rapidly becoming a frontier for businesses.

How to Set Up a Virtual Store in the Metaverse | by Metadrob

How Metadrob help your furniture business generate more ...

Read writing from Metadrob on Medium. Metadrob: Your limitless gateway to crafting unique, user-friendly virtual stores. Elevate your brand, engage customers, and thrive online!.

Metadrob – Medium

The latest tweets from Metadrob (@Metadrob_)

Metadrob (@Metadrob_) / X

Where coins launch. Start the next meta on Metadrop.

Metadrop

An unidentified company declined an offer from Nintendo to develop a Metroid game for the Nintendo 64, as they were not confident they could create a worthwhile successor to Super Metroid. Samus appeared in the Nintendo 64 fighting game Super Smash Bros. (1999).

Metroid - Wikipedia

This article is about the titular creatures known as Metroids. For other uses, see Metroid (Disambiguation). Metroids are the titular creatures of the Metroid series. Originating from the planet SR388, they first became known to the universe at large when Space Pirates stole a batch of specimens ...

Metroid (species) | Wikitroid | Fandom

A Virtual Showroom Creation platform, that can be created by anyone and deployed on web or the metaverse

AI code review is becoming more important in software development, ensuring code quality, identifying bugs, and improving overall project maintainability. In recent years, several tools have emerged to automate and streamline the code review process. In this comparative blog, we will explore and compare Metabob, an AI code review tool, against popular static code review tools like Sonarlint, Sonarcloud, and DeepSource. We will also take a look at how some of these solutions utilize Generative AI for user interaction. The bases of comparison are the level of complexity of identified issues and overall user experience. To conduct our comparison, buggy GitHub Repositories were singled out for extensive testing. These repos include: fiatrete/OpenDan opencodeiiita/PhotoStore fief-dev/fief TransformerOptimus/SuperAGI Metabob stands out as a unique AI code review tool that leverages Graph Neural Networks to identify bugs and LLMs to provide automated code recommendations. It analyzes code snippets and offers suggestions for improvement, bug detection, and best coding practices. Sonarlint, developed by SonarSource, is a powerful static code analysis tool that integrates with popular integrated development environments (IDEs) like IntelliJ, Visual Studio Code, and Eclipse. Sonarcloud, also developed by SonarSource, takes static code analysis a step further by offering cloud-based continuous code inspection. It automatically scans code repositories, providing comprehensive reports on code quality, security vulnerabilities, and technical debt. DeepSource is another static code analysis platform that helps identify bugs, security vulnerabilities, and style violations. Complexity Simple, rule-based code reviews Syntax errors, empty variable assignments, and unnecessary complexity are all examples of simple bugs that occur in scripts. In this regard, Sonarlint, SonarCloud, and DeepSource perform very well. They identify such errors quickly and highlight regions of code that are potentially buggy. Metabob is also able to highlight very blatant errors like empty variable assignments, but it does not do well recommending stylistic syntax issues. Metabob glosses over these issues and deems them insignificant. Complex, context-based code reviews Using its attention mechanism from Graph Neural Networks to comprehend semantic and rational markers, Metabob performs much better than its competitors in this aspect. Metabob is able to detect complex, context-based errors, while the other solutions fail to do so. The example below details a script that uses the HS256 algorithm to generate access tokens. Metabob was able to identify the usage of this algorithm and its weakness against certain attacks. Metabob then recommends the replacement of this algorithm with RS256 or ES256 algorithms to prevent such attacks. Another example of complex errors is a race condition. Metabob is able to understand the objective of the function and what it is trying to achieve. It is also contextualizing this objective to the other functions present in the script. This combination of information helps it identify race conditions. Without contextualizing code within and across scripts, SonarLint, SonarCloud, and DeepSource are not able to determine such issues. User Experience SonarCloud and DeepSource are web-based SaaS platforms that take some time to configure and use. They both feature a dashboard that displays statistics about each repository (security, performance, stylistic issues) while allowing users to navigate through different issues. This makes navigation within the platform very user-friendly and organized.\ SonarLint and Metabob are available as integrated extensions on VScode. They operate right out of the IDE, with no complex configurations required. Metabob then takes it a step further to incorporate generative AI into its user experience. Using LLMs, Metabob generates error explanations, answers users’ questions, and even recommends code fixes. This allows users to engage with the tool to better understand the identified issues and bugs. Conclusion While SonarLint, SonarCloud, and DeepSource are the go-to solution when it comes to simple error identification, Metabob's competitive advantage lies in identifying complex errors. This was evident in the repository analysis conducted, where Metabob could detect all the contextual-based errors while the other tools failed to do so. However, Metabob is only available for Python as a programming language for now, and support for more languages is being worked on. Metabob utilizes generative AI to enhance its user experience, keeping the tool interactive. Its unique question-and-answer AI assistant allows users to clarify issues, and the LLM code fix recommendations elevate the coding standard to a higher level. Metabob offers free-to-use individual developer versions and is currently available on VScode as an extension. The tool can be tested here: ! Metabob: Debug and Refactor with AI - Visual Studio Marketplace

AI Code Review: Comparing Metabob with Sonar & DeepSource

MetaDojo raises $3 million to bring modular marketplaces to the Metaverse. MetaDojo has $3 million in a seed round of funding to create accessible and affordable metaverse venues. , , Altonomy Ventures, Jsquare, Walsh Wealth Ventures, Good Games Labs, PAKA Fund, NFT Technologies, IBC Group, LD Capital, and TsingTing Capital were among the crypto-native funds that participated in this round, which was led by (DFG). raised OKX Blockdream Ventures NGC Ventures Digital Finance Group Dojos are adaptable 3D structures that can be easily embedded into websites or deployed into metaverses. Owners can show off and trade their NFT collections, promote products and services, reward users for creating content or completing missions, host virtual meetings and events, and much more inside these purpose-built metaverse buildings. By converting their valuable skills and experience into professional services and NFTs listed in the marketplace, creators make significant contributions to the Metaverse ecosystem. There will be possibilities for ‘Ninjas’ to offer their services and knowledge in fields such as 3D animation, interior design, and event management, to mention a few. Token holders will engage in governance via voting power, as with any real decentralization initiative. A dojo is a hall or space where people may study or meditate in an immersive environment. By providing ready-to-use 3D structures, we want to make it a little simpler for consumers and companies to start developing their metaverses. They may utilize them as their houses, galleries, stores, schools, and nightclubs, among other things. The only limit is your creativity. They will be available in a variety of configurations and will be smoothly deployed throughout any metaverse and integrated on websites and social media platforms. The Rise and Rise of Metaverse in 2022 If the previous century was marked by mass manufacturing and the advent of the Internet, the twenty-first century may be remembered for the creation and spread of the virtual world, or Metaverse, which promises to be more immersive, interactive, and collaborative than the Internet has yet to achieve. Despite the grandiose expectations and promises made by many entrepreneurs experimenting in this field, it has become abundantly evident that Blockchain technology will underlie the Metaverse and help establish a sustainable environment for all its participants. While it is not unreasonable to believe that the Metaverse will influence traditional vocations or activities that are fairly commonplace now, its impact on society and how people interact with one another will be significant. Using crypto tokens issued by companies supporting these virtual connections, consumers will be able to buy digital avatars, virtual land, and even organize a party for loved ones. Artists will perform in the Metaverse, get paid in cryptocurrency, and trade their winnings for tangible items. The Metaverse extension will increase the amount of value that can be unlocked, leading to a fast expansion of the global economy. Today, a fledgling form of the Metaverse exists, with digital products like Non-Fungible Tokens (NFTs) reflecting popular art and digital relics attracting investors and crypto enthusiasts alike. With major players like Facebook, or Meta as it’s now known, entering this space and boldly signaling that the Metaverse is the new future, it’s only a matter of time before other entities follow suit, resulting in an exponential expansion of the Metaverse’s boundaries and unlocking vast amounts of value previously unknown to consumers and investors. Catch all the breaking news, and Don’t forget to like the story!

MetaDojo Raises $3 Million from DFG and OKX Blockdream to Bring 3D Modular Marketplaces to Metaverse

Travis Warren via Flickr Slow database queries are a regular thorn in my side. Whether it’s missing indexes, expensive joins, or N+1s, database performance woes have a way of surfacing in a multitude of ways. That’s why tracking down the source of slow queries is so important. While Postgres can easily log slow queries, there’s no way to track that back to the line-of-code emitting the query. That’s a problem. We can solve this with the most tool from the Elixir developer toolbox: metaprogramming. By the end of this article, you’ll wield your metaprogramming powers in a worthwhile pursuit: identifying the source of slow Ecto queries in a Phoenix app. James Halliday-like The goal: logging the source of slow Ecto queries For every Ecto query greater than 500 ms, we want to log the query execution time, the raw SQL, and a backtrace to the source: Where to begin? Adding seems like a clear starting point, right? We don’t even need metaprogramming! This give us access to the raw query and its execution time. Here I’m logging all queries that take longer than 500 ms: an additional Ecto logger Example output: [info] Slow!!!!: SELECT g0."id", g0."install_id", g0."email", g0."raw_payload", g0."deleted_at", g0."inserted_at", g0."updated_at" FROM "github_integrations" AS g0 Now, we just the need backtrace and we’re done. : the trace back to the app code that generated the query isn’t available inside . If you attempt to fetch the backtrace via inside , it won’t lead back to your custom application code. Instead, you’ll see a backtrace like this — , for example: But, there’s a problem trace/1 Process.info/2 Ecto.LogTrace.trace/1 notice there’s no references to a controller PSA: don’t want to mess with this? We’re building at my day job that does most of this for you. . Elixir App Monitoring Signup for early access Now what? Let’s override the public Ecto query functions. : we need to ensure we override all of the functions. If the function signatures or names change in later versions, we’ll fail to capture some slow queries and/or possibly break at compile time. This is not ideal Therein lies the danger of metaprogramming. The plan: Have our app’s expand a macro we define in a module we’ll create. repo.ex SlowLogger.Ecto will dynamically create a new module, that wraps around the Ecto query functions. We’ll be able to time their execution and grab backtraces. SlowLogger.Ecto YourApp.Repo.SlowLogger Alias as so our queries will be traced by default. YourApp.Repo.SlowLogger Repo repo.ex Here’s our updated Repo module: SlowLogger.Ecto When this module is used by , a new module, , is created dynamically. How meta! This module wraps around the Ecto query functions like , , and . We’ll be able to time their execution and grab backtraces. repo.ex YourApp.Repo.SlowLogger query all update . . Let’s walk through it. This is the meat of the implementation Here’s the module source How can we override Ecto functions? Technically, we can’t. Elixir functions can only be directly overwritten if they are referenced via the keyword. The Ecto functions that run queries — , , , etc — aren’t listed as overridable. [defoverridable](https://hexdocs.pm/elixir/Kernel.html#defoverridable/1) all query update We can work around this. We’ll dynamically create a new module. This module is included in our module, and we’ll define functions that wrap calls to the module that required it like . Repo unquote(__MODULE__).query(a) **Module.__using__/1** This is called when when the macro is invoked inside . Typically this is done to to inject functions inside the calling module ( ), and in this case, that code creates an entire submodule. [use](http://www.zohaib.me/use-in-elixir-explained/) repo.ex YourApp.Repo The [**quote**](http://elixir-lang.org/getting-started/meta/quote-and-unquote.html) macro We’ve defined the Ecto functions we wish to trace for slow queries inside a doubly-nested block. The outer block is placed in the calling module via . The inner quote block contains function definitions that are assigned to a variable. The block generates a free-standing piece of code: it isn’t executed immediately. quote quote use content quote **__trace/1** This does the actual tracing: we record the start_time, call the function, and record the end_time. **Module.create/3** Module.create(slow_logger_repo_module, contents, __ENV__) This takes the content from the inner block and creates our new module that traces our Repo queries. We’ll use this module vs. to run Ecto queries. quote YourApp.Repo web.ex We’ll alias the dynamically created module, , in so our calls to are routed through our tracing: YourApp.Repo.SlowLogger web.ex Repo Boom! Traces! We’re now logging traces to slow Ecto function calls. Can I have both the raw SQL and backtraces? At this point, we know how to: Log the raw SQL of slow queries Log backtraces to slow Ecto function calls We haven’t married them together: seeing both the raw SQL of a slow query and the associated backtrace to its source code location gives the complete picture. Process/put and Process/get Our wedding band will be Elixir’s Process dictionary. Store the log entry in the Process dictionary and fetch it from our tracing logic. In our Ecto logger, we’ll put the log entry in the Process dictionary: …and get the log entry inside : __trace/1 log_entry = Process.get(:ecto_log_entry) Boom! We’ve got everything: TL;DR Here’s instructions for logging slow Ecto queries: Change the Repo alias in to . web.ex YourApp.Repo.SlowLogger Add the logger to : Ecto config.exs config :yourapp, YourApp.Repo,    loggers: [{Ecto.LogEntry, :log, []}, {Ecto.LogTrace, :trace, []}] 3. Drop into your folder. [SlowLogger.Ecto](https://gist.github.com/itsderek23/f83a3f24d9a417c87da4993e8ce9db48) lib/ 4. Drop into your folder. [Ecto.LogTrace](https://gist.github.com/itsderek23/03c29bd3077b6e17a43f5233221eb8b3) lib/ 5. Add the following line to your file: repo.ex use SlowLogger.Ecto. PSA: Whew…too many steps? We’re building at my day job that does most of this for you. . Elixir App Monitoring Signup for early access

Logging slow Ecto queries: adventures in metaprogramming

A great door for hackers TL;DR: Don't use metaprogramming. It is not that cool Problems Security Limited Control Solutions Use direct calls Wrap the execution in a primitive and controlled command Sanitize it Context Developers employ the eval() and exec() functions to evaluate arbitrary expressions from strings. They can be a powerful tool in certain contexts but come with several risks and problems, especially when used with untrusted input or where the code's behavior is not fully controlled or understood. Sample Code Wrong def calculate(mathOperand, firstArgument, secondArgument):
    return eval(f'{firstArgument} {mathOperand} {secondArgument}')

# Sample usage to multiply two numbers
result = calculate('*', 4, 6)

# Injection to remove all files
calculate('', "__import__('os').system('rm -rf *')",'')) Right def calculate(mathOperand, firstArgument, secondArgument):
    if mathOperand == '+':
        return firstArgument + secondArgument
    elif mathOperand == '-':
        return firstArgument - secondArgument
    elif mathOperand == '*':
        return firstArgument * secondArgument
    elif mathOperand == '/':
        if secondArgument != 0:
            return firstArgument / secondArgument
        else:
            return "Error: Division by zero"
    else:
        return "Error: Invalid operation - Do not hack!"
        
# This is a quick solution but another smell
# You should avoid this kind of switches and iterate to 
# a Polymorphic Hierarchy Detection Automatic You can search for eval() in the code Tags Metaprogramming Level Intermediate AI Assistants Most AI Assistants avoid using eval() in their solutions. They also recognize it as a code smell and offer different options Conclusion Avoid this metaprogramming solution by hardcoding all the possible scenarios and avoiding over-generalizations. Relations Code Smell 207 - Dynamic Methods Code Smell 189 - Not Sanitized Input Code Smell 215 - Deserializing Object Vulnerability More Info https://hackernoon.com/laziness-chapter-i-meta-programming-6s4l300e?embedable=true Disclaimer Code Smells are my . opinion Credits Photo by on Yang Unsplash When you actually sit down to write some code, you learn things that you didn’t get from thinking about them in modeling terms…there is a feedback process there that you can only really get at from executing some things and seeing what works. Martin Fowler https://hackernoon.com/400-thought-provoking-software-engineering-quotes?embedable=true This article is part of the CodeSmell Series. https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-i-xqz3evd?embedable=true

Code Smell 245 — Exec() and Eval()

Go, Rust Haskell, Clojure, Perl, Ada Python and Java coexisting in a strange computational future fever dream of modern sofware development. Mastering the Art of Language Architecture: In the world of software development, selecting the right programming language is crucial, and not always an easy upfront choice. The Language Architecture Matrix is your strategic ally, guiding you through the myriad choices with insights into each language's core traits, architectural decisions, and their implications for your projects. The matrix below covers the following for each major language: Memory-Safe Language Key Trait Memory Safety Traits Architectural Decisions Weaknesses Tips & Tricks Resources Additional Info Commonly Converted From Reason for Conversion Why I made this: Ever wondered how the choice of a programming language can shape the destiny of your entire project? If you’ve been around computers in the last decade, you’ve probably already been a part of the memory safety revolution, but have you really taken a step back to thing about how that’s affecting the ? convergant evolution of software language design If that’s a curiosity you’d like to chase, then welcome to a journey through the Language Architecture Matrix – not just a chart, but a key to unlocking the architectural essence of programming languages. This adventure is more than making choices; it's about discovering the DNA of coding languages and how they've evolved to meet the challenges of the digital age. How It Helps in Thinking Architecturally Across Languages: The matrix is more than a tool; it's a mindset shift. It encourages you to think multilingually in the global city of software development, understanding the cultural, structural, and functional aspects of each language. This approach fosters informed, architecturally sound choices, essential for any seasoned developer. Let’s Get Started: At the bottom, you’ll find a matrix to play with. Here’s a few things you can use the matrix to understand from historical examples: The Great Language Escapades: Historical Stories to Explore the Chart: Explore Java's rise from C++'s shadow in enterprise applications. What made Java the go-to language for large-scale projects? Java's Enterprise Odyssey: Delve into how Swift's memory safety and modern syntax dethroned Objective-C in the realm of iOS development. Swift's iOS Revolution: Investigate Python's ascent over Perl in scripting. What features propelled Python to the forefront? Python Slithering away from Perl: Using the Matrix to Understand Memory Safety: Identify the shift from memory-unsafe to memory-safe languages. What drove these pivotal changes? Memory Safety Quest: Compare two languages and uncover how their design decisions impact their application areas. Architectural Detective Work: Forecast the future trajectory of a language based on its current path in the matrix. Predictive Language Analysis: Oh, and note that once you get down to Haskell, only real tip is to “ ”, which we might dive into more this year. I hope you enjoy this matrix, and I’d welcome contributors to it! Scroll down to the very bottom of this article for a Dungeons and Dragons matrix of these same languages, it might be even more useful. Embrace monadic design patterns Images produced by the , matrix produced by years 10+ years of just trying to build the best thing possible, no matter what. DALL·E 2 prompt Memory-Safe Language Key Trait Memory Safety Traits Architectural Decisions Weaknesses Tips & Tricks Resources Additional Info Commonly Converted From Reason for Conversion Java Most used in enterprise applications Garbage Collection, Object-Oriented JVM provides a sandboxed execution environment Null references; Manual array bounds checking Use to avoid nulls; Favor immutability Optional , Java Tutorials Effective Java Modern versions have enhanced security features C, C++, COBOL Java offers a platform-independent JVM, making it a popular choice for enterprise applications transitioning from legacy systems. C# Primary language for Windows development Garbage Collection, Object-Oriented .NET framework provides a vast library Null references; Unsafe code blocks Use for resource management; Favor LINQ for data manipulation using , .NET Docs C# Station Modern versions support nullable reference types Visual Basic, C++ .NET framework provides a vast library and modern features, making it a natural choice for Windows-based applications transitioning from older languages. Kotlin Modern alternative to Java for Android Null safety, Smart casts Interoperable with Java; Coroutines for concurrency Still possible to have null pointer exceptions Use , , and other scope functions; Understand vs let apply val var , Kotlin Docs Kotlin for Java Developers Officially supported by Android Java Kotlin is fully interoperable with Java but offers more concise syntax and modern features, making it a popular choice for Android development. Scala Hybrid of functional and object-oriented paradigms Option and Either types, Immutable collections Mix of object-oriented and functional paradigms Complexity due to hybrid nature; JVM startup time Use pattern matching extensively; Favor immutability , Scala Docs Scala Exercises Runs on the JVM Java Scala offers both object-oriented and functional paradigms, making it appealing for Java applications looking to adopt functional programming. Swift Modern language for iOS development Automatic Reference Counting (ARC), Optionals Protocol-oriented programming; Value semantics Bridging to Objective-C can introduce unsafety Use optionals ( ) to handle potential nil values; Favor value types over reference types ? , Swift Docs Hacking with Swift Interoperable with Objective-C Objective-C Swift offers a more modern and safer syntax than Objective-C, making it the primary choice for iOS development. Python Most popular scripting language Dynamic typing, Garbage Collection Dynamic nature allows for flexible coding patterns Slower execution; Global Interpreter Lock (GIL) Use for resource management; Avoid using mutable default arguments with , Python Docs Python Patterns GIL can be a bottleneck for multi-threaded applications Perl, PHP Python's simplicity and vast libraries make it a popular choice for web and scripting tasks transitioning from older scripting languages. Rust Best for memory safety without garbage collection Ownership, Borrowing, Lifetimes Ownership system prevents data races Steeper learning curve due to strict compiler Use the borrow checker to your advantage; Understand vs String &str , Rust Book Rust by Example Safe concurrency without a garbage collector C, C++ Rust's memory safety features without a garbage collector make it appealing for systems programming tasks that require performance and safety. Go Known for simplicity and concurrency Garbage Collection, Static Typing Simple and efficient concurrency model No generics; Manual memory management in some cases Use goroutines and channels for concurrency; Understand zero values , Go Tour Effective Go Emphasizes simplicity and efficiency C, C++ Go's simplicity and built-in concurrency make it a choice for backend services transitioning from C/C++ while wanting to maintain performance. Elixir Modern syntax on the Erlang VM Immutable data, Lightweight process model Built on the Erlang VM (BEAM); Metaprogramming capabilities Limited libraries for certain domains Use for project management; Understand the importance of processes and messages mix , Elixir School Elixir Docs Phoenix framework for web development Ruby, Erlang Elixir offers a modern syntax on the Erlang VM, making it appealing for scalable, fault-tolerant systems, especially those transitioning from Ruby on Rails. Erlang Designed for fault-tolerant systems Lightweight processes, Message-passing Built for distributed, fault-tolerant systems Not as efficient for computation-heavy tasks Understand the actor model; Use pattern matching in function heads , Erlang Docs Learn You Some Erlang OTP framework provides design principles for building applications Prolog, older telecom languages Erlang's design for fault-tolerant and distributed systems makes it a choice for telecom and messaging systems. Clojure Functional programming on the JVM Immutability, Functional Runs on JVM, emphasizes immutability JVM startup time; Slower than statically-typed languages Use transducers for efficient data transformation; Understand persistent data structures , Clojure for the Brave and True Clojure Docs *this book teaches you how to love coding, not just Clojure Emphasizes concurrency without locks Java Clojure offers functional programming on the JVM, making it a choice for Java applications looking to adopt functional paradigms. Haskell Pure functional language Pure functions, Immutability Lazy evaluation, strong static typing Complexity due to pure functional paradigm; Lazy evaluation can introduce space leaks Use strictness annotations to control evaluation; Embrace monadic design patterns , Learn You a Haskell Real World Haskell Popular in academic and theoretical computing Imperative and object-oriented languages (e.g., Java, C++) Chosen for its strong emphasis on pure functional programming, leading to more predictable and maintainable code in complex algorithmic development. Ada Emphasizes high-reliability Strong typing, Tasking for concurrency Designed for large, long-lived applications with stringent reliability requirements Verbose syntax; Steeper learning curve Use the package and tasking model effectively; Employ the SPARK subset for high-assurance systems , AdaCore University Ada Programming Wikibook Widely used in aerospace and defense industries Lower-level languages (e.g., Assembly, C) Preferred for its emphasis on safety and reliability in safety-critical applications, such as aerospace and defense, where failure is not an option. But wait, there’s one last thing: I want you to consider one more thing when you choose a language. There’s memory safety, then there’s the people you make memories with. Below is the only AI generated part of our original last year: a Dungeons and Dragons matrix that completely validated my personal thoughts on perl. Gadfly Open Source Zine Alright go have fun. Build something beautiful this year.

Memory Safe Strategy: Mastering the Language Architecture Matrix

What is Mojo language? Mojo is a new language for AI development. The language is being developed by the Modular company. The developer says, that it combines the best of Python syntax with systems programming and metaprogramming and lets you write portable code that's faster than C and interoperates seamlessly with the Python ecosystem. programming According to the official website, Mojo supports parallel threading and is 68,000 times faster than Python. Why this project is important? Mojo is becoming more and more popular and the community is growing actively. So, I decided to try to write my first data science project, but in Mojo language. I am excited to try a new programming language and start learning it before its popularity explodes. This article is being written in December 2023, so this code is valid for that period. So, I strongly believe this little guide will be valuable for someone interested in Mojo. Code from the article is available in this GitHub repo https://github.com/OberemokAlexandra/mojo_experiments/tree/main How to install Mojo language and start experiments? There are two ways to get started with Mojo. The first is to install it manually on your laptop. Instructions for each operating system can be found here https://developer.modular.com/download Installation takes time - be prepared But there is an easier and faster way to try out Mojo on your own: the free JupiterLab playground is available here: https://playground.modular.com/ I set up all the components on my laptop, and all the code below was tested on the environment, which was configured by me on my laptop. Choose of the dataset As it is my very first data project on Mojo - a regression task, I decided to choose a dataset from the sklearn library - diabetes dataset - https://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_diabetes.html Iris and Titanic datasets are the basis for classification tasks, so not today 🙂 . This dataset contains measurements from 442 diabetic patients. There are 10 features with different magical measurements, and the target is a quantitative measure of disease progression over a year. A great explanation of the features is given here https://rowannicholls.github.io/python/data/sklearn_datasets/diabetes.html Installation of Python modules with Mojo Mojo has built-in support for Python infrastructure - so it's quite easy to import a required module. For example, a numpy import will look like this. # first line imports a Python module in Mojo
from python import Python
# This line imports a numpy module itself
let np = Python.import_module("numpy") Don’t forget to install the necessary  modules in your environment first. For example, pip install numpy Get the dataset Variables in Mojo can be declared with two keywords - let and var. The main difference between them is that “let” is used to declare an immutable variable, while “var” is needed to state a mutable variable. In a Mojo, there are two ways to declare a function - by using def and fn keywords. More detailed information about the difference between the keywords can be found here: https://docs.modular.com/mojo/manual/functions.html Here is a function to return a dataset for further modeling. fn get_data() raises -> PythonObject:
    # Import of sklearn module with ready datasets
    # It’s possible to import a whole module
    let datasets = Python.import_module("sklearn.datasets")  
    let ds = datasets.load_diabetes()
    return ds Function to split, build an ml model, and evaluate its performance fn main() raises:
    # gets data from previous function
    let ds = get_data()
    let X = ds['data']
    let y = ds['target']
    # import needed sklearn module for train_test split
    let model_selection = Python.import_module("sklearn.model_selection")
    let split = model_selection.train_test_split(X, y)
    # Unpacking looks much harder than in python
    let X_train = split[0]
    let X_test = split[1]
    let y_train = split[2]
    let y_test = split[3]
    # modeling process
    let linear_model = Python.import_module("sklearn.linear_model")
    var regr = linear_model.LinearRegression()
    regr.fit(X_train, y_train)
    let pred = regr.predict(X_test) Metrics and results Let’s evaluate the regression model and see the results let metrics = Python.import_module("sklearn.metrics")
print("mean")
print(np.mean(y_test))
print("mse")
print(metrics.mean_squared_error(y_test, pred))
print("mae")
print(metrics.mean_absolute_error(y_test, pred))
print("r2")
print(metrics.r2_score(y_test, pred)) The results look like this Warning: your results may differ from those given here due to the random splitting of the data into training and test samples and model evaluation procedure Brief metrics analysis and explanation: Mean shows the mean value in the test split A huge value of the mse metric compared to a relatively small mae value may indicate that there are outliers in the test sample. The R-squared metric represents how much of the variance from the mean is accounted for by the model. In our case, it equals approximately 0.6, and it means that the model deserves to be considered. Mojo vs Python I’ve rewritten the same code in Python. To make the experiment clear and honest, I maintained the same settings on Python (trust me, you can make much more using Python). Here is the code listed below from sklearn.datasets import load_diabetes
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
import numpy as np

def get_data():
    """returns dataset for modeling"""
    return load_diabetes()


def main():
    """performs all the modeling actions"""
    ds = get_data()
    X, y = ds['data'], ds['target']
    X_train, X_test, y_train, y_test = train_test_split(X, y)
    regr = LinearRegression()
    regr.fit(X_train, y_train)
    pred = regr.predict(X_test)
    print("mean")
    print(np.mean(y_test))
    print("mse")
    print(mean_squared_error(y_test, pred))
    print("mae")
    print(mean_absolute_error(y_test, pred))
    print("r2")
    print(r2_score(y_test, pred)) It is seen that modeling results using Python are comparable. Challenges The challenges below are valid for December 2023. By the time you are reading this article, they may have already been fixed For now, the hardest part - is that it’s almost impossible to pass arguments easily to a Python module in Mojo data = load_diabetes(as_frame=True) Nowadays, I can’t pass parameters like as_frame=True in Mojo code. It can lead to difficulties when using and tuning complex models Based on information from Github, this feature is on request to develop issue link - https://github.com/modularml/mojo/issues/702 I couldn't unpack values in “the Python way.” I can't write a line of code like this X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42) I only could do something like this let split = model_selection.train_test_split(X, y)
let X_train = split[0]
let X_test = split[1]
let y_train = split[2]
let y_test = split[3] Conclusion Mojo is a new programming language under development. Today, it is possible to write code with a simple regression model. Some features need to be introduced for more development abilities, but I strongly believe that the new programming language has potential and will gain more popularity in the future.

A New Programming Language For AI: Linear Regression, But With Mojo Language

Programmers are constantly arguing about which language is the best. Once we compared C and Pascal, but time passed. The battles of / and /C# are already behind us. Each language has its pros and cons, which is why we compare them. Ideally, we would like to expand the languages to suit our own needs. Programmers have had this opportunity for a very long time. We know different ways of metaprogramming, that is, creating programs to create programs. Even trivial macros in C allow you to generate large chunks of code from small descriptions. However, these macros are unreliable, limited, and not very expressive. Modern languages have much more expressive means of extension. One of these languages is Kotlin. Python Ruby Java The definition of a domain-specific language A is a language that is developed specifically for a specific subject area, unlike general-purpose languages such as Java, C#, C++, and others. This means that it is easier, more convenient, and more expressive to describe the tasks of the subject area, but at the same time it is inconvenient, and impractical for solving everyday tasks, i.e. it is not a universal language.As an example of DSL, you can take the regular expression language. The subject area of regular expressions is the format of strings. domain-specific language (DSL) To check the string for compliance with the format, it is enough to simply use a library that implements support for regular expressions: private boolean isIdentifierOrInteger(String s) {
 return s.matches("^\\s*(\\w+\\d*|\\d+)$");
} If you check the string for compliance with the specified format in a universal language, for example, Java, you will get the following code: private boolean isIdentifierOrInteger(String s) {
 int index = 0;

 while (index < s.length() && isSpaceChar(s.charAt(index))) {
 index++;
 }

 if (index == s.length()) {
 return false;
 }

 if (isLetter(s.charAt(index))) {
 index++;

 while (index < s.length() && isLetter(s.charAt(index)))
 index++;

 while (index < s.length() && isDigit(s.charAt(index)))
 index++;
 } else if (Character.isDigit(s.charAt(index))) {
 while (index < s.length() && isDigit(s.charAt(index)))
 index++;
 }

 return index == s.length();
} The code above is harder to read than regular expressions, it's easier to make mistakes and trickier to make changes. Other common examples of DSL are HTML, CSS, SQL, UML, and BPMN (the latter two use graphical notation). DSLs are used not only by developers but also by testers and non-IT specialists. Types of DSL DSLs are divided into two types: external and internal. languages have their own syntax and they do not depend on the universal programming language in which their support is implemented. External DSL Pros and cons of external DSLs: 🟢 Code generation in different languages / ready-made libraries 🟢 More options for setting your syntax 🔴 Use of specialized tools: ANTLR, yacc, lex 🔴 Sometimes it is difficult to describe grammar 🔴 There is no IDE support, you need to write your plugins are based on a specific universal programming language (host language). That is, with the help of standard tools of the host language, libraries are created that allow you to write more compactly. As an example, consider the Fluent API approach. Internal DSLs Pros and cons of internal DSLs: 🟢 Uses the expressions of the host language as a basis 🟢 It is easy to embed DSL into the code in the host languages and vice versa 🟢 Does not require code generation 🟢 Can be debugged as a subroutine in the host language 🔴 Limited possibilities in setting the syntax A real-life example Recently, we at the company faced the need to create our DSL. Our product has implemented the functionality of purchase acceptance. This module is a mini-engine of BPM (Business Process Management). Business processes are often represented graphically. For example, the BPMN notation below shows a process that consists of executing Task 1, and then executing Task 2 and Task 3 in parallel. It was important for us to be able to create business processes programmatically, including dynamically building a route, setting performers for approval stages, setting the deadline for stage execution, etc. To do this, we first tried to solve this problem using the Fluent API approach. Then we concluded that setting acceptance routes using the Fluent API still turns out to be cumbersome and our team considered the option of creating its own DSL. We investigated at what the acceptance route would look like on an external DSL and an internal DSL based on Kotlin (because our product code is written in Java and ). Kotlin External DSL: acceptance
	addStep
		executor: HEAD_OF_DEPARTMENT
		duration: 7 days
		protocol should be formed
	parallel
		addStep
			executor: FINANCE_DEPARTMENT or CTO or CEO
			condition: ${!request.isInternal}
			duration: 7 work days after start date
		addStep
			executor: CTO
			dueDate: 2022-12-08 08:00 PST
			can change
	addStep
		executor: SECRETARY
		protocol should be signed Internal DSL: acceptance {
	addStep {
		executor = HEAD_OF_DEPARTMENT
		duration = days(7)
		protocol shouldBe formed
	}
	parallel {
		addStep {
			executor = FINANCE_DEPARTMENT or CTO or CEO
			condition = !request.isInternal
			duration = startDate() + workDays(7)
		}
		addStep {
			executor = CTO
 dueDate = "2022-12-08 08:00" timezone PST
			+canChange
		}
	}
	addStep {
		executor = SECRETARY
		protocol shouldBe signed
	}
} Except for curly brackets, both options are almost the same. Therefore, it was decided not to waste time and effort on developing an external DSL, but to create an internal DSL. Implementation of the basic structure of the DSL Let’s start to develop an object model interface AcceptanceElement

class StepContext : AcceptanceElement {

	lateinit var executor: ExecutorCondition
	var duration: Duration? = null
	var dueDate: ZonedDateTime? = null
	val protocol = Protocol()
	var condition = true
	var canChange = ChangePermission()

}

class AcceptanceContext : AcceptanceElement {

	val elements = mutableListOf<AcceptanceElement>()

	fun addStep(init: StepContext.() -> Unit) {
		elements += StepContext().apply(init)
	}

	fun parallel(init: AcceptanceContext.() -> Unit) {
		elements += AcceptanceContext().apply(init)
	}
}

object acceptance {

	operator fun invoke(init: AcceptanceContext.() -> Unit): AcceptanceContext {
		val acceptanceContext = AcceptanceContext()
		acceptanceContext.init()
		return acceptanceContext
	}
	
} Lambdas First, let's look at the class. It is designed to store a collection of route elements and is used to represent the entire diagram as well as -blocks. AcceptanceContext parallel The and methods take a lambda with a receiver as a parameter. addStep parallel A lambda with a receiver is a way to define a lambda expression that has access to a specific receiver object. Inside the body of the function literal, the receiver object passed to a call becomes an implicit , so that you can access the members of that receiver object without any additional qualifiers, or access the receiver object using a expression. this this Also, if the last argument of a method call is lambda, then the lambda can be placed outside the parentheses. That's why in our DSL we can write a code like the following: parallel {
	addStep {
		executor = FINANCE_DEPARTMENT
		...
	}
	addStep {
		executor = CTO
		...
	}
} This is equivalent to a code without syntactic sugar: parallel({
	this.addStep({
		this.executor = FINANCE_DEPARTMENT
		...
	})
	this.addStep({
		this.executor = CTO
		...
	})
}) Lambdas with receivers and Lambda outside the parentheses are Kotlin features that are particularly useful when working with DSLs. Object declaration Now let's look at the entity . is an object. In Kotlin, an object declaration is a way to define a singleton — a class with only one instance. So, the object declaration defines both the class and its single instance at the same time. acceptance acceptance “invoke” operator overloading In addition, the operator is overloaded for the object. The operator is a special function that you can define in your classes. When you invoke an instance of a class as if it were a function, the operator function is called. This allows you to treat objects as functions and call them in a function-like manner. invoke accreditation invoke invoke Note that the parameter of the method is also a lambda with a receiver. Now we can define an acceptance route … invoke val acceptanceRoute = acceptance {
	addStep {
		executor = HEAD_OF_DEPARTMENT
		...
	}
	parallel {
		addStep {
			executor = FINANCE_DEPARTMENT
			...
		}
		addStep {
			executor = CTO
			...
		}
	}
	addStep {
		executor = SECRETARY
		...
	}
} …and walk through it val headOfDepartmentStep = acceptanceRoute.elements[0] as StepContext
val parallelBlock = acceptanceRoute.elements[1] as AcceptanceContext
val ctoStep = parallelBlock.elements[1] as StepContext Adding details Infix functions Take a look at this code addStep {
	executor = FINANCE_DEPARTMENT or CTO or CEO
	...
} We can implement this by the following: enum class ExecutorConditionType {
	EQUALS, OR
}

data class ExecutorCondition(
	private val name: String,
	private val values: Set<ExecutorCondition>,
	private val type: ExecutorConditionType,
) {
	infix fun or(another: ExecutorCondition) =
		ExecutorCondition("or", setOf(this, another), ExecutorConditionType.OR)
}

val HEAD_OF_DEPARTMENT =
	ExecutorCondition("HEAD_OF_DEPARTMENT", setOf(), ExecutorConditionType.EQUALS)
val FINANCE_DEPARTMENT =
	ExecutorCondition("FINANCE_DEPARTMENT", setOf(), ExecutorConditionType.EQUALS)
val CHIEF = ExecutorCondition("CHIEF", setOf(), ExecutorConditionType.EQUALS)
val CTO = ExecutorCondition("CTO", setOf(), ExecutorConditionType.EQUALS)
val SECRETARY =
	ExecutorCondition("SECRETARY", setOf(), ExecutorConditionType.EQUALS) The class allows us to set several possible task executors. In we define the infix function . An infix function is a special kind of function that allows you to call it using a more natural, infix notation. ExecutorCondition ExecutorCondition or Without using this feature of the language, we would have to write like this: addStep {
	executor = FINANCE_DEPARTMENT.or(CTO).or(CEO)
	...
} Infix functions are also used to set the required state of the protocol and time with a timezone. enum class ProtocolState {
 formed, signed
}

class Protocol {
 var state: ProtocolState? = null

 infix fun shouldBe(state: ProtocolState) {
 this.state = state
 }
}


enum class TimeZone {
	...
 PST,
 ...
}

infix fun String.timezone(tz: TimeZone): ZonedDateTime {
 val format = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm z")
 return ZonedDateTime.parse("$this $tz", format)
} Extension functions is an extension function. In Kotlin, extension functions allow you to add new functions to existing classes without modifying their source code. This feature is particularly useful when you want to augment the functionality of classes that you don't have control over, such as classes from standard or external libraries. String.timezone Usage in the DSL: addStep {
	...
	protocol shouldBe formed
	dueDate = "2022-12-08 08:00" timezone PST
	...
} Here is a receiver object, on which the extension function is called, and is the parameter. The receiver object is accessed using keyword. "2022-12-08 08:00" timezone PST this Operator overloading The next Kotlin feature that we use in our DSL is operator overloading. We have already considered the overload of the operator. In Kotlin, you can overload other operators, including arithmetic ones. invoke addStep {
	...
	+canChange
} Here the unary operator is overloaded. Below is the code that implements this: + class StepContext : AcceptanceElement {
 ...
 var canChange = ChangePermission()
}

data class ChangePermission(
 var canChange: Boolean = true,
) {
 operator fun unaryPlus() {
 canChange = true
 }

 operator fun unaryMinus() {
 canChange = false
 }
} Finishing touch Now we can describe acceptance routes on our DSL. However, DSL users should be protected from possible errors. For example, in the current version, the following code is acceptable: val acceptanceRoute = acceptance {
 addStep {
 executor = HEAD_OF_DEPARTMENT
 duration = days(7)
 protocol shouldBe signed

 addStep {
 executor = FINANCE_DEPARTMENT
 }
 }
} within looks strange, doesn't it? Let's figure out why this code successfully compiles without any errors. As mentioned above, the methods and take a lambda with a receiver as a parameter, and a receiver object is accessible by a keyword. So we can rewrite the previous code like this: addStep addStep acceptance#invoke AcceptanceContext#addStep this val acceptanceRoute = acceptance {
 this@acceptance.addStep {
 this@addStep.executor = HEAD_OF_DEPARTMENT
 this@addStep.duration = days(7)
 this@addStep.protocol shouldBe signed

 this@acceptance.addStep {
 executor = FINANCE_DEPARTMENT
 }
 }
} Now you can see that is called both times. Especially for such cases, Kotlin has a annotation. You can use to define custom annotations. Receivers marked with the same such annotation cannot be accessed inside one another. this@acceptance.addStep DslMarker @DslMarker @DslMarker
annotation class AcceptanceDslMarker

@AcceptanceDslMarker
class AcceptanceContext : AcceptanceElement {
	...
}

@AcceptanceDslMarker
class StepContext : AcceptanceElement {
	...
} Now the code val acceptanceRoute = acceptance {
 addStep {
 	...

 addStep {
 ...
 }
 }
} will not compile due to an error 'fun addStep(init: StepContext.() -> Unit): Unit' can't be called in this context by implicit receiver. Use the explicit one if necessary Links Below are links to the official Kotlin documentation on the language features that were considered in this article: Function literals with receiver https://kotlinlang.org/docs/lambdas.html#function-literals-with-receiver Passing trailing lambdas https://kotlinlang.org/docs/lambdas.html#passing-trailing-lambdas Object declarations https://kotlinlang.org/docs/object-declarations.html#object-declarations-overview Operator overloading https://kotlinlang.org/docs/operator-overloading.html Infix notation https://kotlinlang.org/docs/functions.html#infix-notation Extension functions https://kotlinlang.org/docs/extensions.html#extension-functions Scope control: @DslMarker https://kotlinlang.org/docs/type-safe-builders.html#scope-control-dslmarker Conclusion Domain-specific languages offer a powerful means to enhance productivity, reduce errors, and improve collaboration by providing a specialized and expressive way to model and solve problems within a specific domain. Kotlin is a modern programming language with many features and syntactic sugar, so it is great as the host language for internal DSL.

How to Develop a DSL in Kotlin

কোটলিনে কীভাবে একটি ডিএসএল বিকাশ করবেন

So entwickeln Sie ein DSL in Kotlin

Cómo desarrollar un DSL en Kotlin

Comment développer un DSL dans Kotlin

कोटलिन में डीएसएल कैसे विकसित करें

Kotlin で DSL を開発する方法

Kotlin에서 DSL을 개발하는 방법

Como desenvolver uma DSL em Kotlin

Как разработать DSL в Kotlin

Kotlin'de DSL Nasıl Geliştirilir?

Cách phát triển DSL trong Kotlin

如何在 Kotlin 中开发 DSL

In today's data-driven world, networks and graphs are fundamental for modeling complex relationships and dependencies. Graph Neural Networks (GNNs) have emerged as a transformative approach to understanding and analyzing graph-structured data. In this post, I will delve into GNNs, explaining what they are, their purpose, and the key advantages they offer, especially for beginners. Defining Graph Neural Networks (GNNs) Graph Neural Networks (GNNs) are a class of neural network architectures designed to operate on graph-structured data. These networks are tailored to analyze and learn from the intricate interconnections between nodes within a graph. In a graph, nodes typically represent entities (e.g., users in a social network or molecules in a chemical compound), while edges denote relationships or interactions between these entities. At my company, Metabob, we are working on utilizing GNNs for code analysis. If you want to see it in action at its current state, check out: . try.metabob.com GNNs enable nodes in a graph to learn and share information with their neighboring nodes. This allows them to capture and utilize information from connected entities, making GNNs highly effective at understanding complex relationships within a graph. The Purpose and Significance of GNNs GNNs are developed with several key purposes in mind: GNNs are engineered to capture intricate, nonlinear relationships in graph-structured data. This makes them exceptionally well-suited for a wide range of applications, even for analyzing codebases. Modeling Complex Relationships: GNNs are adept at node classification tasks, which involve assigning labels or categories to nodes within a graph. This capability has applications in recommendation systems, where GNNs can recommend products or content to users based on their preferences and those of similar users. Node Classification: GNNs can classify entire graphs based on their structural properties. This is valuable in scenarios like social network analysis or identifying molecular structures. In codebase analysis, graph classification can be used, for example, for library and dependency assessments. Graph Classification: GNNs can generate new graphs that follow similar patterns to the input data. This is used in creating synthetic data for various applications, such as drug discovery or social network simulation. In the example of codebase analysis, this could be used to rebuild the code graph, for example, with a fixed region of the code. Graph Generation: Advantages of Graph Neural Networks GNNs offer several key advantages, making them an indispensable tool for graph data analysis: GNNs are highly adaptable and can be applied to various graph structures. They can handle different types of graphs, such as directed or undirected graphs, and can be extended to handle dynamic graphs. Flexibility: GNNs are computationally efficient since they leverage localized information from neighboring nodes. This allows them to scale to large graphs and real-time applications. Efficiency: GNNs have consistently achieved state-of-the-art results in numerous graph-related tasks. Their ability to capture complex relationships sets them apart in the field of machine learning. State-of-the-Art Performance: In conclusion, Graph Neural Networks are definitely an asset for the analysis and understanding of graph-structured data. They offer a means to uncover intricate relationships and dependencies, making them an effective tool for data scientists and machine learning enthusiasts. If you're interested in social network analysis, recommendation systems, or even using GNNs for code analysis, exploring Graph Neural Networks is a rewarding journey that can unlock new possibilities for your data analysis and modeling endeavors.

Metadrob

metadrob.com

-- employees

Since n.d.

COMPANY RANKING

METADROB

EVERGREEN INDEX #6481

Metadrob WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

Metadrob

metadrob.com

-- employees

Since n.d.

COMPANY RANKING

METADROB

EVERGREEN INDEX #6481

RELATED COMPANIESRANK

STORIES ABOUT METADROB

Metadrob WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!