DEV Community: Aryan Kaushik

ContextCache: AI that remembers so your team doesn’t have to.

Aryan Kaushik — Fri, 08 Aug 2025 15:27:38 +0000

Another Day, another ridiculous idea. Another win.
This time, at the AINATIVEHACK: SDLC Hackathon, where we asked one simple question:
Why does no one remember WHY we made that decision?

😵 The Problem, Let’s set the scene:
You join a new product team.
You’re looking at some deeply suspicious retry logic in the codebase.

You ask, “Why was this added?”
And then it begins…
Slack messages get forwarded.
Someone linked a Notion doc last edited in 2021.
The engineer who made the decision has moved to Bali and now makes NFTs.
Everyone shrugs and says, “Must’ve been important.”

Welcome to modern software development:

In a world where teams are remotely collaborating, rapidly iterating, and constantly forgetting, we realized something critical was missing:

🧠 Memory.

Not the RAM kind. The “why-did-we-do-this” kind.

✨ The Solution: ContextCache
Enter ContextCache — your AI-powered, passive-aggressive team memory agent.

It silently listens to:
-Slack messages (even those cursed 30-thread debates),
-MS Teams transcriptions (yes, even the ones where Bob forgot to unmute),
-GitHub PRs, Notion docs, and more.

Then it asks itself:
-What was the decision?
-Why was it made?
-Who made it?
-Is this gonna get us sued?

It then summarizes, tags, and stores that info in a vector database. So next time you ask:

“Why did we choose Kubernetes over ECS?”
It answers:
“On April 12, DevOps Dan argued for better autoscaling support in Slack #infra. Legal Lisa also needed HIPAA compliance which ECS lacked. Karen approved the change. You’re welcome.”

🛠️ How We Built It (in 8 Hours Because... Hackathon)
Ingestion Layer
Slack and Teams APIs pumped in conversations and transcripts.
(Yes, some of those were us arguing about what to build.)

LLM Magic via ACI.dev
We piped chunks of conversation into custom agents on ACI.dev, which:

-Extracted decisions,
-Flagged compliance risks,
-Gave structured JSON summaries like a nerdy robot secretary.

Vector Memory Layer
Stored in Pinecone, so we could semantically search decisions by topic, date, or confusion level.

Slackbot Interface
Ask a question like:

“Why did we remove login with Google?”
And boom — instant context.

🥇 The Win
The judges loved it. The devs wanted it.
And the compliance folks? They nearly cried.

We won as An Idea with more Potential
And now we’re thinking — why stop here?

🚀 What’s Next
💬 VSCode plugin so devs can pull decision context without leaving their IDE.
🛡️ Auto-flag compliance issues before audits become horror stories.
🤝 Integrations with Notion, Jira, and whatever comes next.

Our Team: Shivang, Emil, Dave, Mustafa

🎉 Final Thoughts
ContextCache wasn’t just a hackathon project. It was a love letter to every developer who’s ever whispered:

“Why the hell did we do this?”
And now, the answer won’t be:

“¯_(ツ)_/¯"

It’ll be:
“Here’s the full thread, rationale, and approval notes. I got you.”

Chekout the Viral Video:Link
Checkout the Presentation:Link

From EmpowerAI to Clueless: How a B2C Dream Became a B2B Superpower

Aryan Kaushik — Tue, 05 Aug 2025 13:18:47 +0000

Every breakthrough starts with a simple, stubborn question: “Why is this still so hard?”

The Spark: Inspiration Strikes at YC

EmpowerAI was born at the intersection of two worlds. It all started when I attended a YC (Y Combinator) event hosted by Tom, the co-founder of Monzo. Listening to Tom talk about building products that are the next-gen of AI Revolution, AI that could take control of the system and do your tasks. I found myself reflecting on something closer to home—my parents.

Both are smart, resourceful, and independent, but they’re late adopters of technology. And every time they need to do something online—book a ticket, update a form, use a new app—they end up waiting for me to walk them through every single step. It’s not just my family. Millions of people feel left behind by tech, and I realized this isn’t a niche problem. It’s a global barrier.

The B2C Vision: EmpowerAI—Technology That Teaches, Not Replaces

My initial solution? An on-screen AI guide that empowers, not automates. I imagined a tool that could highlight buttons and fields in real time, gently guiding users step by step on top of the apps they already use. It wasn’t about making things automatic—it was about building confidence and independence. I wanted people like my parents to feel empowered, not helpless.

EmpowerAI’s target audience started with people like them:

Older adults and late technology adopters
Parents returning to the workforce
Teachers and community workers navigating digital transformation

The vision was to launch a product that offered real value for individuals and families, but also had potential for partnerships with NGOs, government programs, and anyone committed to digital inclusion.

The Research: The Need Was Bigger Than I Thought:

Digging into the numbers and talking to users, the opportunity was massive. Over 1 billion people face digital barriers, and the global assistive tech market is worth over $30 billion, growing at a staggering 27% a year. Most importantly, almost every existing solution failed to actually teach—they either overwhelmed users or automated away the learning.

The Hackathon Shift: Bringing EmpowerAI to Life:

Then came the AI Engine Hackathon in London. Surrounded by ambitious, creative minds, many thought it was a waste, and many liked but they had an idea they wanted to work on. So, I met a duo who wanted to work on the Dev Tools, and my other friend suggested an AI agent to prevent employee poaching. I shared the EmpowerAI idea with them and due to its virality and need, they agreed to join. The excitement was instant—everyone saw the need and the potential. The team worked around the clock, building a prototype that could turn everyday tech struggles into moments of guided success- Kudos to them.

But as we started testing and talking to mentors, another insight emerged: Businesses have the exact same problem. Whether it’s onboarding customers, training employees, or supporting users, companies are constantly fighting digital friction.

The Pivot: Clueless—Visual B2B Workflows for Every Business.

That’s how Clueless was born. We realized our technology could transform not just individual lives, but entire organizations. With Clueless, businesses can deliver real-time, visual guidance to every user, turning confusion into clarity and frustration into confidence.

User onboarding becomes intuitive
Customer support becomes proactive
Adoption of new features skyrockets

What started as a tool for my parents has become a B2B superpower—helping businesses empower thousands, not just one person at a time.

