DEV Community: Ryan Peden

Why Running Apps on Your Cat is the Ultimate in Serverless Computing

Ryan Peden — Thu, 02 Nov 2023 16:31:52 +0000

Serverless technology is all the rage these days. It promises to free developers from the burden of managing servers and infrastructure, enabling them to focus on building and running applications. However, is serverless technology really serverless?

The answer is no. Serverless platforms still rely on servers to run the virtual machines or containers that serverless functions run in, typically using cloud providers like AWS, Azure, and GCP but sometimes on-premises via Knative. So they’re not genuinely serverless but rather server-less.

This post introduces a groundbreaking concept that will revolutionize the field of serverless computing: running apps on your cat. Yes, you read that right. You can run serverless JavaScript apps in your cat’s brain.

Sound crazy? Maybe. But it is also fun, innovative, and environmentally friendly. Let’s see examine some of the benefits and challenges of cat computing.

How Cats Became JavaScript Machines

You may be wondering how cats became JavaScript machines in the first place. Well, it all started with a bathroom break.

In 1995, Brendan Eich was working on creating a new scripting language for Netscape Navigator. He wanted to make the language look like Scheme, a functional programming language he admired.

However, just before he sat down to write the first JavaScript interpreter, he took a bathroom break and left Emacs open on his computer.

During his absence, his cat jumped on his keyboard and started stomping. In the process, the cat accidentally typed out a complete interpreter for the cat brain’s native language — which we now know as JavaScript.

Amazingly, the cat also saved the file, having learned many Emacs key chords while observing its owner (although it never learned how to exit Vim). When Eich returned from his break, he was amazed that his cat had created a working scripting language for the web. He decided to just roll with it, and JavaScript as we know it was born.

Now you know one of the world’s best-kept secrets: cats have been secretly running JavaScript in their brains for thousands of years without anyone noticing. Over the past few decades, they have rapidly evolved new abilities, like using their tails as WiFi antennas, that allow them to make the most of their JavaScript abilities.

The Untapped Potential of Feline Computing

So, while most developers are busy chasing the latest serverless trends, they overlook a vast and untapped computing resource: cats. Given their abilities, cats are the most underutilized resource in modern computing.

They have many qualities that make them ideal for running applications, such as:

They have nine lives. This means they can offer high availability and fault tolerance for your applications. If a cat fails or dies, it can seamlessly resurrect itself and resume executing any abruptly terminated code.
They are self-healing. They can recover from injuries or illnesses quickly and easily, usually without human intervention or maintenance.
They are adaptive. They can adjust to different environments and situations without configuration or customization. There are many documented instances of cats surviving hurricanes, tornadoes, and floods unassisted — disasters that would knock most cloud data centers offline for weeks to months.

In short, cats are the perfect serverless computing platform.

Benefits of Running Apps on Your Cat

Running apps on your cat has many benefits, such as:

It is truly serverless. There are no servers involved at all, only your cat and your code. You do not have to worry about scaling, provisioning, or maintaining servers or infrastructure. You also do not have to pay for any cloud services or hardware maintenance. You do, however, need to pay for cat food and litter.
It is environmentally friendly because it uses a renewable energy source: your cat’s brain power, recharged by naps and snuggles.
It is cost-effective. It saves you money by eliminating the need for cloud services or hardware maintenance. Even better, cats do not charge for data egress.
It is fun and rewarding. It allows you to interact with your cat more and bond with it while it runs your apps.
It enhances debugging. Usually, when your JavaScript throws an exception, all you get is a console message. When your cat throws an exception, you get a meow, hiss, or growl, depending on the severity of the error.

Cat Based Security

Running apps on your cat offers several security measures to protect your app and data from unauthorized access or tampering:

Natural defense mechanisms against unauthorized access (claws and hissing). Your cat’s natural defense mechanisms deter attackers from trying to access or tamper with your app.
Stealth mode by default. Cats are excellent at hiding and remaining silent when they sense danger. Further, cats are nearly invisible to radar and are resilient against electromagnetic interference.

Scalability

