DEV Community: Masashi

Langjam Gamejam

Masashi — Sat, 20 Dec 2025 13:56:20 +0000

Day 1

There's only 6 days left. I had a ton of things to look after for the past few days so I completely missed the date.Infact, I started working on a fresh compiler for my language ~~graveyard~~ garden.

Suicmez, the Language

Suicmez underwent PDD (panic driven development). In the past month, I've done two speedruns of implementing languages from scratch. Both of them were in Rust, so naturally, I decided to use it for this thing as well. All that practice came in handy as I slapped together a lexer and a parser in about two hours.

However, I realised that things were way more challenging than I assumed them to be.

Performance

For ANY game (apart from tic-tac-toe or "guess the number"), I couldn't just have a bloated DSL that hogs 2GB of RAM and gives you 2FPS on flappy bird. The past two speedruns were treewalked (though one of the languages got a JIT
after the speedrun was over).

Suicmez had a few options:

Bytecode VM
JIT using Cranelift
Compiling to C

But that wasn't all.
I needed a typechecker. A robust one.
One without good enough inference would mean I'd have to spend time worrying about type annotations where I shouldn't have to. An overly complex one would mean that I'd finish the typechecker by next Christmas.

Then there was the runtime, the builtins, FFI support, etc.
And THEN ONLY, could I start working on a game.

Hopium

All of this was nearly impossible to do alone. So I set out on a search for a nice teammate.
Luckily, Nishi decided to join. I was overjoyed.

What We Did

We discussed the plans for the game and specifically, the compiler, and how it interacts with stuff. Nishi originally thought of using Milsko, his graphics library, but we'd have to do a ton of math stuff on our own if we wanted to use it for a game.
So we settled on Raylib.

Nishi primarily divided the work (for the game) into three sections:

Rendering
Collisions
Networking

And then, he started working on a networking library for the game, libfishsoup.

Day 2

The Best Team Ever

Shortly after, Wildered and El1i0r joined.

El1i0r was probably the most fluent in PLTDI theory stuff. So he helped us with some language design choices and helped me correct some of the sucky decisions I had made.

Wildered created a generational (pun intended) GC specifically for our use case. He also worked on the codegen part.

Now, we had set goals for the lang and the game.

The reason we chose not to use a bytecode VM was: performance.
The reason we chose not to use a JIT VM was: too complex.

A C backend was the Goldilocks solution to our problem.

Days 3-4-5

We decided to make a multiplayer FPS game. A 3D one. Last one standing wins.

These days went by in a haste, Wildered's GC was working perfectly. I started working on Suicmez's standard library.
We were utilizing ODE and Raylib. At some point, we did regret not choosing an engine but, we were already too deep in the rabbit hole.

Near day 5, I realized how big of a mistake we had made. Suicmez was way too abstract and high level to have nice C interop so me and Wildered spent a night adding low level features.

Days 6 and 7

Our target was to get things done by Day 6, but because of shader errors. Things rolled on to Day 7.

The terrain was just a green blob.
Luckily, we managed to fix it and, things went well.

So in the last 15 or so hours, we deployed the game on Nishi's VPS.

And with that, our work, was done. All that was left was to submit it.
We had a lot of fun throughout this game jam and ended it with a playtesting session (We all suck at the game).

My NeoVim Experience: Productivity vs Curiosity

Masashi — Fri, 24 Jan 2025 19:00:10 +0000

I've used a ton of IDEs and text editors to. Tried and tested everything to find which one can use best to optimize my workflow and write absolutely garbage code.

Before NeoVim

At first, I started with PyCharm by JetBrains. Pretty awesome IDE. A solid 9/10. However, it was too heavy for my liking. I was constrained by the specs of my device since I started out with a pretty weak laptop.

I had to switch.
I moved to VSCode. Loved the huge variety of extensions but yet again... too slow. Then I tried Atom (RIP Atom). Not sure why I gave up on it, but I did.

The Savior

After all this, I found the one that suits my needs the best.

