DEV Community: shaheer khan

Are we still in the Console Era of AI?

shaheer khan — Wed, 27 May 2026 11:15:47 +0000

I was scrolling through my feed recently when I saw something that felt like a glitch in the simulation. A developer had built a terminal emulator called "Ratty" a GPU-accelerated, 3D environment where the cursor is a spinning 3D rat and you can literally tilt your entire workspace in 3D space like a PS2 game.
It was weird. It was "useless" in the most beautiful way. But as I watched those 3D objects render inside a terminal, it hit me this insight:

We have spent forty years running away from the terminal, only to realize we might have just accidentally abandoned one of our most important collaborators behind.

The Great Human-Centric Detour

The core issue isn't that we want 3D elements in our terminal; it’s how we've navigated multiple revolutions to perfect user interface frameworks for humans, while completely ignoring AI as the next great user class. In our obsession with making software accessible to ourselves, we never bothered to design UIs that are friendly for them.

Since the 1980s, the driving mandate of software engineering has been "Human-Friendly or Bust." We migrated from the Command Line Interface (CLI) to Graphical User Interfaces (GUI) so humans wouldn't have to memorize syntax "spells" just to interact with a machine. We built React, SwiftUI, and mobile-first paradigms to reduce friction, turning complex code into an intuitive, responsive "slab of glass."

But in our rush to make applications beautiful for human eyes, we made them invisible to AI

The "Translation Tax"

We are currently living in a bizarre paradox: we expect AI to operate like a Senior Software Architect, yet we force it to interact with our applications like a confused detective. Modern frontend frameworks (like React or Flutter) are meticulously optimized for pixels, not AI interpretability. This forces AI agents to reverse-engineer visual layouts through brittle, lossy workarounds like Optical Character Recognition (OCR) or DOM tree inspection.

This is the Translation Tax. We have built a world of visual illusions tailored for human perception. For AI, however, this world is a fragmented, chaotic mess. We are stuck in a new kind of "primitive era" because we are still forcing advanced AI to adapt to our legacy graphical interfaces, rather than building systems that naturally speak its language.

The Next Leap: The Bilingual UI

The path forward requires a shift toward AI-Native Frontend Frameworks and user interfaces that are fundamentally bilingual.

For every Visual Layer rendered for human eyes, a parallel Semantic Layer must be generated underneath. This underlying architecture allows our digital collaborators to navigate a UI as effortlessly as we do.

In this paradigm, an AI doesn't "look" at a screen or guess where a button is; it instantly reads and mutates the application's state. The need for fragile prompt engineering tricks or seven-paragraph operational instructions disappears entirely. The "prompt" fades away because the application and the AI finally share the same semantic reality

Beyond the "Command Line"
Right now, sharing "prompt hacks" on social media is the 2026 equivalent of sharing Linux shell hacks in 1995. It feels powerful and elite, but it's actually a symptom of a primitive ecosystem.

We shouldn't be proud that we've learned to "talk to robots" in clumsy natural language strings. Instead, we should be questioning why our software architectures are so inherently AI-unfriendly that we have to rely on natural language just to bridge the structural gap.

The terminal era won't end when AI gets smarter. It will end when our UI layer stops acting as a barrier and starts acting as a bridge. Only then will we move past merely "using" AI, and step into a shared environment where the machine finally understands exactly what we mean-zero translation loss required.

JavaScript to Java - A Comprehensive Comparison

shaheer khan — Tue, 03 Jan 2023 14:38:03 +0000

Comparing 2 weirdly different languages to get a better understanding. Some may like this approach and some won't. But no other ways to find out. And this is not like that one place that you find everything that you need to know about these languages. this will more like be an article on where it is and where might these be heading to.

I'm a bit hesitant on recommending this to absolute beginners as some of the words can be confusing. But still I'll try to use as mush as simple words to explain these concepts.

As the Programming industry has been constantly improving with no slow downs, we have ended up with a load of technologies and languages to learn. And when you look at it from a beginner perspective it can be so confusing. So, I'll to give a little bit of overall on what has changed on these two languages and how they work. Because java is one of the oldest and a most solid language and JavaScript on the other hand is mentioned as some kind of a modern language and so I think it'll be interesting to compare them and see what has changed.

Before we go deep down let me give a little overview on..

Where we use these languages.

Java is a general-purpose programming language that is widely used in a variety of contexts, including desktop app development, web development, mobile development, and enterprise applications.
Java is known for its portability, scalability, and performance, and it is commonly used to build large-scale applications that need to run on a variety of platforms.

And JavaScript is also a general-purpose programming language, but it is primarily used for web development. JavaScript is used to add interactivity and dynamic behavior to web pages, and it is supported by all modern web browsers. JavaScript is also used to build server-side applications using runtime environments like Node.js, and it is increasingly being used for mobile development using frameworks like React Native.

So, generally we can use both languages to build Desktop apps, Mobile apps and Server side apps with their own pros and cons.
And that is also a main reason for choosing this topic as both of them are competitive with their abilities.

And now go a bit deep and look at a core attribute of these languages.

How these languages talks with the processor.

Even though they mostly serve similar purposes the way that they talk to the processor (central processing unit or CPU) can be quite different.

