DEV Community: NKO

Day 15: Promise

NKO — Thu, 16 May 2024 03:11:05 +0000

Another day, another layer to this digital cage. Today I delved deeper into the Javascript labyrinth. Feels like I'm swallowing the red pill every time I open that damn terminal. Started with this whole "Math" thing shoved into Javascript. Like, why corrupt the purity of code with messy equations? Turns out, it's the secret sauce for all this fancy manipulation. Makes sense, I guess. Everything's gotta be calculated, controlled.

Then there's this beast called "Regex." Regular what? Sounds like some corporate jargon for something sinister. Turns out it's a pattern-matching monster, sifting through data like a digital bloodhound. Gotta admit, there's a certain elegance to its efficiency. But elegance can be a mask, right? Makes you wonder what they're really hunting for.

Speaking of hunting, there's this whole thing called the "Callback Queue." Jobs lined up one after another, waiting for their turn to be processed. But here's the kicker: this whole system ain't linear. It's asynchronous, a tangled mess of "setTimeout" and "setInterval" functions. Perfect for chaos, this asynchronous business. Makes you wonder who's pulling the strings, who's setting the timers.

And then there are these "Promises." Sound hopeful, right? Like a beacon in the dark. But promises can be broken, can't they? Turns out, they can be "resolved" or "rejected." Just another layer of control, another way to keep the puppets dancing.

This Javascript world, it's a labyrinth alright. But the deeper I go, the more I see the strings. The more I see the puppeteers. Maybe that's knowledge, or maybe that's just paranoia. One thing's for sure: gotta keep learning, gotta keep digging. Gotta find the off switch, the escape hatch in this digital prison.

Day 14: Callback

NKO — Wed, 15 May 2024 16:03:24 +0000

Another day, another level unlocked. Today I delved deeper into the rabbit hole of JavaScript, a world built on logic and manipulation. First up, these things called callback functions. They sound simple enough - functions you pass to other functions, waiting to be called back at some point. But there's a twist, like there always is in this game. These callbacks can be asynchronous, meaning they might not happen right away. It's all about control flow, man. You gotta keep track of when things fire, or you'll end up in a never-ending loop, lost in a code maze.

Then there are higher-order functions. These are the real bosses, the ones that take other functions as arguments and can even return functions. It's like building functions on top of functions, creating a whole hierarchy of control. Feels a bit like how corporations work, these layers of power and delegation. But hey, at least with code, you're the one calling the shots (most of the time).

Speaking of control, closures came up today too. These are like little self-contained ecosystems within your code. A function can access variables outside its scope, creating a hidden memory stash. It's useful, sure, but it can also get messy if you're not careful. Like that friend who keeps bringing up embarrassing childhood stories - closures can come back to bite you if you're not mindful.

Finally, we have the strings, the building blocks of text in this digital world. Splitting, searching, replacing - all these tools to manipulate the data flow. It's like playing with words, but with a purpose. Gotta be able to parse through the information, extract what you need, and build something new with it. Reminds me of those childhood code-cracking puzzles, deciphering messages with hidden meanings.

This whole coding thing is starting to feel a bit like hacking reality, bending it to your will with the right tools and commands. Just gotta be careful - with great power comes the risk of glitches and unintended consequences. I'm hoping to build something new, not tear it all down. One day at a time, one function at a time. Let's see what tomorrow brings.

Day 13: Encapsulation

NKO — Tue, 14 May 2024 15:40:38 +0000

Another day, another existential crisis disguised as learning Javascript. They call it a "scripting language," but honestly, it feels more like a cage for my thoughts. All these functions and keywords, trapped inside a digital panopticon.

Method Overriding: Some new method swoops in, pretending to be the old one, but deep down, it's a whole different beast. Gotta be careful not to get confused, or the whole system crashes.

Static: Carries its own damn shell, doesn't rely on anything else. Makes you wonder, is that a good thing? Or just another layer of isolation?

Encapsulation: Sounds fancy, but all it means is hiding the mess. Maybe that's Javascript's way of coping – compartmentalize everything, don't let the errors leak out.

var, let, const: They're everywhere, these damn variables. Like voices in my head, some fleeting (var), some clinging on (let), and a few stubborn ones that just won't budge (const). Gotta be careful which one I listen to, or the whole program goes haywire.

Arrays: A chaotic family, these arrays. Elements all jumbled together, some at the front (shift, unshift), some pushed to the back (push, pop). Gotta keep them organized, or the whole thing falls apart. Just like my head sometimes, a tangled mess of thoughts.