Sublime Text.
(Did you think I'd say NeoVim? not yet.)
Light. Fast. Customizable. Too good!
I spent almost two years on Sublime Text.
I loved it. However, FOMO caught up to me. Moreover, I considered the "it makes you faster, more productive, etc" arguments and gave it a try.

NeoVim

I tried NeoVim with LunarVim. It was a really smooth experience for me. However, I wanted to customize it to my wants. I decided to give it a try by building a NeoVim config from scratch. I used Lazy for plugin management, Mason for LSPs, LuaLine and the Catppuccin theme.

The Experience

It's going well so far. However, the initial "learning curve" (me getting habituated) was costing me my productive. So, I decided to quit it and go back to Sublime Text for now. I'll return soon.
I loved setting NeoVim up and how fast NeoVim was. Using only the keyboard was fun but productivity comes first. I'll try NeoVim again and see how it goes!

Feel free to suggest me something, or uhhh, to just say something about it. Cheers!

Do We Need a New Framework?

Masashi — Wed, 29 Nov 2023 18:07:22 +0000

In the past few years, the frontend world has seen a surge in various frontend frameworks, all offering new solutions. However, do we really know what the problem in hand is? 🤔

Background and History 🤓

Frontend frameworks have been on the rise recently. Developers wanted more responsive applications; hence, the comfortable ✨SPAs✨ (pun intended).

SPAs (Single Page Applications)

This style was popularized by frameworks such as React, Vue and Angular.
These made UI development faster and were more modular than VanillaJS. Truly a revolution 🗣️.

What's wrong with SPAs?

Nothing.
Spas help you relax. Oh, my bad. I needed to talk about SPAs. You can still use SPAs; they are well supported. However, they do have demerits. After all, every coin needs to have two sides.

Bundle Size: The applications have a lot of things bundled together. This makes the initial page load rather time consuming.
Not as Performant as Vanilla: As a general rule of thumb, smaller is faster. React, Vue, etc. use a Virtual DOM. This makes any UI change costly in terms of computation. :( (Svelte does not have a VDOM)
Not SEO friendly: SEO stands for Search Engine Optimization. All search engines, such as Google, DuckDuckGo or Bing use crawlers. Crawlers "crawl" through the internet (the "web") and find the best pages to show in results. They DO NOT index JavaScript in the results. Only HTML. Pure, H-T-M-L. SPAs rely heavily on JS, and in fact, the initial loaded page hardly had any information in HTML. This makes them less SEO-friendly. (NextJS, NuxtJS and others of their kind let people use their favorite frontend framework such as React or Vue and render the content on the server. This is called SSR(Server Side Rendering)).

"There is no sadder sight than a pessimist." ~Mark Twain

The Positive Side

VanillaJS seems to be difficult to maintain. These frameworks with a VirtualDOM are not performant enough.
What can be done now?

Well....

We do have NextJS and other SSR options to improve the condition we are in right now, but it too has its downsides.
Moreover, it's limited to JavaScript. All data fetching and other things need to be DONE-IN-JS. This is not ideal for a full-stack situation (IMO).

Tying Existing Pieces Together

We know that SSR is better for SEO. SPAs are better for interactivity but are not performant enough.

Let's create... ✨ A new framework ✨.

"Seriously 😒"

Yes, I just grumbled about how there are too many frameworks out there.
HEAR ME OUT, PLEASE!
We will not implement "Yet Another React/Vue/Svelte." Our framework is new in terms of architecture and principles.

The Idea

If you made it this far, kudos. Take a cookie 🍪 <3.

TL;DR: Async page loads to make the app feel faster (say, Hotwire Turbo). Websockets for changing DOM contents (say LiveView) and interactivity.

Async page loads will make the user experience better.
For the DOM part, using Vanilla JS is not so maintainable (as aforementioned). Using the popular frameworks makes the page heavier. We seek a median. More maintainable than JS and lighter than Svelte. Much lighter than React, Angular, etc.

What next?

In the upcoming posts, we will create our very own JS framework. Yup!
For now, kindly drink some water and take some rest. Thanks a ton for reading through the article. The upcoming parts of this series will be worth it🔥.

Adios

Will you buy me a coffee? >_<

What Is Python Like?

Masashi — Mon, 06 Mar 2023 15:41:43 +0000

Hello there people! Hope y'all can relate to this and more importantly, hope y'all enjoy!

When a new Python developer sees code with semicolons run flawlessly:

When you get a huge task, but you can just import it:

When you accidentally mix tabs and spaces:

When your 3AM session gives you bugs.

Waiting for PyCharm to start:

Python developers when they code in C:

Someone after creating first Django project:

Removing the max recursion limits in Python:

When you realise that Python is older than Java

When someone says you cannot run arbitrary pseudo code, but you use Python:

PyPy is written in Python:

Asking old projects to migrate to Python 3:

I wrote this code:

true=False
false=False
if(true==false):
  print("Need a break?")

My friends' reaction:

Python programmers fighting the Rust compiler:

This was my collection of memes. I think that you found it funny. Feel free to share your favourite memes in the comments. If it seems like something doesn't make sense, maybe I can explain in the comments.

Oh, and enjoy your life. Hope y'all stay well.

Suggestions to Revive an Old Device

Masashi — Sun, 19 Feb 2023 08:50:44 +0000

Hello people. Lately, I remembered one of my proudest deeds. Somehow, that 'deed' gave me more pleasure than when I got a scholarship or when I ranked in the international top 10 in an Olympiad. You can call me wierd, but that delightful job was:

Installing Arch Linux on a practically unusable, old laptop.

I use Arch btw

You might have heard of this 'punchline'. This 'punchline' can actually get your face punched if you use it a lot(some people have a strong dislike apparently, and I would really like to know why), but I use it anyways.

Why Arch?

Well, Arch (apart from giving you a sense of immense satisfaction) gives you the liberty to choose from a plethora of choices about anything in your desktop.
It is basically like:

Your computer. Your design. Your choices.

(I made that thing.)

Getting started

Enough of Arch specific stuff.
Let's see the specific details of how to make our computer light.

The main factor in lightness is mostly the desktop environment (DE) . Keep a heavy DE and see your computer slow down or keep a light window manager(WM, it is not even a DE fully) and see yourself get frustrated despite having a fast computer. So basically, I will recommend you to choose something in between and XFCE seems to be the Goldilocks solution.

If someone says, 'what about systemd' or 'remove XYZ for PQR' or 'use a lightweight distro(Bodhi, Puppy, etc)' or something else; sure, it might be a good solution but Arch will give you a proper computer, not with some tradeoffs (except the installation).

Also, we should try to minimise background tasks (daemons) that run continuously.

RAM is the main factor in using old devices.

I Don't Want Arch

Well, if you have some personal grudge or mistrust against Arch, then you can consider some other options.

Manjaro ❌:

Manjaro might be well loved by the community and have lightweight variants(XFCE or the Manjaro Architect), but I don't recommend it. Manjaro has made a few huge blunders in the past such as forgetting to renew their SSL certificates numerous times.
Manjaro also had some. Also Manjaro claims to be stable by delaying the Arch packages by a week (which seems really idiotic to me). Moreover, Manjaro even caused a Denial-of-Service attack on the AUR(Arch User Repository) due to a broken version of pamac 😂(source). Overall, I had a pretty bad experience with Manjaro in the past and I would recommend everyone to stay away from it.

Linux Mint ✅

Linux Mint is renowned to be 'lightweight' yet feature-rich.
It comes in three editions, namely Cinnamon, XFCE and MATE.
You can choose the XFCE(or maybe MATE or Cinnamon) edition to install on your device. However, you must remember that it has Ubuntu at it's core and it has both it's pros and cons, but overall, happy journey if you use it(I have no personal experience regarding Mint).

EndeavourOS ✅

Almost Arch without the hassle of installation. EndeavourOS tries to be an Arch based distro as close to Arch as possible. You can go for it.

Installation of Arch

I will be providing a very easy to follow guide for the Arch installation in the next post. Till then, you can make some 'design choices' (Network manager, Bluetooth manager, etc) from the Arch wiki.

Happy revival folks!

Oh, and please let me know why people don't like 'I use Arch, btw' because I use Arch, btw.

Hobbyists, Do Not Quit

Masashi — Mon, 23 Jan 2023 17:42:30 +0000

Programming as a Hobby

So, here is my story. I was a kid who was busy with boring and usual everyday things. This was until I found out about this whole new world. It was really motivating since I could see what I created (what I made was not usable enough in the beginning, but later I improved). During the COVID pandemic, programming was everything to me. I learnt and made a lot of things during that period.

The Challenge

I am a school student and thus, have to give enough time to my studies. Now I also have other things which were not present during the pandemic.

This is where the problem is. Time is limited.

The Solution

You don't have time, you make time.

This quote is the key to time management.

You might not get 'long coding hours' of about 2 to 3 hours, but you can always keep 30 minutes of your valuable time aside everyday for your beloved hobby (that is in my case, yours may vary). You can make very minute progress everyday, but remember that you will eventually have a finished project that will make you realise that:

It was all worth it.

Happy coding to everyone, especially the hobbyists like me who take their hobby seriously. If you are going through tough times, just remember that things will get better and that a hobby can bring unfathomable levels of joy. Also, kindly let me know about your experience of first programming and how you started.

Part-0 The Plan

Masashi — Sat, 14 Jan 2023 10:40:10 +0000

In this series, we are going to build a compiler. I assume that you have limited knowledge of working of compilers. It is a nice exercise, and is cool as well. So, you have come to the right place if you wanted to make a programming language or just make another compiler for some other language.

Where to start?

First step, define your language if you want to create a new one(if you are implementing an existing language, say another C compiler like GCC, you may skip it).
Second step, choose the language in which you will create a new language. Choose a language you are somewhat comfortable with. However, it is very helpful if your language of choice has pattern matching. [My choice: Rust]
Third step, start with the implementation.

How does a compiler work?

First a compiler will read your file, then it will convert the code you have written into tokens. A token is the tiniest component of any program. It can be a comma, semicolon, an identifier like "my_variable" or some keyword like "if" or some operator like "+". This part is called lexing.

Then, it will create a data structure called the AST(Abstract Syntax Tree) from the tokens, representing your program logic. This process is called parsing.

Note: After parsing, some compilers check for unused variables, unreachable code or some other bugs such as referencing an undeclared function or variable and so on (This is called static analysis).

After the AST is created, we will convert each node of the tree(AST) into some meaningful code that will be executable. In jargon, we transverse the AST to translate it into some low level code.

What is 'low level code'?

Many of you might have used Java or Python. The compiler (they have both a compiler and an interpreter, but I will get into it later), will translate the code you typed into a stream of tokens and then into an AST and finally, into a bytecode. This bytecode is then executed by a 'virtual machine'. The VM(Virtual Machine) is basically a program that understands the bytecode (returned after the AST is translated)and runs according to that bytecode. To make it clearer, I'll show an example. Say someone wrote a program.

print("hello world")

The Python compiler will see this and turn it into an AST which will be run by the python interpreter. The interpreter will see the bytecode and say 'Okay, I have to print something on the screen, let me do it.'

This mechanism makes the code platform independent because the programmer will (usually)not have to worry if her/his code is going to run on Windows or Ubuntu/Fedora/Arch or Mac or some other operating system (I use Arch btw).

However, the AST can also be translated into machine code or assembly as done by C or C++ or Rust compilers.

Now that you know how the code is translated into executable, you should also know that this process of translating of AST into bytecode or machine code is called code generation or 'codegen'.

Any suggestions are welcome. I will be implementing the compiler in the upcoming posts.

ASGI: A brief overview

Masashi — Fri, 10 Dec 2021 07:33:12 +0000

Starlette, FastAPI, Quart, all are web-frameworks, (backend), but, they all have one more thing in common. They are based on ASGI.

In PEP-333, WGSI was introduced, long ago, why? To facilitate the use of any web server with any WSGI-based framework. As a result, we have Flask, Django, Pyramid and other frameworks, and WSGI servers like Gunicorn.

Why ASGI?

ASGI stands for Asynchronous Server Gateway Interface and it lets us use any ASGI web server with any ASGI-based framework.

Pretty much the same right? But, WSGI was sync and ASGI is async (obviously).

What should I do with this info?

ASGI makes it much easier to make a web framework (though you don't have to) and it works on three components. scope, send and recieve.

Scope

The scope is a python-dictionary object that contains information about the connection. Such as, is it http or https or ws(websocket) or wss(ws secured) or something else.

Eg:

{ 
  "type" : "http",
  "method" : "GET",
  "path" : "/api",
  "query_string" : "userid=999",
  "headers" : [
      b"accept-encoding": b"gzip, deflate, br",
      b"connection": b"keep-alive",
      b"cookie": b"a=b",
    ],
}

No text parsing, just use it. Pretty simple.

Send

Sends a Python-dictionary object containing your response.

await send({
   'type': 'http.response.start',
   'status': 200,
   'headers': [
      b"content-type": b"text/html",
      b"date" : b"Fri, 10 Dec 2021 06:16:51 GMT",
      b"cache-control" : b"none",
      b"set-cookie": b"a=b"
    ]
})


await send({
    'type': 'http.response.body',
    'body': b"Hello user",
})

Recieve

It is used get more info from the user after connection is established. Eg: HTTP body.

But still, where do I use these?

It all is there in an ASGI callable as arguments.

It may be a function or a class.

Eg:

async def app(scope, recieve, send):
# Some logic here

or,

class App:
# other things
  async def __call__(self, scope, recieve, send):
   #Some logic here

Conclusion

ASGI is used to make frameworks, but knowing it is needed for working with Starlette, and maybe other frameworks as well. It can be used for making middlewares of other frameworks as well. It can be used for other protocols. There is a variety of things to build by following this specification. This was just a brief overview. Read the full specification at asgi.readthedocs.org. If you want to see an example of application of ASGI, look at an HTTP framework named willpyre that I made, or check some well known framework like Starlette, or Sanic.
Also, check some ASGI servers like Uvicorn, Hypercorn or Daphne if you want to see how the specification is for the servers.

That was all. Hope you all stay well.