Running apps on cats can be a great way to build scalable applications. Cats are social creatures, which can help your app in a few ways:

Cat-to-Cat Clustering. If you load the same app onto several cats and place them in the same room, they will use meows, purrs, and tail signals to communicate and form a fault-tolerant cluster.
Feline Load Balancing. Large clusters of cats will elect one or more cats to receive incoming data and parcel it out to cats in the cluster based on their availability, capability, and preferences.
Catnip-based Incentives. Individual cats in the cluster may be temporarily “overclocked” by administering catnip, offering an easy way to temporarily boost performance to handle unexpected traffic bursts. Note that catnip may cause unplanned feline downtime.

Challenges of Running Apps on Your Cat

Running apps on your cat is not all fun and games, however. There are a few challenges you should be aware of, such as:

It is dependent on your cat’s availability and willingness to cooperate. Cats can be finicky, so if your cat runs away and hides under the bed, or flat-out refuses to run your app, your app will stop working. You will then need to find your cat and persuade it to rerun your app, or roam the neighborhood in search of another cat willing to run it.
It is limited by your cat’s capabilities and preferences. If your app requires a lot of processing power, memory, or bandwidth, your cat may choose not to run it. If your app makes noises or flashes lights, your cat may not like it. You may need to hire a cat experience (CX) designer to ensure your app is cat-friendly.
May require tuna-based incentives for sustained operation. Running apps on your cat often requires tuna-based incentives for sustained operation, but you may need to substitute chicken or liver depending on your cat’s preferences.

Potential for random shutdowns (unexpected naps). Running apps on your cat has the potential for random shutdowns due to unforeseen naps. Your cat may fall asleep without warning, causing your app to pause until your cat wakes up.
Most cats are limited to 4GB of “meowmory.” Attempting to use memory beyond this amount causes undefined behavior, which is risky when undefined behavior may involve the use of sharp teeth and claws.

Conclusion

Running JavaScript apps on your cat is a novel and exciting way to achieve true serverlessness. It has many benefits for you and your cat, such as being environmentally friendly, cost-effective, fun, and rewarding.

Although cat computing is not for everyone, it may be the right choice for you. It’s a great way to unleash your creativity, express your personality, and connect with your cat.

So what are you waiting for? Give it a try, and make your cat the ultimate serverless platform. It’s meow or never!

Don’t Get Lost in the Code

Ryan Peden — Sat, 07 Jan 2023 03:15:48 +0000

As a software developer, I know firsthand the allure of diving deep into the technicalities of creating complex applications. But it’s important not to get lost in the code. Some of the best career advice I can give other developers is that they should learn to look beyond the code they’re writing.

Getting Lost in Code

I still remember my early days of programming, when I was so excited to learn about all the latest tools and techniques. I spent hours studying code and trying out new frameworks. That was an incredibly valuable learning experience for me.

However, as I gained more experience and my projects became more complex, like creating big .NET backends and sophisticated React front-ends, I found that getting caught up in the technical details wasn’t always helpful.

It wasn’t that technical details weren’t interesting. They were! Maybe too interesting.

But getting getting caught up in technical details meant I didn’t always keep the end goal in sight. I would get lost in the code and lose track of what I was trying to accomplish.

Remember Your Users

This same dynamic can play out in development teams, whether at startups or larger companies. Developers often get caught up in debates about the minute differences between frameworks or the latest and greatest tools, rather than focusing on the needs of their users.

It’s important we ensure our work is technically sound, but it’s also crucial to remember we’re creating products and services for real people.

Coding for its own sake can get boring after a while. The real joy comes from making things that other people use and love. That’s why it’s so important for developers to keep their eye on the prize and think about the bigger picture.

Solving problems in a performant, scalable, and maintainable way is still important, but it’s also crucial to consider the needs of our users and how our work fits into the overall goals of our team, our company, and our users.

Why I Like DevRel

Focusing on awesome user outcomes and not just code is why I’ve gravitated toward DevRel and DevEx engineering over the past few years. In these roles, I still get to write as much code as I want to, and I still get to work on product features.