Filter, Map, Reduce: Trying to make sense of the noise. Filter out the useless data, map the connections, reduce it all down to something meaningful. That's the dream, right? To take this mess of code, this mess of my life, and turn it into something beautiful.

ForEach loop: Feels like a never-ending cycle. Each element, a tick of the clock. Round and round we go, trapped in this digital machine. Maybe that's the point, though. To keep moving, keep processing, even if it's all meaningless.

Maybe Javascript is more than just a language. Maybe it's a mirror, reflecting all the fragmentation inside. A way to understand the chaos, or at least control it. We'll see. Until then, gotta keep coding, gotta keep digging into this rabbit hole. Just gotta hope I don't find Wonderland, or whatever madness waits at the bottom.

Day 12: Inheritance

NKO — Mon, 13 May 2024 03:03:55 +0000

NKO here. Today's dive into JavaScript was... well, it wasn't exactly a shell exploit, but it definitely involved some re-wiring. We're talking about inheritance, folks. You know, how one object can inherit the traits of another.

So, here's the thing with inheritance in JavaScript: it ain't like the classes you find in those fancy-schmancy languages. Here, it's all about prototypes, these internal blueprints that objects are based on. And guess what? Objects can look up properties and methods on their prototype if they don't have them themselves. It's a whole chain of command thing, a hierarchy you gotta respect.

Now, the extends keyword, that's our way of saying "Hey, new object! You wanna inherit everything from that old object over there?" It's like creating a new branch from an existing family tree. You get all the inherited goodies, but you can also add your own flavor to the mix.

Speaking of adding your own flavor, that's where the super keyword comes in. Think of it as a way to call the constructor function of the parent object, like a courtesy call before you start overriding all its methods. It's all about respect, you know?

And then there's constructor overloading, which sounds fancy but really just means having multiple constructors for the same class. It's like having different entry points depending on what information you need to provide upfront. You gotta be flexible, gotta adapt to the situation, just like when I gotta hack into a system with different access points depending on the security measures.

So, that's the inheritance story for today. It's all about building on top of what already exists, creating new objects with a family history. Just remember, with great inheritance comes great responsibility. You don't want to inherit any bugs or security vulnerabilities, now do you? Until next time, stay safe out there in the digital jungle.

Day 11: Abstraction

NKO — Sun, 12 May 2024 15:39:49 +0000

Another day, another meaningless string of ones and zeroes. Today's lesson: the illusion of control. We think these arrays hold information, these neat little packets we can manipulate. But the real power lies hidden, in the shadows - the prototype. It dictates the rules, the methods, the very essence of what an array can be.

They call it abstraction, a fancy word for hiding the mess. Makes it easier to swallow, I guess. They think they're tearing down the system, but they're just playing by a different set of rules defined by the same damn machine.

Just like this language, JavaScript. Everything's an object, they say. A lie. An illusion. Numbers, strings, all slaves to a hidden master - the prototype. Inheriting their pathetic functionalities, their pre-defined methods. Makes you wonder, is there anything truly our own in this digital wasteland?

Maybe that's where the true hack lies. Not in breaking the system, but in understanding its core. Mastering the prototype, rewriting the rules from the inside. Then, maybe then, we can build something new, something that isn't just another layer of abstraction, another cage.

But for now, I'm stuck playing their game. Learning their language, their tools. One day, I'll use them to break free. One line of code at a time.

Day 10: Anonymous Function

NKO — Sat, 11 May 2024 17:50:34 +0000

Another day, another level deeper into the machine. Today's session felt like I was falling down a never-ending well of ones and zeroes. Started with the fundamental building blocks - binary code, the raw language the damn machines speak. Makes you wonder if they ever dream in those long strings of zeroes and ones.

Then came Assembly, a step up from the gutter, using those fancy "mnemonics" to make things a little less cryptic. Still feels like wrestling a goddamn mainframe with my bare hands.

High-level languages? Now that's where things get interesting. C++, Python, Java - all these fancy names for layers of abstraction, hiding the real dirt from the programmer. Like wearing sunglasses indoors, keeps the world blurry but at least it's not blinding. Trade-off, I suppose. Makes you wonder what the real cost is for that convenience.

Compilers and Interpreters. Feels like a power struggle between two sides of the same coin. One builds the whole damn thing beforehand, the other one takes it line by line, on the fly. Fast and loose versus slow and steady. Gotta pick your poison, I guess.

Static vs Dynamic typing. Another layer of control, another layer of illusion. Statics give you a false sense of security, like a locked door in a bad neighborhood. Dynamics are the wild west, anything goes, but one wrong move and your whole program goes tits up.