What’s Next: The Journey Continues:

Looking back, it’s amazing how a conversation at a YC event, a problem at my parents’ kitchen table, and a hackathon with strangers could lead to something this big. The lesson? Start with real human problems, listen hard, and stay open to the pivot.

Clueless now stands for every company that wants its users—and its team—to truly feel at home in the digital world. - In Progress

Check out the Demo: Link

Viral Video: Instagram

Takeaway: Sometimes, the most scalable B2B solutions are born from deeply personal B2C insights. When you focus on empowering people, you find game-changing opportunities everywhere.

My Key Takeaways From The Campus DevRel Show | Juan Pablo Flores E2

Aryan Kaushik — Mon, 05 Sep 2022 17:44:36 +0000

🎉Welcome to the 2nd Blog of The Campus DevRel Show
series where we focus on the lessons from the experience of the amazing guest DevRels.

As you can read from the title, today we gonna talk about the experience of Juan Pablo Flores who is a Senior Program Manager at GitHub and has also been leading the Campus Expert Program. I am sure most of the folks who are part of GitHub’s student community already know him. He is a celebrity in the Mexican student communities for the amazing work he has done and still does for uplifting the community culture in LATAM.

Before we dive more into his journey, If you are new here make sure you check out DevRel.Page and also do check out the blog on the Ist Episode of “The Campus DevRel Show” with Jon Gottfried.

At the time when Juan started getting involved with tech communities, the ecosystem was very small. There were only a handful of people in the ecosystem who were “that influential”. Even a hackathon with 15–20 people was considered big, where everything was organized on a contribution basis. His journey into the tech community started in 2014 when he organized a hackathon known as “MX Hacks”. One of the biggest challenges he wanted to tackle was the interaction between the students. He focused on building a space where students could build whatever they had in their minds, work with folks they have never met before, and of course FREE FOOD!

Juan started attending community events and eventually attended a meetup for Google Developer Group for Dart, where he met a few folks and got the idea for organizing hackathons for student communities in Mexico. Juan met Jon, co-founder of Major League Hacking through a meetup. He mentions that the networks and connections he has made over the last 7 years have been the key to his and his community’s development.

Random people that you meet at random places at the right time lead to better opportunities.

When Juan started building MX hacks, he was also having conversations with Jon and Swift, the founders of Major League Hacking, about building the league in Mexico that they had in the US. He also wanted to see if the developer audience would like the idea of the hackathon in Mexico — experimenting with MX Hacks which turned out to be a success. At this point, they started organizing hackathons for governments, and corporates, having built a decent community built around it. That’s when Juan and other organizers felt they needed a bigger league for this and started the “La Liga Mexicana de Hackatones” (LMH). He also mentions that not only helped him make connections with the MLH team in the US but also with the DevRel folks in the UK.

The very first thing Juan mentioned was about finding the right people to partner with while you start an organization and then sharing the same vision with them. He also talks about the process of separation, where the team that he was part of separated to focus on very different aspects of the same idea. This involved a lot of friction, the experience of which helped him develop a different perception and approach at a very young age. Juan also derives the importance of opportunities presented to the student communities for their success and growth.

After working with MLH for almost 18 months, Juan had a lot of offers that he wanted to take but he couldn’t due to his delayed degree. Juan decided to go back to university to finish his degree at the same time when he was approached by his friend, who was working at an IT consultancy company, to start Inventive Hack. He went on working and managing his school at the same time, but after 2 years it was getting harder and harder for him to manage time. At that time, they were building apps for various companies and also made an app for Mexico City to solve their traffic problems. He recalls that within a week they were having conversations with the CEO of Uber Mexico and similar big startups. He and his team were just paving their way through this new journey being total beginners in their early ’20s. They ended up getting a lot of media coverage that made their firm explode leading to big partnerships. Juan also secured a summer internship at CMU, the US to work with “top-top-top” researchers in the field of human-computer interaction.

Juan recalls that learning how to react to incidents had been great learning, during his MLH days. He also recalls his biggest learning through his journey — “Importance of access to opportunities”. He felt the need to bring change to the community around him and then branch out to provide the same opportunities wherever possible, which lead him to join GitHub as a community manager. He also knew that he wanted it, but at the same time, he could contribute to the role and make the existing program even better.

Juan's journey into communities and his learnings
When GitHub was launching its first-ever batch of campus experts, Joe Nash from GitHub, approached him to talk about the program wanting to know if he was interested in joining in. Juan continued his community work alongside his other ventures all along. Juan joined the program and he never felt the need to sell GitHub or force himself to do so. He had already been talking about GitHub right from his college days and he was always fascinated to see students transition from learning about GitHub to their first PR merge. He also had a deeper involvement with GitHub as he became a campus expert and then a field expert. The training in the program was very hard but at the same time, he could also pinpoint the places where the program was struggling. He later also became responsible for reviewing the training of other campus experts. He wanted to be influential in this space to make more students from Latin America and the European region to be involved in the tech space.

What advice would you give looking back at your journey, would you give to students exploring the DevRel field as a career option?

Work on your communication skills. - Juan

Communicating effectively, and correctly and making sure that you can express yourself will always pay off in some way or another in the future. DevRels, CMGRs, and PMs — are all expected to write & communicate a lot. If you aren’t the best at it, start early! Start writing blogs, there are lots of platforms out there.

Yes! Juan's journey into the tech community and the tech space is fascinating!

Do you think reading this made your pathway to #DevRel a little clear? Or Is it still a little blurry?

You can always check out DevRel.page to understand more about #DevRel.

Watch the Highlights on Youtube and Full Episode on Twitch

Follow DevRel.Page on Twitter Instagram

Do share your thoughts related to this blog & DevRel and feel free to connect with me on Twitter

What is version control? Why Git & GitHub are so popular?

Aryan Kaushik — Wed, 31 Aug 2022 12:11:27 +0000

Hi Folks, thanks for dropping by!

Today, We gonna learn about Version Control, it's use cases and why git and GitHub are so popular among developers.

What is version control?