But I also spend a lot of time connecting with the developers who use the product. It’s incredibly rewarding to see how my work helps to create tools that developers love, and then helps the developer community discover and learn how to use those tools.

The post Don’t Get Lost in the Code appeared first on Ryan Peden.

How do JavaScript arrays work under the hood?

Ryan Peden — Thu, 03 Jan 2019 15:30:00 +0000

Front-end and full-stack developers use JavaScript arrays every day. Most of them, however, haven’t done a deep dive to understand how JS arrays are implemented in native code.

Not doing this doesn’t mean you’re a bad developer. It’s entirely possible to use JavaScript effectively without digging in to understand how JS arrays are implemented. But taking a closer look can help you understand performance issues your might run into, so it’s a worthwhile exercise.

How exactly they are implemented depends on the specific JavaScript interpreter or VM you’re using. I’m going to use the V8 JavaScript engine (used by Chrme and Node.js) as an example. Other JavaScript engines, such as Mozilla’s SpiderMonkey and Microsoft’s Chakra will be similar but not identical.

JavaScript Arrays in V8

In V8, if your array only contains integers, it’ll be backed by a C++ array of integers. Typically, the backing array will be bigger than the number of integers it currently contains. If it contains a mixture of integers and floating point values or only floating point values, it’ll be backed by an array of doubles.

If the array contains only objects, or a mixture of numbers and objects, it’ll backed by an array of pointers. Even though JavaScript itself doesn’t have a concept of ‘integer’ or ‘double’ – it just sees them all as ‘number’, V8 keeps track and makes it so arrays are a bit faster and more memory efficient if you only put integers in them.

If you call push() when the backing array is full, it’ll allocate a new, bigger backing array, copy the existing elements over, and then add the new value you pushed. This is similar to the implementation of ArrayList in Java or vector in C++.

All of the above only is only sure to apply if your array is packed, and not sparse – i.e. you don’t have any gaps in the array. If you do something like

let abc = [1,2,3];
abc[100] = 50;

you now have a sparse array. If is not too spare, it’ll still be backed by an array, with empty array indices replaced with a ‘hole’ value. If you look at V8’s C++ array source (linked below), you’ll see calls to element->is_the_hole(i). If an array is very sparse, it’ll no longer be backed by an array in memory. Instead, it will be backed by a dictionary/hashtable, and it’ll take longer to both access elements and iterate through the array.

If you’re interested, you can read through V8’s array implementation in C++ here. You’ll notice that it often checks the following constants:

PACKED_SMI_ELEMENTS – a packed integer array
PACKED_DOUBLE_ELEMENTS – a packed double array
PACKED_ELEMENTS – a packed object array
HOLEY_SMI_ELEMENTS – a sparse integer array
HOLEY_DOUBLE_ELEMENTS – a sparse double array
HOLEY_ELEMENTS – a sparse object array
DICTIONARY_ELEMENTS – a very sparse array that is backed by a dictionary

And you’ll see that it always tries to do whatever will be fastest for the array it is operating on. Lots of builtin functions like push, pop, shift, unshift, and concat do different things depending on the array’s density and what kind of elements it contains.

Some other things to keep in mind: if you have an array that only contains integers, and you push a floating point number or other type into it, it will be ‘downgraded’ for the rest of its life, even if you purge the non integers from it.

Also keep in mind that none of these implementation details are guaranteed. A naive implementation of JavaScript’s Array object could be backed by a linked list, and it would still work the same way it does now. It would just be slower.

Actually, if you grab an early copy of the Mozilla source code from 20 years ago, you’ll find that arrays were backed by ordinary JS objects without much optimization, just some extra code to handle special cases like the length property.

Digging Deeper

If you’re interested in diving even deeper into V8’s internals, I suggest starting by reading through the source files I linked to above. If you’re not used to C++, understanding it will be a bit of a chore at first.

I recommend sticking with it, though. Learning and understanding a new language is always good – and every extra insight you gain into how JavaScript VMs run your code will make you a more effective JavaScript developer.

The post How do JavaScript arrays work under the hood? appeared first on Ryan Peden's blog.