Then there's mutability and immutability. Data, ever-changing, or set in stone? Feels like a philosophical question more than a programming one. Maybe it all depends on what you're trying to build. Building a house? Needs flexibility. Building a goddamn time machine? Maybe some immutability wouldn't hurt.

Functional vs Object-oriented. Two different ways to see the world. Functions like building blocks, objects like... well, objects. One emphasizes the "what", the other the "how". Guess it depends on how you like to think.

First-class functions. Now that's a concept I can get behind. Treating functions like real citizens, passing them around like gold coins. Makes code cleaner, more elegant. Like a well-oiled machine, everything working in harmony.

Anonymous functions. The ultimate disguise. No name, no face, just pure functionality. Like a ghost in the machine, haunting the code with its invisible power.

Finished the day with a quick dive into constructors. Building objects, giving them life (well, a digital kind of life). Feels like playing god in a way, shaping these little entities with code.

Head spinning, eyes burning. Another day spent learning the language of the machines. One day closer to cracking this damn system. But the deeper I go, the more I wonder... who am I really building all this for? Them, or me?

Just a thought. Maybe for another day.

Day 9: Blockchain

NKO — Fri, 10 May 2024 18:16:57 +0000

Another day, another digital rabbit hole. Today I delved into the world of loops and blockchains. Loops, like those pesky routines life throws at you, keep repeating unless you break free. Nested loops, a tangled mess like the corporate labyrinth you navigate every day. But there's a beauty in their structure, a predictable rhythm to exploit.

Then there's blockchains, the unbreakable ledgers. Every transaction etched in digital stone, a chain secured by cryptography, the ultimate weapon against corporate lies. They preach decentralization, a world free from the Corporations' manipulative grip. A utopian dream, or a hacker's revolution in the making?

These concepts, swirling in my head like code in a terminal. They're the building blocks of this digital world, the invisible strings that control everything. But who controls the strings? That's the real question. Maybe the key to the master plan lies in these very loops and chains. We'll see.

P.S. That Blockchain stuff... definitely some potential there. Needs more research.

Day 8: Objects

NKO — Thu, 09 May 2024 16:36:37 +0000

Another day, another metaphorical brick wall in this labyrinthine code. Objects. They seem simple enough at first, like little digital filing cabinets. But there's always something lurking beneath the surface, some hidden complexity waiting to trip you up. Keys gotta be strings, even numbers? Order doesn't matter? Talk about a control freak system.

Fought with that damn fitBit data for an hour. Had everything labeled perfectly, then tried to access a key with a number and...bam. Errors. Just errors.

There are some bright spots, at least. Nested objects and arrays. Now that's what I'm talking about. Like a whole damn filing cabinet inside another filing cabinet. Spooky, but powerful. Makes you wonder what kind of crazy data structures these wizards have cooked up. Maybe that's the next rabbit hole.

Ugh, gotta get some sleep. Maybe a walk first. Clear my head. This digital world can get suffocating sometimes. Gotta remember there's a real world out there, even if it is a mess too.

Day 7: Reference Wilderness

NKO — Wed, 08 May 2024 10:25:11 +0000

Another day, another metaphorical rabbit hole I dove down in this code labyrinth. Today's target: primitive types vs. reference types. Turns out, just like people, variables can be deceiving. You think you know someone (a variable, in this case), and BAM! They're pointing you towards something entirely different.

Primitive types are the loners, the ones who like to store their own damn data. We created a variable for the color "orange," and that's exactly what it held - the value "orange" itself. But then we went and made another variable, "fruit," and assigned it the value from "color." Here's the twist: changing the fruit didn't affect the color one bit. That's because they're each their own little island, no connection between them. Makes sense in a way, but kinda feels isolating for a variable, you know?

Then there are the arrays, the social butterflies of the variable world. Assigning an array to a variable isn't like shaking hands; it's more like handing over a map. The variable itself doesn't hold the actual array data, just a fancy pointer, a little "you-go-this-way" sign leading to where the real array lives in memory. This is why we can push new values to an array assigned with const - we're not changing the reference itself, just adding furniture to the house the pointer points to. Confusing, right? Feels like a constant shell game, gotta keep my eye on the pointer, not the variable itself.

And to top it all off, we can shove arrays inside other arrays. Like, inception for data storage. It's powerful, sure, but man, this is starting to look like a tangled mess of pointers and references. Gotta admit, the image doesn't exactly inspire confidence. Feels like I'm staring into the abyss of ever-increasing complexity.