Version control, also known as source control, is the practice of tracking and managing changes to software code. Version control systems are software tools that help software teams manage changes to source code over time. As development environments have accelerated, version control systems help software teams work faster and smarter. They are especially useful for DevOps teams since they help them to reduce development time and increase successful deployments.

Purpose of Version Control.

Multiple people can work simultaneously on a single project. Everyone works on and edits their own copy of the files and it is up to them when they wish to share the changes made by them with the rest of the team.
It also enables one person to use multiple computers to work on a project, so it is valuable even if you are working by yourself.
It integrates the work that is done simultaneously by different members of the team. In some rare cases, when conflicting edits are made by two people to the same line of a file, then human assistance is requested by the version control system in deciding what should be done.
Version control provides access to the historical versions of a project. This is insurance against computer crashes or data loss. If any mistake is made, you can easily roll back to a previous version. It is also possible to undo specific edits that too without losing the work done in the meanwhile. It can be easily known when, why, and by whom any part of a file was edited.

Why VCS(Version Control System) is important for Developers?

Enhances the project development speed by providing efficient collaboration,
Leverages the productivity, expedites product delivery, and skills of the employees through better communication and assistance,
Reduce possibilities of errors and conflicts meanwhile project development through traceability to every small change,
Employees or contributors of the project can contribute from anywhere irrespective of the different geographical locations through this VCS.
For each different contributor to the project, a different working copy is maintained and not merged to the main file unless the working copy is validated. The most popular example is Git, Helix core, Subversion, etc .
Helps in recovery in case of any disaster or contingent situation.
It informs us about Who, What, When, and Why changes have been made.

Branches in the version control system

What is Git & Why it is widely used?

Git is a version control system used for tracking changes in computer files. It is generally used for source code management in software development.

Git is used to track changes in the source code
The distributed version control tool is used for source code management
It allows multiple developers to work together
It supports non-linear development through its thousands of parallel branches

Features of Git

Tracks history
Free and open source
Supports non-linear development
Creates backups
Scalable
Supports collaboration
Branching is easier
Distributed development

The Git workflow is divided into three states:

Working directory - Modify files in your working directory
Staging area (Index) - Stage the files and add snapshots of them to your staging area
Git directory (Repository) - Perform a commit that stores the snapshots permanently in your Git directory. Check out any existing version, make changes, stage them and commit.

Download git

This link has details on how to install Git in multiple operating systems: Link

What is Github and why it is so popular?

GitHub is an online software development platform used for storing, tracking, and collaborating on software projects. It is a cloud-based version control system. It enables developers to upload their own code files and to collaborate with fellow developers on open-source projects. GitHub also serves as a social networking site in which developers can openly network, collaborate, and pitch their work.

In simple words, Github might be considered as a social media which is made for developers where they share their work. it might be any project regarding website development or any design of a website, or some operating systems like Android, Linux, etc.

How To Use Git & Github Effectively

Let us see how to host a local repository on Github, from the very beginning

Step 1. Configure your global username and email:

Set your username:


git config --global user.name "FIRST_NAME LAST_NAME"

Set your email address:


git config --global user.email "email@example.com"

Step 2. Creating your workspace By creating a new working directory:

mkdir gitrepo

Next, move into that working directory:

cd gitrepo

Once inside that directory, you will need to create a sample file to demonstrate Git’s functionality. You can create an empty file with the touch command:

touch file

Step 3. Initializing a Git repository in an existing directory by using the git init command.

git init

Git will never track new files automatically, so git add is a necessary step when adding new content to a repository that Git has not previously tracked.

git add .

You now have an actively tracked Git repository. From now on, each of the steps in this tutorial will be consistent with a regular workflow for updating and committing to an existing Git repository.

Creating a commit message:

Each time you commit changes to a Git repository, you’ll need to provide a commit message. Commit messages summarize the changes that you’ve made.

git commit -m "first Commit" -a

There are two important parameters of the above command. The first is -m, which signifies that your commit message (in this case “Initial Commit”) is going to follow. Secondly, the -a signifies that your commit should include all added or modified files. Git does not treat this as the default behavior, but when working with Git in the future, you may default to including all updated files in your future commits most of the time.

In order to commit a single file or a few files, you could have used:

git commit -m "first Commit" file1 file2

Step 3. Sign up for GitHub

Step 4. Create a repository on github

Copy the Github Repository URL:

In the Command prompt, add the URL for the remote repository where your local repository will be pushed.

// Sets the new remote
git remote add origin URL

//Verifies the new remote URL
git remote -v

Once you have a remote configured, you are able to push your code. You can push code to a remote server by typing the following:

git push --set-upstream origin master
// Only for the first time

There are many more uses of git like Inspecting & comparing code, Sharing & updating code, tracking path changes, rewriting history, etc

Check out Git Cheat Sheet at this link

This Blog was about getting started with git and GitHub. Stay tuned for more amazing blogs.

Do comment your thoughts and suggestions related to the blog and please share if you found it useful.

My Key Takeaways From The Campus DevRel Show | Jon Gottfried E1

Aryan Kaushik — Tue, 30 Aug 2022 15:03:05 +0000

Heya 👋, Welcome to this Blog Series of The Campus DevRel Show, focusing on the lessons from the experience of the amazing guest DevRels.

Before we get started! Let's take a moment to understand what exactly is DevRel.
As the name suggests, Developer Relations (or DevRel) focuses on maintaining relationships with the folks responsible for developing an organization's technology or product. Depending on the company and its goals, roles in this field can take various forms, as well as tasks.
Communication between organizations and developers is often the responsibility of a DevRel in order to ensure a better information flow and feedback loop. This is a job for people who have a deep understanding of development, who are inherently developers, and who are able to relate to and empower developers.

DevRel functions as a bridge between the product and the community.

By Pandy Knight

A Brief about Jon's Background

Jon Gottfried is the co-founder of MLH, previously National Director of the StartupBus, and was formerly a Developer Evangelist at Twilio. Having grown up around computers, he has always been fascinated by them. Since graduating from history school, he found his own niche in software engineering. Research and academics were initially what attracted him to computer science, but soon he discovered that building things and writing code were his passions. Even so, he never strayed too far from the tech side, always finding a balance between the two.