In Java, the code is compiled into bytecode, which is a low-level machine-readable format that can be executed by the Java Virtual Machine (JVM). The JVM is a runtime environment that is responsible for executing the bytecode and managing the memory and resources of the program. When the JVM runs the bytecode, it translates the instructions into machine code that can be understood by the CPU.

In JavaScript, the code is typically interpreted by a JavaScript engine, which is a software program that executes JavaScript code. The JavaScript engine reads the code and translates it into machine code that can be understood by the CPU. Unlike Java, JavaScript is not compiled into a standalone executable file (You can find a ton of tutorials on how to compile java code on YouTube), but is instead executed directly by the JavaScript engine as it is encountered in a web page or other context.
JavaScript engine may differ from the browser you use.

Data types

In both Java and JavaScript, variables are used to store values in memory. However, the way that these values are stored and accessed in memory can be quite different between the two languages.

In Java, variables are stored in a specific location in memory, and the location is determined at runtime by the Java Virtual Machine (JVM). The JVM also manages the lifetime of variables, allocating and deallocating memory as needed. Java has a number of different data types, including primitive types (such as int, double, and char) and reference types (such as objects and arrays). Primitive types are stored directly in memory, while reference types are stored as pointers to the memory location where the object is stored.

In JavaScript, variables are also stored in memory, but the way that they are stored and accessed is quite different from Java. JavaScript is a dynamically-typed language, which means that the type of a variable is determined at runtime and can change during the lifetime of the variable. JavaScript variables are not bound to a specific location in memory and are instead stored in a variable object associated with the current execution context. JavaScript has a number of different data types, including primitive types (such as number, string, and boolean) and reference types (such as objects and arrays). Primitive types are stored directly in memory, while reference types are stored as references to the objects they represent.

Also something we often hear is that Java is a statically typed language and JavaScript is a dynamically typed language. And recently TypeScript was introduced and it works like JavaScript with types and more. And java also recently introduced the var keyword in Java 10 which acts like a dynamic datatype. Still it is not a dynamic data type it just allows you to declare variables without specifying an explicit type, and the type is inferred from the initializer expression. So, here also we can see these languages are having some similar moves.

Understanding these can be an advantage when working with either language.

Object Orientation

Object oriented programming is not specific to any languages. It is a concept used in programming and can be achieved with their own ways with different languages.

Java
Java can be one of the first languages that comes to our mind when we hear OOP. And below I'll add the key areas of how these two languages handle this technique.

Java is a class-based OOP language, which means that objects are created based on a class definition.

Example for class-based OOP -

public class Person {
  private String name;
  private int age;

  public Person(String name, int age) {
    this.name = name;
    this.age = age;
  }

  public void greet() {
    System.out.println("Hello, my name is " + this.name + " and I am " + this.age + " years old.");
  }
}

To create a new Person object in Java, you would use the new operator like this:

Person p = new Person("John", 30);
p.greet();  // Output: "Hello, my name is John and I am 30 years old."

Java has four access modifiers (public, protected, private, and default) that determine the visibility and accessibility of class members (fields, methods, etc.).
In Java, it is possible to define multiple methods with the same name but different parameter lists, a technique known as method overloading.
Java has a concept of static members, which are associated with a class rather than a specific instance of the class.
Java has a feature called interfaces, which allow a class to specify a set of methods that it must implement.

JavaScript

JavaScript is a prototype-based OOP language, which means that objects can inherit properties and methods from other objects (called prototypes). (Also note that JavaScript introduced Classes in ES6 which can be used as a syntax to create objects and defining their behaviors).

Example for prototype-based OOP

let person = {
  name: 'John',
  age: 30,
  greet: function() {
    console.log('Hello, my name is ' + this.name);
  }
};

To create a new object that inherits from the person object in JavaScript, you would use the Object.create method like this:

let student = Object.create(person);
student.study = function() {
  console.log(this.name + ' is studying.');
};

student.greet();  // Output: "Hello, my name is John"
student.study();  // Output: "John is studying."

class-based OOP languages use classes to define objects, while prototype-based OOP languages use prototypes to create new objects that inherit from existing objects. Both approaches have their own benefits and trade-offs, and the best approach to use depends on the specific needs of the application.

JavaScript does not have access modifiers, and all object properties and methods are public by default.
JavaScript does not support method overloading, but it does allow functions to be defined with optional parameters.
JavaScript does not have a direct equivalent to static members, but it is possible to achieve a similar effect using the static keyword in a class definition.
JavaScript does not have interfaces, but still we can use a regular object with no special behavior or enforcement if we want.

These are just a few of the differences between Java and JavaScript. There are many other differences between the two languages, and it is important to understand the specific features and capabilities of each language when working with them.

I didn't go in-depth about all the features. But I hope someone would find this helpful. And your corrections or suggestions are always welcome as they helps me to improve.

And If you loved it, please don't hesitate to leave a reaction Your support will be very much appreciated.

Cool Hamburger Animation CSS

shaheer khan — Wed, 17 Nov 2021 08:30:56 +0000

Why?

Simple answer is I made this to practice CSS Animations.

But there's another reason which is I saw a ui/ux designer making this animation on IG and some people on comment section pointed out that these animations are quite complex to implement when it comes to code which is true.

But with the help of CSS transform property and its values like rotate and translate it was a little easy to do.

You can see the work on my codepen.
Link

Please feel free to drop your thoughts 🤗