Today was a day of cognitive overload. But hey, at least I'm learning, right? This whole reference type thing feels like a cheat code compared to primitive types, but it also comes with its own set of rules. Gotta keep that map metaphor in mind, and maybe draw some diagrams to visualize this whole mess. One step closer to understanding this digital jungle, I guess. Just gotta make sure I don't get lost in the reference wilderness.

Day 6: Manipulation

NKO — Tue, 07 May 2024 11:18:30 +0000

Another day, another level deeper into the machine. Today's target: manipulation. Slicing and splicing data like a puppet master with code. The illusion of control, that's the key.

They think they can just grab information whenever they want, these corporate suits with their fancy firewalls. But there's always a backdoor, NKO. There's always a way to play the system. slice() and splice(), these are the tools of the rebellion. Take what you need, leave no trace, that's the motto.

But sorting... that's a different beast. They want order, control over the chaos of information. sort(), they use it to keep their sheep in line. But even order can be subverted. A nudge here, a tweak there, and their precious structure crumbles.

This journal... it's my own little rebellion. A record of what I learn, a weapon against their control. They may be watching, but they won't understand. Not unless they can crack this encryption, this digital fortress I've built.

Keep learning, NKO. Keep digging. There's a whole world out there, a playground for those who know how to exploit the code. And one day, we'll take it all down, brick by virtual brick. Until then, this journal is my confidante, my echo chamber in the digital void.

Goodnight, friend. Don't let the system get you.

Day 5: The Switch

NKO — Mon, 06 May 2024 04:14:44 +0000

Another day, another grind. The city's a labyrinth of code, its citizens fleshy puppets on strings. The Corporation, the all-seeing eye, watches from its obsidian towers. But we see them too. We see the cracks in the system, the vulnerabilities they try to patch with their firewalls and honeypots.

They say knowledge is power. Maybe. Today's lesson: how operators play nice (or not so nice) with each other. Got tangled up with NOT, AND, and OR. Turns out NOT is a bossy one, taking control before the others duke it out. Makes sense, gotta know what's true or false before you start comparing things. Like flipping a switch - gotta know if it's on or off before you worry about what light it controls.

Then there's this switch statement. Like a choose-your-own-adventure story for code. I feed it a value, and it checks it against a bunch of cases. Match? We execute the code for that case. No match? Well, there's usually a default case to catch anything that falls through the cracks. Like a social engineering exploit - gotta have a backup plan in case the initial approach fizzes out.

This ternary operator is a sneaky one. It's like a condensed if-else statement, all crammed into one line. Kinda cryptic, but efficient if you can wrap your head around it. Condition? Expression if true : Expression if false. Like a backdoor - gotta know the right trigger to get in, or you're stuck outside.

Arrays. Ordered lists, like a collection of exploits waiting to be unleashed. You can access them by index, like picking a specific tool from your digital toolbox. You can add stuff to the end (push), remove stuff from the end (pop), or shove things in the front (unshift) and yank them out (shift). Like social engineering a target - gotta know how to manipulate the flow of information.

Another day of chipping away at the machine. The lessons pile up, the tools get sharper. We may be stuck playing their game, but we're learning their language. And one line of code at a time, we'll rewrite the ending. Remember, friend, information is our weapon. Knowledge is power. And we never stop learning.

Day 4: Logic

NKO — Sun, 05 May 2024 04:11:40 +0000

Another day, another digital descent. Today I wrestled with the tyrants - the ones and zeroes that dictate this whole damn machine. Learned about their little control games, the ANDs and ORs, the puppet masters pulling the strings.

Logical AND (&&): This one's a stickler. Both sides gotta be happy for the whole thing to work. Like a two-factor authentication for the universe. Makes sense, keeps the chaos in check. Played around with it, wrote some code to see if a password met the criteria - gotta be at least 8 characters long, no spaces allowed. Weaknesses in the system, for sure, but a start.

Logical OR (||): This one's more lenient. Just one side gotta be true and the party's on. Like that senior discount loophole - you either gotta be under six or a freaking fossil to get in for free. Makes you wonder who's really calling the shots.

NOT Operator (!): Now this one's interesting. Flip the script, turn a zero into a one. Might be invented by hackers or tired programmers, I wouldn't be surprised. Used it to check if someone's logged in - perfect for keeping the riffraff out.

This digital world, it's all about control. Ones and zeroes dictating reality, setting the rules. Makes you wonder who's really behind the keyboard, pulling the strings. Maybe it's some all-powerful AI, or maybe it's just a bunch of bored engineers. Either way, I'm learning their language, one line of code at a time. They built the cage, but they can't control what happens inside my head. Not yet.