Community building and evangelism were something that Jon was always interested in. He grew up going to summer camp and being super involved in it and liked being involved in building communities and experiences for people. At the Music Hack Day, he met folks from a company whom he later pitched for being a part-time developer evangelist, and joined as a developer evangelist after graduating, which shaped his further understanding of the field.

I just happened to be at the right place at the right time and meet amazing people. -Jon

Jon's understanding of DevRel when he just started working for Twilio was to show up at hackathons, do a really cool demo and support developers throughout the weekend. While working there, he realized there was much more than that going in that background, and a lot of it was about figuring it out as he moved forward. As a company, their strategy was to build something that developers love, which also inspires them to use it! He did mention numbers, and that someone had to keep in mind getting “X number of users”, but he was focused on making something that would make developers super excited. A lot of things their team did involve trial and error.

The Story of MLH

About MLH: It is a 500k+ global community empowering the next generation of developers to learn through hackathons and many MLH fellowships.

Jon and Swift worked as developer evangelists and attended multiple events, spoke at and founded community meet-ups together in New York. Their frequent meeting places were student hackathons, which were still a growing trend at that time. The two had been working together on different projects, a few small ideas here and there, which led them to agree that they want to work together in the future. Eventually, they found co-founders before they came up with an idea for a startup. Jon had registered the domain for MLH years before they for a completely different idea and eventually agreed to form a global community hackathon community.

My Learnings from this Episode:

1. What exactly do companies look for in student communities?

Companies' goals have changed from the time they started. At first, when MLH was just getting started, most of its sponsors were Jon's personal & professional friends. As MLH grew it changed a lot as now they had to focus on making sure it was mutually beneficial for companies along with student communities. Sponsorships are sort of give and take relationships.

Connections and relationships play a huge part in developer relations as a huge chunk of it is about creating meaningful relations.

2. What does Jon think is the best part about working in Developer Relations?

When you do something to help someone, just as a nice thing to do, and years later they come back and you realize how impactful it has been.

When you are into developer relations there are hundreds of interactions that you carry out as your day-to-day job. The interaction might be casual for a DevRel, but that for the other person can be really impactful.
That’s one of the best parts about this job — impacting people in a positive way and being able to scale that impact.

3. What is Jon’s advice for undergrads getting into DevRel space?

“Start with becoming a community organizer” — Jon

Attend conferences, organize hackathons, or volunteer under organizations that do the same, basically to gain the initial experience that you can showcase both, the community and the engineering side of things when you apply for a job. A little bit of experience in marketing — blogs, videos, and speaking helps too. When Jon worked at Twilio and his team would look for developer relations roles, they would often look for full-time engineers who did part-time community work because of their enjoyment around it. So they would approach them and basically ask them to do what they enjoyed doing, but full time!
But now community managers and content creators from college can also be DevRel.

4. What exciting things companies are doing for student communities right now?

Dev.to does really cool stuff” — when it comes to folks getting started with writing about tech, Dev provides an accessible platform for doing so. Jon was personally excited about Battlesnake and its unique way of exercising creativity.

5. Jon’s takeaway for DevRel metrics

According to Jon, DevRels may not struggles to measure success or struggles to determine what their success metrics are.

Here, he means is that DevRel teams have so many metrics, but fail to agree on which metric is more important for measuring their success. Which category DevRel fits into is still a very debatable question. Most would say that it depends on the company and its goals, and which team you fit in, helps in determining what your success metric will be.

The companies that have been most successful have had a mix of beliefs in the strategy and metrics. One has to be willing to take creative risks while proving that they’re doing something valuable because otherwise, it’s hard to justify spending money on the team.

That was literally a lot of info to get started. Make sure you take your own time to understand every piece of information to pave your path toward becoming a DevRel.

This is just the beginning of this Series. We've many more blogs coming up with a lot more different experiences.

Do you think reading this made your pathway to #DevRel a little clear? Or Is it still a little blurry?

You can always check out DevRel.page to understand more about #DevRel.

Watch the Highlights on Youtube and Full Episode on Twitch

Do share your thoughts related to this blog & DevRel and feel free to connect with me on Twitter

Cryptle - Wordle clone for Enarx

Aryan Kaushik — Wed, 08 Jun 2022 17:09:54 +0000

Hi Folks, Welcome to another exciting Blog.

In the previous blog, we learned about "The Enarx Project" an open-source framework for running applications in TEEs (Trusted Execution Environments) using WebAssemby. It is the part of Confidential Computing Consortium from the Linux Foundation. But today we'll try hands on Enarx application using Cryptle.

Enarx in brief

Enarx aims to minimize the trust relationships required when executing applications, meaning that the only components which need to be trusted are: the CPU and associated firmware, the workload itself, and the Enarx middleware, which is fully open source and auditable. Applications run without any of the layers in the stack (e.g. hypervisor, kernel, user-space) being able to look into or alter the Keep or its contents.

Today, we will deep dive into Cryptle - a Wordle clone for Enarx. The Cryptle game is developed using Rust on the server-side and JavaScript on the client-side. It can either be run on wasmtime which is not secure or on Enarx a trusted secure platform.

Wordle

In Addition Cryptle has a multiplayer support

Steps to run Cryptle on your Machine

1) Install Rust

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- --default-toolchain nightly -y

source $HOME/.cargo/env

2) Install Enarx

git clone https://github.com/enarx/enarx
cd enarx/
cargo build


cargo install --bin enarx --path ./

3) Clone and Run Cryptle

git clone https://github.com/enarx/cryptle.git
cd cryptle/
cd Rust/

CARGO_TARGET_WASM32_WASI_RUNNER="wasmtime run --tcplisten 127.0.0.1:8443 --env FD_COUNT=1"  cargo +nightly run --target wasm32-wasi

Server is running on http://127.0.0.1:8443.

Cryptle

The goal of Cryptle is to demonstrate data encryption in use, where the processing of the data is done in a Trusted Execution Environment (TEE), and only accessible to the Cryptle application.

The Single Player mode is similar to Wordle. A player has to guess a five-letter secret word (selected by the application), with yellow/green colored titles shown as hints in each round, indicating letters that match with the secret word.

In the Multi Player mode, the secret word is not selected by the application itself, but instead is (or rather are) suggested by the players themselves. Each player proposes words that are most likely to match those sent by others. The words are sent to the Cryptle application running in an Enarx Keep (a specific TEE instance) and are only revealed to the players when there’s a match between the secret words.
Standard engagement with the game involves playing Cryptle from the client-side and guessing the secret words.

The Cryptle Hack Challenge

Alternatively, players may also write their own application that run on the host side and attempts to deduce or otherwise guess the secret words. Implementers have the option to choose a mechanism, but the application must be publicly available (under an OSI license) on GitHub or GitLab. Any programming language may be used, but it should not be intentionally obscured. All root privileges should be granted to the application. It should be documented how the application can derive the secret words or guess them. Applications will be executed as ELF binaries on a host running a modern Linux kernel. There will be no physical access allowed to the host.

Profian CTO- Mr. Nathaniel McCallum announcing The Cryptle Hack Challenge at CloudNativecon'22.

You can still win prizes if you can hack Cryptle and report it to the team. Reach us out via our Chat.

References:

Do comment your ideas and suggestions related to the blog and please share if you found it useful.

Building Tic Tac Toe Game in Cpp using Wasm

Aryan Kaushik — Thu, 05 May 2022 22:59:31 +0000

Hi Folks, Welcome to another fanatstic blog where we will build a Tic tac toe game in Cpp using WebAssembly and will run it on browser.

So lets get started.

1. Install Emscripten

Enscrypten directly converts your C/C++ code to JavaScript which means you don’t even need to write any glue code for reading your .wasm file. This gives you enough flexibility to solely focus on the logic rather than implementation.
Secondly, it is very intuitive in terms of calling functions written in your C++ file to your JS file. You will see this once we dive into the code.

# Get the emsdk repo
git clone https://github.com/emscripten-core/emsdk.git

# Enter that directory
cd emsdk

Fetch the latest version of the emsdk (not needed the first time you clone)
git pull

# Download and install the latest SDK tools.
./emsdk install latest

# Make the "latest" SDK "active" for the current user. (writes .emscripten file)
./emsdk activate latest

# Activate PATH and other environment variables in the current terminal
source ./emsdk_env.sh

2. Write the Logic for tic tac toe

We will be building a 3×3 tic-tac-toe game. Our game logic includes:

a. Computing which player has won
b. Calculating if there is no winner
c. Indicating pending moves

Here is the program:

#include <emscripten/bind.h>
#include <emscripten/val.h>


using namespace emscripten;

val tic_tac_toe() {
    val board_values = val::global("BoardValues");
    val moves_pending_label = val::global("movesPendingLabel");
    val no_winner_label = val::global("noWinnerLabel");
    val empty_block = val::global("emptyBlock");
    bool moves_pending = false;

    val solutions[8][3]= {
        { board_values[0][0], board_values[0][1], board_values[0][2]},
        { board_values[1][0], board_values[1][1], board_values[1][2]},
        { board_values[2][0], board_values[2][1], board_values[2][2]},
        { board_values[0][0], board_values[1][0], board_values[2][0]},
        { board_values[0][1], board_values[1][1], board_values[2][1]},
        { board_values[0][2], board_values[1][2], board_values[2][2]},
        { board_values[0][0], board_values[1][1], board_values[2][2]},
        { board_values[0][2], board_values[1][1], board_values[2][0]},
    };

    for ( int i = 0; i < 8; i++ ){
        if((solutions[i][0] != empty_block) && (solutions[i][1] != empty_block) && (solutions[i][2] != empty_block)&& (solutions[i][0] == solutions[i][1]) && ( solutions[i][1] == solutions[i][2] )) {
            return solutions[i][1];
        } else if((solutions[i][0] == empty_block) || (solutions[i][1] == empty_block) || (solutions[i][2] == empty_block)){
            moves_pending = true;
        }
   }

   if (moves_pending) {
       return moves_pending_label;
   }

    return no_winner_label;


}

EMSCRIPTEN_BINDINGS(my_module) {
    function("tic_tac_toe", &tic_tac_toe);
}

3. Build command for converting C++ files to .wasm & .js files

emcc --bind -o tic_tac_toe.js tic_tac_toe.cpp

Now a index.html, tic_tac_toe.js & tic_tac_toe.wasm file will be genereated

Remember our tic_tac_toe() C++ function which was exposed by Embind, that is now available on the Emscripten module object.

However, we can only call our tic_tac_toe() once it’s fully loaded i.e, it’s runtime(.js glue code and .wasm file) is initialized. For this, we use onRuntimeInitialized callback which will run when the runtime is ready.

Now whenever any player clicks on any cell we call our C++ function as Module.tic_tac_toe() which will return the appropriate results.

4. Install Live Server to deploy & view your changes

npm install -g live-server

5. Open the project

python3 -m http.server 8080

Go to browser and type in localhost:8080 or http://127.0.0.1:8080/

Hence our the game is ready to play on the browser. Two players can play it together.

WebAssembly is truly remarkable and has indeed allowed us to do things that were previously impossible. This game can be your first step to work with wasm.

Do check our previously created projects:

References:

Do comment your ideas and suggestions related to the blog and please share if you found it useful.
Write your queries in comment section, we'll help you to resolve your errors.

Video to gif converter using Wasm

Aryan Kaushik — Wed, 04 May 2022 22:08:05 +0000

Welcome to the another Blog.
This one is going to be Super exciting!

Today, we're going to create Video to .gif convertor using wasm.
This could be used as your wasm projects or a mini project.

WebAssembly has made things so easy as traditionally we use to upload our apps to cloud server, where the server was working at the back end. But wasm allow us to perform CPU intensive jobs directly on our browser.

Here, we will use FFmpeg library(written in c language) to convert a video to gif. We will download wasm binary for ffmpeg directly into a react app which can enable us to offload the video editing work into our system directly through the browser.

So, Lets get Started.

1. Creating a Directory

a. Create a new directory wasm-gif.
b. Move into the directory cd wasm-gif/

2. Generating a new react app using snowpack:

npx create-snowpack-app gifmakr --template @snowpack/app-template-react

It will automatically fetch files for the react app.

3. Install FFmpeg

npm install @ffmpeg/ffmpeg @ffmpeg/core

4. Run the App

npm start

This command will let the default react app run in the browser.

If we check the Sources tab in elements/developer tools of the Browser, we can see the code converted into WebAssembly Text.

5. Writing the react code.

a. Go to src/ and open App.jsx and remove the boilerplate.
b. Add

(i) working with this library we'll set the log option to true so we can see everything that it does directly in the console now it's important to understand at this point that the actual webassembly binary has not been bundled in our application it's a pretty large file so we don't want it to block our web application right away.

import { createFFmpeg, fetchFile } from '@ffmpeg/ffmpeg';
const ffmpeg = createFFmpeg({ log: true });

(ii) To keep track of the loading state we'll go ahead and add a stateful property here called ready with the use state hook it has a default value of false and then we'll create an async function here called load that can flip it to true after the binary has been loaded.

function App() {
  const [ready, setReady] = useState(false);

  const load = async () => {
    await ffmpeg.load();
    setReady(true);
  }

(iii) Now we just need a place to call this function in react, So we can do that with the use effect hook to run this function when the component is first initialized use effect takes a function as its argument then notice how i'm adding an empty array as the second argument this will ensure that the function is only called once when the component is first initialized or mounted then inside the effect we can simply call our load function.

 useEffect(() => {
    load();
  }, [])


  return ready ? () : ( <p> Loading...</p> );
}

export default App;

6. Loading the Video file into the application

a. The first step is to add additional state to the component in this case a video file which will initially start undefined in the html we can add an input element with a type of file when this input changes we'll run an event handler that will set the video state and it gets the actual file from the event the event emits a file list and then we use item 0(FILE Object) to select the first file from that list.

function App() {
  const [ready, setReady] = useState(false);
  const [video, setVideo] = useState();
  const [gif, setGif] = useState();

  const load = async () => {
    await ffmpeg.load();
    setReady(true);
  }

  useEffect(() => {
    load();
  }, [])

b. Now that we have access to a video file we want to display it in an html video element we'll use a logical and operator to only show the video when the video file is defined the element has controls a width of 250 but a tricky thing here is that we can't just pass the raw file to the source attribute we need to convert it to a url that the
browser can fetch therefore assign a file to the URL.

 <div className="App">
      { video && <video
        controls
        width="250"
        src={URL.createObjectURL(video)}>

      </video>}


      <input type="file" onChange={(e) => setVideo(e.target.files?.item(0))} />

      <h3>Result</h3>

      <button onClick={convertToGif}>Convert</button>

      { gif && <img src={gif} width="250" />}

    </div>
  )
    :
    (
      <p>Loading...</p>
    );
}

export default App;

c. Now, we'll do here is add one more piece of state to the component called gif and it will be used to hold the end result which is a url of an image file from there we'll create a function called convert to gif which the user can run when they're ready to make the conversion now one thing to understand here is that webassembly is managing its own
in-memory file system and in order to run ffmpeg on that file we need to make it known to that file system we can do that by calling fs or filesystem along with the write file method along with the name of the fileand then we fetch the actual video file that we've collected from the end user what we've done is taken the video file and saved it to a place in memory as test.mp4 it can be now accessed by webassembly while it's in memory and it only stays in memory until the browser is refreshed from there we can run an actual ffmpeg
command.

import React, { useState, useEffect } from 'react';
import './App.css';

import { createFFmpeg, fetchFile } from '@ffmpeg/ffmpeg';
const ffmpeg = createFFmpeg({ log: true });

function App() {
  const [ready, setReady] = useState(false);
  const [video, setVideo] = useState();
  const [gif, setGif] = useState();

  const load = async () => {
    await ffmpeg.load();
    setReady(true);
  }

  useEffect(() => {
    load();
  }, [])

  const convertToGif = async () => {
    // Write the file to memory 
    ffmpeg.FS('writeFile', 'test.mp4', await fetchFile(video));

    // Run the FFMpeg command
    await ffmpeg.run('-i', 'test.mp4', '-t', '2.5', '-ss', '2.0', '-f', 'gif', 'out.gif');

    // Read the result
    const data = ffmpeg.FS('readFile', 'out.gif');

    // Create a URL
    const url = URL.createObjectURL(new Blob([data.buffer], { type: 'image/gif' }));
    setGif(url)
  }

  return ready ? (

    <div className="App">
      { video && <video
        controls
        width="250"
        src={URL.createObjectURL(video)}>

      </video>}


      <input type="file" onChange={(e) => setVideo(e.target.files?.item(0))} />

      <h3>Result</h3>

      <button onClick={convertToGif}>Convert</button>

      { gif && <img src={gif} width="250" />}

    </div>
  )
    :
    (
      <p>Loading...</p>
    );
}

export default App;

Finally, now we be able to open up your demo select a video file then when you click the convert button it uses webassembly to convert that file to an animated gif and it should log the entire process here in the console you could then take this file and upload it to giphy or use it on twitter or whatever you want and that's how easy it is to start incorporating webassembly into your web applications.

We Can also use CSS to make this app more interactive and beautiful.

Disclaimer: This application will only work on the browsers which support SharedArrayBuffer.

Try to install previous version of browsers if you are unable to build this app.

Reference:

Do comment your ideas and suggestions related to the blog and please share if you found it useful.
Write your queries in comment section, we'll help you to resolve your errors.

Image Recognition App using GoLang | Tensorflow | WasmEdge | Dapr | Docker

Aryan Kaushik — Tue, 03 May 2022 06:25:23 +0000

Hi Folks, welcome to another super interesting blog featuring another cool WebAssembly application.

It is an Image Recognition Application made using Go Language, works on a Tensorflow model and it requires Dapr and WasmEdge runtime for execution.

Small brief about these technologies:

In order to build microservices, Dapr is a versatile framework. Containers are required to initialise Dapr, here we are using Docker.
A WebAssembly VM, like WasmEdge, provides a secure and high-performance runtime for microservices.
WebAssembly-based microservices can be written in a number of programming languages, including Rust, C/C++, Swift, and JavaScript.
WebAssembly programs are embedded into Dapr sidecar applications and are therefore portable and agnostic to Dapr host environments.
A WasmEdge SDK makes it easy to create Tensorflow inference microservices.
WasmEdge is a Kubernetes compatible runtime and could play an important role as a lightweight container alternative to run microservices.

Let's get started:

1) We need to install Go, Docker, Dapr, WasmEdge.

sudo apt  install golang-go

WasmEdge

curl -sSf https://raw.githubusercontent.com/WasmEdge/WasmEdge/master/utils/install.sh | bash

Docker

sudo apt-get remove docker docker-engine docker.io containerd runc

Dapr

wget -q https://raw.githubusercontent.com/dapr/cli/master/install/install.sh -O - | /bin/bash

Initialise Dapr

dapr init

Check your Docker to verify

docker ps

2) Make a directory, for me its imgpro_wasm.

mkdir imgpro_wasm
cd imgpro_wasm/

3) Clone this git repo created by Second Stage.

git clone https://github.com/second-state/dapr-wasm.git

4) Go to fuctions/classify and build the classify function

cd functions/classify
 ./build.sh

5) Start Web Service for User GUI:

cd web-port
go build
./run_web.sh

6) Build and start the microservice for tensorflow-based image classification:

cd image-api-go
go build --tags "tensorflow image"
./run_api_go.sh
cd ../

7) The App is ready to Work

Open your default browser and go to:

http://localhost:8080/static/home.html

Hence the model will detech the objects in the images that will be uploaded to the application.

Wasm is an opportunity make more efficient, powerful, fast applications. Daily alot of Contributors are making a really good progress. Let's make much more interesting and cool applications using WebAssembly to make it more fun!

This ML model was created by Second State team. Do check their cool developments on their github.

References:

Do comment your thoughts and suggestions related to the blog and please share if you found it useful.

Enarx: The future of Trusted Execution Environment Frameworks

Aryan Kaushik — Sun, 01 May 2022 22:58:11 +0000

Hi Folks, Welcome to an another blog where we will learn about a leading Open Source Framework used for executing applications in TEEs (Trusted Execution Environments). It's part of the CCC(Confidential Computing Consortium) from the Linux Foundation.

Introduction:
Organizations from different sectors move their computing workloads across multiple environments, from on-premises to public cloud to Edge, they require greater assurances that their sensitive code and data are protected. This is especially true for sectors like banking & finance, government & public sector, telecommunications, Internet of Things, healthcare, customer data sensitive enterprise functions, defence, and human rights.

There are three states in which data can be protected: at rest, in transit, and in use. Encrypting data at rest and in transit have become a common practice in cloud computing, while encrypting data in use (the core idea behind Confidential Computing) is still an emerging concern:

a. Data at rest includes files, objects, and storage.

b. Data in transit includes data that is moving from one location to another such as across the Internet or a private network.

c. Data in use is data that is being processed in the CPU or memory.

Trusted Execution Environments (TEEs) provide a hardware-based solution to this need to maintain data confidentiality and integrity in use, regardless of who might own or have access to the host system on which the application is running.

Enarx aims to minimize the trust relationships required when executing applications, meaning that the only components which need to be trusted are: the CPU and associated firmware, the workload itself, and the Enarx middleware, which is fully open source and auditable. Applications run without any of the layers in the stack (e.g. hypervisor, kernel, user-space) being able to look into or alter the Keep or its contents.

It is CPU-architecture independent, enabling the same application code to be deployed across multiple targets, abstracting issues such as cross-compilation and differing attestation mechanisms between hardware vendors.

Provides attestation, packaging and provisioning of the application to take place in a way which is transparent to the user. Every instance of an application goes through three steps:

Attestation: Enarx checks that the host to which you’re planning to deploy is a genuine TEE instance.
Packaging: Once the attestation is complete and the TEE instance verified, the Enarx management component encrypts the application, along with any required data.
Provisioning: Enarx then sends the application and data along to the host for execution in the Enarx Keep.

Lets try it:

1. Install Rust

$ curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y

# set path variable
$ source $HOME/.cargo/env

2. Install WebAssembly Rust toolchain

$ rustup target install wasm32-wasi
$ cd~/

3. Install Enarx from Github:

$ git clone https://github.com/enarx/enarx
$ cd enarx/
$ cargo build

$ cargo install --bin enarx --path ./

so now Enarx is installed in your system and it's globally accessible everywhere in the system.

Since Enarx supports binary files for so to convert that we'll Build and run a WebAssembly module.

4. Create a simple Rust program

cargo init --bin hello-world
$ cd hello-world
$ echo 'fn main() { println!("Hello, Enarx!"); }' > src/main.rs
$ cargo build --release --target=wasm32-wasi

You can now run the WebAssembly program in an Enarx keep.

$ enarx run target/wasm32-wasi/release/hello-world.wasm
[…]
Hello, Enarx!

Latest Version of Enarx is Enarx 0.4.0: Fort of Dhat al-Hajj
Check out the changelog for more details.

Enarx was built to be simple to use. It abstracts away complex concepts and supports multiple architectures transparently so that users don't have to worry about these.

Checkout Enarx on Github and give it a star.

Join the Community using this Link, everyone is welcomed to share their contribution and thoughts.

References:

Confidential Computing Consortium- The next generation of Data Security

Aryan Kaushik — Sat, 30 Apr 2022 23:39:13 +0000

It's good to be back with another interesting blog!

WASM is considered as the third generation of Cloud Computing, and it is expected to boom in the upcoming time therefore Data Security needs an upgrade to keep up.

In previous blogs, we explored the properties & applications of WebAssembly,

But today we're going to learn about CCC (Confidential Computing Consortium) is an open-source community powered by The Linux Foundation, which works as the icing on the cake for Wasm.

Confidential Computing protects data in use by performing the computation in a hardware-based Trusted Execution Environment. These secure and isolated environments prevent unauthorized access or modification of applications and data while in use, thereby increasing the security assurances for organizations that manage sensitive and regulated data.

Importantly, the definition is not limited to “cloud” uses, but can be applied anywhere including public cloud servers, on-premises servers, gateways, IoT devices, Edge deployments, user devices, etc. It is also not limited to such trusted execution being done by any particular processor, since trusted processing might also be in various other places such as a GPU or a network interface card. Neither is it limited to solutions that use encryption, though this is the most common technique employed.

Trusted Execution Environments (TEEs):

A Trusted Execution Environment (TEE) is defined by the CCC, following common industry practice, as an environment that provides a level of assurance of the following three properties:
a. Data confidentiality: Unauthorized entities cannot view data while it is in use within the TEE.
b. Data integrity: Unauthorized entities cannot add, remove, or alter data while it is in use within the TEE.
c. Code integrity: Unauthorized entities cannot add, remove, or alter code executing in the TEE.

In the context of confidential computing, unauthorized entities could include other applications on the host, the host operating system and hypervisor, system administrators, service providers, and the infrastructure owner—or anyone else with physical access to the hardware.

Technologies that will be benefited by CC:

There are several projects within CCC with the main focus on the security and privacy of digital data. They are as follows:

Enarx
Gramine
Keystone
Occlum
Open Enclave SDK
Veracruz

Organisations that are part of this initiative:

Overall Expected Market growth of Confidential Computing:

In a report generated by the Everest group, it is expected about CCC is

The Total Addressable Market (TAM) for CC is likely to grow at least 26x over the next five years in the best-case scenario due to growing enterprise awareness of confidential computing.

The CC hardware and software markets are poised for exponential growth backed by expanding regulations, demand for comprehensive security postures, and an appetite for new revenue generators.

Multi-party computing and security-specific use cases across industries will be the biggest growth drivers for the technology.

Conclusion:

As a result, due to the increasing complexity of technology, privacy and security have become more difficult to protect. The Confidential Computing Consortium is a great initiative that is working to keep data secure in any system by creating a sophisticated enviornment. Getting more and more contributors in will put this on a meteoric rise within a short time.

Keep an eye out for the next blog in this series in which we will learn about the various projects that make up the Confidential Computing Consortium.

References:

Do comment your thoughts and suggestions related to the blog and please share if you found it useful.

Why Wasm is the perfect runtime for server-side applications.

Aryan Kaushik — Fri, 29 Apr 2022 12:18:28 +0000

Namaskar, welcome to another fantastic blog, previously we've tried to work with wasm on the user/client-side and learned its advantages but today in this blog we will try to understand the broader applications and advantages of Wasm in the tech industry i.e. using it on the server-side, it is much more functional than we've thought.

Every two years, the number of transistors on a microchip doubles e, though the cost of computers is halved. Moore's Law states that we can expect the speed and capability of our computers to increase every couple of years, and we will pay less for them. Another tenet of Moore's Law asserts that this growth is exponential. The machine learning tasks can run 60,000x times faster when we replace Python with native code and specialized hardware. WebAssembly is a key technology that makes the software more efficient, while preserving safety, portability, and software engineering best practices we built up in the past 25 years.

WebAssembly was invented as a client-side technology, but it is also proven very useful on the server-side. Server-side WebAssembly provides crucial benefits for modern web and service applications.

Fast: WebAssembly achieves near-native performance. Compared with the Java, Python, or JavaScript runtimes, it can be 10x to 100x faster (how is this possible?). It is also much faster than Docker, especially in the cold start and system access.

Safe: WebAssembly is a sandbox with a capability-based security model. It is not only safer than native binaries but also safer than OS-level containers like Docker. Yet it provides access to the underlying system, including new hardware features.

Portable: WebAssembly apps can be written in C, C++, Rust, Go, and run without change on different OS and hardware platforms.

Manageable: WebAssembly programs can be provisioned, started, hot-swapped, stopped, and moved around by other applications.

To run WebAssembly outside of the browser, You need a runtime. A runtime is an application that runs on the command line or via a static library that allows you to load your Wasm module and run it as if it was just any other program. SSVM, Wasmer, WasmTime, Wasm3, WAVM, and Lucet, are some common emerging Wasm runtimes that have been coming out from the community as of late.

SSVM: Second State provides an open-source WebAssembly implementation (Second State Virtual Machine, or SSVM) that is specifically optimized for server-side applications. It is

Best-in-class in performance. It is 1000x faster than Docker for cold starts.
Seamlessly supports server application frameworks, such as Node.js. You can build high-performance Node.js apps with SSVM.
Supports safe access to external resources, such as databases, message queues, and even new AI hardware
Allows precise metering of computational resources for serverless apps.

Wasmer: Wasmer is designed to provide three key features:
Enable programs to run in any programming language
Enable extremely portable binaries to run unmodified on any "OS" supported by Wasmer (for example, Linux, macOS, Windows and FreeBSD).
Act as a secure bridge for Wasm modules to interact with native "OS" functionality, via Application Binary Interfaces (ABIs) such as WASI and Emscripten (version 1.38.43 and earlier).

In a blog written by Libhunt, they compared SSVM & Wasmer

Emerging Tech Stacks where Wasmer is making a Significant Difference:

a) Blockchain: Wasmer's Single-pass compiler helps eliminate JIT bombs, enabling blockchain providers with a high-quality-of-service infrastructure for their applications.

b) Function-as-a-Service (Faas): Wasmer is a market leader for enabling WebAssembly on the server. It nearly eliminates all the challenges developers must deal with to fully adopt FaaS as a part of their application development strategy.

c) Machine Learning and AI: Wasmer nearly eliminates all the challenges developers must deal with for deploying machine learning applications in and outside of data center environments.

SSVM is also running with pace to make its runtime more efficient and progressing exponentially, while other WebAssembly runtimes are in the development stage and are making progress day by day. Soon we will see a lot of efficient Wasm runtimes on the server-side.

Conclusion:
Lately in the server-side development community, which is the desire to simplify, and is coming in the form of things like Functions as a Service, or serverless technology. There's AWS Lambda, OpenFaaS the serverless framework, things like that are really designed to make things simpler, again, because things have gotten much more complex in the last 5 or 10 years, with the rise of microservices and whatnot. It's made things more difficult.
Wasm can really help with this goal by building these very tightly constrained, highly composable modules from various languages, really whatever you want, and fitting them together into whatever configuration that you need for your application, is pretty compelling.

Check this Blog by @cohix where he explains Server-Side WASM: Today and Tomorrow!

References:

Do comment your thoughts and suggestions related to the blog and please share if you found it useful.