Doomcoding: Defensive Coding and Design Against Indians and Outsourcers - Design, tooling and choices we make can make us vulnerable

  • Want to keep track of this thread?
    Accounts can bookmark posts, watch threads for updates, and jump back to where you stopped reading.
    Create account

Catboy Ranch

Stop the Indian horde, apply at JOBS.NOW!
kiwifarms.net
Joined
Aug 21, 2022
Starting a thread to talk about individual design choices to make our work far more resistant to Indian takeovers.

I have some personal overarching rules I go by that I'll share (I have more for specific use cases, loads), but just from heavy interactions with pajeets:

  • keep Java as a third Class citizen, and if you can get rid of it or cripple it, do it. Java is a pajeet language, followed by C#

  • in SQL, triggers are fun. more fun than sprocs to debug. (but they're great for final data validation, cross-calculations, triggering downstream sprocs, etc). Indians get REALLY confused when you add WITH(..)AS scratch tables and CURSOR over them inside the trigger. Oldschool SQL development design books would tell you to make all your write and transaction entry points as sprocs, so as Indians have conquered much of the tech landscape, this is the pattern that they are used to seeing. Fuck that shit, I use journalizing tables for my writes and triggers take over the work of orchestrating the downstream effects. When they rollback, I leave a dead letter table for the dead soldiers, including very great detail about why the XACT exploded. Not one time have I released a datastore to some offshore Indian they didn't come running back for help because the triggers sent them for a loop. (I can't see why. The loop is self-describing.)
still stuck with MSSQL? Take the time to learn about Service Broker. If this shitty CorpApp is still stuck on MS database technology, might as well go to the very tightest coupling between their crap database engine and the code. This thing works by calling a stored procedure that just hangs; so by default you can only use this thing by ensuring multithreaded completeness. When someone deposits a message in a SB queue, your stored proc call that is hanging will then release, and give you the record. You're supposed to loop and hang yourself again. There's better ways to do this kind of instant handoff of data, but hey... this one wasn't popular when Microsoft killed DTS, so that means your Indians don't know a thing about it, because they never see this pattern. It also helps that the Technet documentation for it is ass.

  • whenever you are about to reach for a tool library for that "One Small Thing" it has, this is the crucial moment: would it make more sense if I wrote this natively myself?


On this last bullet point, let me talk about something ancient and basic you learned long ago; structured data.


This is remarkably simple at first. (The complexity comes once you introduce multicore/multiuser later on, but it's not that big of a problem.)

In the initial design phase, you start out like this (pseudocode):


Code:
// pseudo
struct FileRecord {
   startByte byte[1]
   versionCode byte[3]
      ... any more announcement fields...
   startRecord *StructuredDataRecord
   position long,
   .... any more sentinel bytes before start of the data ...
Code:
   sentinelBytes byte[6]
   UnstructuredDataSet byte[...]
Code:
   capBytes byte[10]
}


The picture you're about to create looks like this:
1757300889560.webp

Instead of opening a file and reading a blast of bytes as a string, which you and every Indian knows how to do, you're going to be organized. Neat. Tidy. Contractual. So contractual, in fact, that you're always going to read and write bytes in a specific way, using a specific set of rules. YOUR set of rules. You write the contract. You know everything there is to know about this contract, because you're creating every aspect about it in code. This makes you the default World's Leading Expert for this storage format: your storage format. That you invented, not the Indian.


The Indian will now have to have expert methodical read-by-hand, code reviewing skills. Not an AI tool, you need to know how to do this by hand. Because one small change will destroy the integrity of the format. And Claude is not that great about preserving spec integrity unless it's been trained well in advance, which the Indian is never going to do. The Indian would still have to *know* the format well, and he doesn't want to do that work.

By the way, you also get to write the tooling for the format for integrity and data repair, which are now the world's leading authorities on validating the integrity of the dataset.

You might say: Didn't structured datasets go out the window a long time ago? Well, not if you're a protobuf user. And most Indians at this level just use code generators for protobuf, they have no fucking clue what any of the proxy client/server shit is doing. And the number of these guys that can crack open WireShark and read a protobuf stream is absolutely fucking zero.

But beyond using binary structures for the maximal optimum data transfer performance, you likely don't need shit like SQLite/MySQL or some shit Redis instance (just mount the fucking dataset in a RAM volume nbd, stop crying). Instead of reading struct-length by struct-length for your records, you likely want to store data of any size in a field, yeah?. That's easy enough to do if you move all your fixed-sized bytes to the top of the record, and then use sentinel bytes to highlight the any-sized data elements, and record the starting offsets as fields in your fixed-sized structure. Make a reader/writer that can read the data and write in both forward and reverse directions, and holy shit you now have your own database. You can continue stacking only the pieces you need on top of this, and still stay super fucking fast. Oh, while you're doing this, you'll now learn how to read hex dumps and you can get into the world of ROM dumping vintage Gameboy carts in your free time.

If all this sounds too crazy to you, then fuck off and go play with your NoSQL MongofuckDB whatever it is that the Indians are learning on PluralSight right now.

If you're still interested: guess what? Not one fucking human being in India is going to be able to handle this thing. You have now powerleveled yourself closer to the status of Unfireable.
 
IPC Is Great For Microservice Pieces On The Same Container... Terrible For Pajeets

IPC is an ancient term meaning Inter-Process Communication. Two computer programs talking to each other, like a telephone call. nbd

Seems to confuse the ever-loving fuck out of people, junior devs, Indians.



The latest-greatest pattern that's common is to go to protobuf for this. I assure you, this is the most basic-bitch technology, and dead-simple. You write a schema in emacs, vim, notepad.exe, run a generator, out comes a server and a client for it. You stick the generated proxy code in their respective libraries and write wrappers above them to regulate when/how the dialing/execution happens. That's it.

It's re-inventing CORBA from the 1990s.

If you're in the Go language, and only the Go language, you can skip protobuf and use GOB instead (and you don't need to gen out proxies!)


So here's what you do:
  • You're building something, anything, that starts up and runs forever until shutdown, kube host kills it, etc.
  • Inside that something, you spot a place where... it's not today, but soon... we're going to need to break this service up into two services of their own, but they share an incredible amount of state, or storage area, and it's just not possible to physically separate these things hardware-wise. But software-wise it would be so much cleaner if we did.
  • If that's the case, let's go ahead and do that now and break them up.

You make two binaries instead of one for your service and then you use protobuf as the connection bridge between the two running binaries, usually one of them is acting as each other's client and server (so you can, later on, make this a mesh network on IPv6... but let's stay simple for now).

Once you separate GetCreditCardDetails() from SendCreditCardPayment() into their own process boundaries (which may later-on be separated to different hardware, too) and that connection is now over a real or virtual socket, that puts you in the commander's seat for defining the shape and security of the connection bridge, the interaction points, essentially (again) it's a contract. But this isn't JSONRPC and REST or SOAPXML which the Indians have all been studying. We're back to a YOU-define-it binary structure, but with wizards.

Congrats again, you just kicked out more than 98% of all the Indians.
 
Simple: just write in C. The sandniggers can't program without the compiler handholding them to stop them from making memory mistakes, and they will blow their brains out when they try to understand your macros

It's AI proof too, for the same reasons. Jeets and AI are basically the same species
 
Compression Is Your Friend In Logging Cases

A common practice corpos want you to do and it's taught as "Good Design" is to throw everything and the kitchen sink at SaaS logging services (DataDog, New Relic), etc. Including throwing the entire original data transaction that started an orchestration, along with the response.

You can save the company money, and confuse the Indians, by changing that somewhat.

Get a wrapper for liblzma and compact that blob document shit, then Base64 encode it, before passing that crap up to the SaaS host. The only Engilsh they should be seeing are the short fields of what/where the crash was, the error message, and the bottom of the stack. Encrypt and base64 the bigger data trace. Don't use Microsoft/python standard libs for this. Use liblzma. That way a Indian running Microsoft Pajeet11 with VSC has no fucking idea what's going on there.

For the data trace in a production event scenario, you can write a quick script in emacs, vim or whatever (and use AI to help here) and make a text editor macro to reverse the paste when you actually want to inspect this data. To make it less obvious, do what your corpo security consultant recommended but you ignored in the mando training and scan-and-delete PII and other sensitive data so that on an audit, you look like the most complying motherfucker in that sweatshop.

And you're saving the company money, too.

Don't ever give your custom tools to the Indians. Don't even let them see them over Zoom.

If it's in an emacs macro buried under ~/.emacs.d/... they ain't recovering that shit anyway. (I do show the Indians my emacs buffers since I type 125WPM and blast through chords faster than the screenshare can send the paints to keep everyone up.)

When it's time to report on the post-crash analysis for your corpo bosses, stick that in a nice-looking Jupiter notebook looking thing so they never see your local tooling. I do it every time.
 
Last one for now, to give my fingers a rest...

Custom Logging That You Control, All The Time

Much like C developers and their incessant passion to write malloc() from scratch because the temptation to follow a hardware designer's optimizations for your googledyflap edge case is impossible to resist, you should develop this same habit when it comes to logger units. I prefer to write them all from scratch. There is no reason whatsoever to use someone's kit from GitHub.

My current basic regime;

  • Multi-sink, as all the popular logging toolkits do, but...
  • Analyze what is being asked to be logged. This is where most of your decision code comes into play (like that custom compression and PII removal trick I told you about, earlier)
  • Make a router in the logger and make it smart.
    • Does it really need to go to SaaS and run up money? Maybe you can send a redacted version of the event to SaaS and push the voluminous detail to storage (hey, that's where you can write your own file format too :story: )
    • And while we're here, include all the systemd behavior you expect to see; like archival/retrieval and rotation.
  • Think about adding a directive in your CI/CD to change the routing plan so that you can go back to firehose in intense debugging situations, if you want... but don't make it easy as a live-feature setting. Force a re-deployment.

So, ERROR and WARN go up to SaaS in all their glory, and to systemd like usual. Business data is whitespace compacted, cleared of PII, encrypted, Base64 prior to upload.

INFO gets a thorough scrubbing just like before. I tend to put the wake up state of long-running components, clocking events, and connection events here.

DEBUG in normal production mode gets an intensive scrubbing operation before upload, and I'm not going to include the data transactions involved in the processing by default. It's going to a storage volume. I am going to force you to redeploy and add the compile directive to get that feature to get the data back into SaaS, and I'm going to shoot out lots of ERROR on startup to make sure every SaaS alarm gets triggered, too, so if I don't have ownership over the CI/CD... then the true owner in charge of deploy will be scared to leave that option turned on and will redeploy it away when the crisis is over.


Indians like to believe the mystic that they can learn everything just from the logging. But everyone in tech has seen an Indian fixate on the dump message and not look at preceding events. This happens a lot. Well, if we're being frugal and not firehosing a live delta of the fucking database on every transaction, this changes the log reading skill from mindless reading to UNDERSTANDING what we're reading.

And on a Zoom call, the tracing you do will get recorded by the Indians on the other end and they will want to copy it on their own. Just give them documentation instead. The best solution for this... and it's the one your leadership really wants, is a Root Cause Analysis document (it's a 1 page sheet) that has the timeline of the crisis, a summary of the root cause, a summary of the fix, lessons learned, missed opportunities and I love to use the word: things that were misidentified.
"A Cognizant Team Member misidentified the server involved in the event, believing on first observation that it was PORTLAND node EC3.... however in the New Relic trace of APPSUX, at 0849 was the following:...."
 
The best solution for this... and it's the one your leadership really wants, is a Root Cause Analysis document (it's a 1 page sheet) that has the timeline of the crisis, a summary of the root cause, a summary of the fix, lessons learned, missed opportunities and I love to use the word: things that were misidentified.
Channeling some BOFH here, and I love every bit of it.

I have to second writing useful tools in C/C++ natively. I ported a Javascript utility at an old job that took 3 days to finish (don't ask) into C++ that did the same job in about an hour and was more flexible besides. All the devs at the company were JS die-hards (all White, to their credit), and every time I tried to excitedly show off the innards of the new tool in C++, their eyes just glazed over and they were satisfied to see the results and leave the code to the old greybeard (which was the only reason I offered to show it off). Looks team-oriented, eager to share new technology improvements, produces results, and good fucking luck to the jeet team that tries to untangle a multithreaded program flinging multiple-gigabyte TSL::sparse_maps around.
 
Channeling some BOFH here, and I love every bit of it.

I have to second writing useful tools in C/C++ natively. I ported a Javascript utility at an old job that took 3 days to finish (don't ask) into C++ that did the same job in about an hour and was more flexible besides. All the devs at the company were JS die-hards (all White, to their credit), and every time I tried to excitedly show off the innards of the new tool in C++, their eyes just glazed over and they were satisfied to see the results and leave the code to the old greybeard (which was the only reason I offered to show it off). Looks team-oriented, eager to share new technology improvements, produces results, and good fucking luck to the jeet team that tries to untangle a multithreaded program flinging multiple-gigabyte TSL::sparse_maps around.
I was at Microsoft Build in person when Miguel de Icaza was showing off Google Glass, one of many of Google's e-waste landfill launches, and he was going gaga over the then-new async..await pattern, which I wanna say back then about 1/5 of the Moscone Center was jeet. I had been writing threadpool managers by hand for years before this and already learned it in C# 5.0 before the conference. Straight away the chaos involved with every GUI toolkit's strange behavior ( under, sigh, .BeginInvoke() , where you think you have independent context, but realistically you'll run into shit where that's not true) was making me unwell before I even got there. Then Miguel goes goo-goo and tells the audience to just spray that shit everywhere. Everywhere you travel in your code. It's great!

Years and years and years of mysterious jeetified antipatterns followed, and I watched plenty of people suffer for half a decade since multi is not a first class citizen in any .NET lang, helpless to debug it. You didn't learn pointers because "you didn't need to learn that in C#", but pointers are the reason why data disappeared on a context switch!

Since Java got the same thing added to it, orphaned unreleased handles have turned into the number one cause of memory leaks in Java, with a planet of jeets with poor knowledge of the JVM seriously unable to hunt them down. So they just tell you it's "good health" to restart your app every so often.

In fact, this is now a feature in Android OS itself, so all the Java leaking apps you have no longer have reserved pages on OS restart. Android will now just reboot your phone to clear it once it's figured out when you plug your charger and go to bed.
 
Indians like to believe the mystic that they can learn everything just from the logging. But everyone in tech has seen an Indian fixate on the dump message and not look at preceding events. This happens a lot.
Another good way to keep jeets out is to insist that you write your own logging or, whatever you do, don't use third party logging tools. Indians doing QA and also devops (click ops) where they are the ones who push the "build" button are also suicide, all for the same reason - they slowly realize they can just claim nothing is working (lie). Don't ever let your white team get lazy to the point where some dipshit higher up thinks, "this is a small enough job we could hire a third worlder for".

You have to keep them out of QA because they will just fail your build and use it against you. Same with devops, they will just claim your new build fucked everything up. A lot of devops jeets just kick back and think they can claim all the builds failed, also devops jeets realize they can just randomly turn shit off in the cloud cpanel, drive up a storm of hate towards you, then turn it right back on. A lot of smaller hosts don't log every single turn off / turn on and if they do, by definition you've made it so the jeet is the only one who can have access to it. QA is the same, they are just gonna repeatedly fail your build/merge/whatever.

Third party logging tools are the same - jeets love being in charge of logging, it's a bullshit job where they can basically kick back and use the software to just claim it's your fault by mis-explaining the logs.

I worked at a small company years ago that tried to take the jeet pill over the course of 2 weeks and tried to go the "look it makes sense that nobody wants to handle builds so let's just hire a jeet for it". Suddenly overnight, builds now take a fucking month to get pushed and our new jeet QA department fails 100% of pull requests or branches etc. Huge huge step backwards.

Worked at a different company still where they had "three layers of QA/UAT" that were all jeets for the same reason, "hurr durr let's hire a third worlder for a bullshit job like that", it started with 1 Indian hire, then that became 3, then 5, then 12, all they did was alternate 2-3 months of failing all the pull requests and then accepting all of them, clients got pissed, then we just went back to the old way of the programmer working directly with the client (gasp!), problem went away overnight.

No matter how small or irrelevant or bullshit the job, jeets will fuck it up and try to turn it into a huge department and then when anyone tries to figure it out, they bail and claim their internet is not working for a week so they dodge a review, all that happens is at end of year you are months behind and have to pull weekends to get back on track.
 
So they just tell you it's "good health" to restart your app every so often.
God that shit pisses me off so fucking much. Containers and VMs are immensely useful for all sorts of workloads and deployments, but an unfortunate side effect of containers being so "disposable" is that literally nobody I've talked to professionally for the past ten fucking years has been even remotely interested in "online debugging" -- i.e. dicking around inside a failing/broken application as it's failing to figure out why the fuck it's broken. Nine times out of ten the actual problem (and likely the root cause not far behind it) is glaringly obvious if you're sitting at a shell on the broken instance. It's almost always easier to detect the real problem that way just by exploring and poking at a half-dead system than trudging through those goddamn logs (though your logging approach is also quite lovely and I'm going to seriously push hard for it on the next project at work).

Everybody just wants to "tear it down and spin up a fresh container" instead. You lose so much potentially useful "forensic" data throwing containers away like that when they fail. It's depressing.

Ah well. Progress marches on, I suppose.

ETA: Also, if your program can't survive an uptime of a year or more, with restarts only for hardware failures or software updates, it's a piece of shit and needs to be rewritten until it can.
 
but an unfortunate side effect of containers being so "disposable" is that literally nobody I've talked to professionally for the past ten fucking years has been even remotely interested in "online debugging"
Reason why is because it will create accountability ie show who fucked something up, namely a jeet. Containers are gay for 99% of their application, jeets love containers because it makes it harder to prove they fucked it up.

Another big red flag you should 100% ban if you can is purposefully not putting an error code in your exception, ie doing the jeet tier "Just try again later saar :-)" message that you show to fucking end users. Not logging an exception to at least a database somewhere and leaving the customer with that should be fireable offense the very first time.

When jeets started getting involved in programming, error codes disappeared quick, and now white people can't even have error codes because they'd just get blamed for all the jeet shit.
 
Knee-jerk thoughts:
1. Use the GPL. You immediately gatekeep anyone who wants to monetize.

2. I feel like functional programming is more AI proof. Lisp having macros may make it the best choice, but the ML dialects should also work.

3. Attach to some kind of hardware in as low-level as possible, or touch metal. Making up some voodoo in Vulkan is probably good enough, or throw in some assembly code. Ideally make your code impossible to run in Docker or a hypervisor.

4. Avoid weakly typed languages like Javascript

5. Avoid anything trendy on sites like Hacker News (e.g. Rust)
 
keep Java as a third Class citizen, and if you can get rid of it or cripple it, do it. Java is a pajeet language, followed by C#
I feel so bad for C and Java people. My father became a C and Java pro when they were hot new things.
Of course, being an old school IT guy, he knows electronics themselves and many languages and has no problem moving and jumping from one task and language to another.
But it's still a shame. You make something relatively unsophisticated to help spread the digital age and pajeets will alwys highjack it.
It's like some company creates a kit which anyone can buy to assemble a car at home. It's plastic shell, it's not very powerful, but it's a basic car to increase your mobility. And then jeets come along, assemble them at their poojeet backyard "factories", frankestein things the original chassis was never supposed to take, and then resell the cars to other people as an original product. TRUST ME SAAR THIS IS LAMBORGUNT 9000 SAAR ALL ORIGINAL PRODUCT SAAR I SELL FOR 10 RUPPIES PLEASE SAAR .
 
Containers and VMs are immensely useful for all sorts of workloads and deployments, but an unfortunate side effect of containers being so "disposable" is that literally nobody I've talked to professionally for the past ten fucking years has been even remotely interested in "online debugging" -- i.e. dicking around inside a failing/broken application as it's failing to figure out why the fuck it's broken.
At my job before this, NO ONE could do online debugging, or breakpoints.
"Just spin off a container and add print/log statements."
"No, I want to set a red dot and run my code up to the red dot and see what's inside."
"Just spin off a container and add as many print/log statements as you want."

Debugging consisted of "spinning off a container" and seeing if it built without errors. If it did and the users didn't complain, all was well. If they complained, a programmer would edit the code and spin off another container. Programmers didn't check if the problem was fixed in the code (they didn't know how, they just guessed where in the code the problem was likely to be and changed something there) and they didn't even check if it was fixed in the user interface, because it was the testers' job.
(That was pre-ChatGPT.)

Eventually the boss proposed "knowledge sharing" seminars where "all employees" (me) would share their valuable expertise with the rest of the team. I gave three, on breakpoints, enums (do not use raw numbers throughout your code!!!) and binary sets, and preventing N+1. They didn't like a wamen telling them what to do, and that was it.

They couldn't even do containers properly, they fucked up layering by copying over the custom code first, with the result that all libraries were being downloaded over and over at every build, taking up like 20-40 minutes per build, to the point the repo started throttling our IPs. I said, this is fucked up, it can't possibly work like this, even terminally online "don't you have broadband" westoids wouldn't tolerate this garbage. They said, "we can spin off a local cache server for downloads" (they did not). I was refusing to learn anything about containers (because I hate the utter pajeetery of them, and because I thought that if I did, they'd break something about my online debugging setup and leave me to pick up the pieces) but I did, moved a line, added a line, and the containers started building in three seconds.

Their database guy refused to add the timezones table to MySQL, he didn't know what it was.
"Just run this line of code."
"I won't, it could be a virus."
"Here's the documentation."
"I don't trust it, you can write anything on the internet!"
(he couldn't read English)

(They were whites. The frontend was outsourced jeets. The jeets refused to give any information about what they thought was broken directly to the backend, and we had to go through the CTO of our company to the jeet manager; the line jeets didn't last longer than two weeks each, although we did not "fire" them, it simply was one jeet today and a different jeet tomorrow.) The backend did fun shit like, in the list of orders from a specific company, they pulled the company's info and financials with joins and n+1 requests for each row (same company! nested serializers are so convenient amirite), and then the frontend jeets would pull the company data from a random element of the order list (well technically always the "first" element, but dependent on frontend sorting). The jeets refused to change the frontend (we coudn't talk to them online). I did "research" by removing fields one by one from the backend response and seeing if the site still worked. Everything that was required, I pulled once and copied into every row. It worked, the page took 400 ms to load, down from 10 seconds.

Also, easily like 90 minutes each day had to be spent fucking around in the task manager, and 40 minutes in the morning on that horrid Agile Anonymous meeting, whatsitcalled.
 
All my strategies revolve around eliminating "True Indian Competency", meaning the Indian bullshitter is left to sit up for days writing AI prompts and will be helpless if he doesn't actually learn and understand anything.

Some more data hygiene tips for communication:


Store Currency as a 64-bit Integer

It surprises me over and over with how India's ass number-writing system for their worthless currency never really prompts them to think of a universal way to store currency values. And then I see, over and over, them writing code to store the value as a float64, followed by (and sometimes not at all) a shitton of casting in the code to deal with the imprecise nature of FPVs.

Takes about an hour or less to write a generic datatype to deal with this and store, convert to string, convert string to native, an Int64 back to a number you can work with and not lose precision but also avoid all the noise of casting. You could also add all the math functions for your needs, like taking floor(), banker's rounding, generic methods to interact with raw numeric datatypes etc. on to this too. You can then write the same user-defined functions in the database platform itself (if you're storing there) so the handling can be done in more than one place.

Once the company's fin transactions are flowing through your own currency conversion and notation expression kit, another small step away from falling into the black hole as being seen by your leadership as disposable biomass.


Who needs HTTP/2, REST when you can be so much "better"

It's still very surprising to me how QUIC is all the rage with people directly interacting with Google's shit, but outside of that... the vast majority of people have barely even moved up to HTTP/2. You should move to HTTP/3 right now (QUIC) and get ahead. Yep there are libraries. And more libraries. And more libraries. It's been around long enough that it's beyond time to move to it in production.

Big boss will of course freak and say wtf/no... but that's where you continue to offer traditional HTTP/2 to the front door router, but any internal service to service bouncing should move up to /3. And to sell this with your colleagues, you show them how HTTP/1.1 is an insecure nightmare due to request munging it can never hope to fix, and how /2 was an improvement but still has its problems, and /3 is the better fix.

Already loads of blog posts telling you to go up to QUIC. Not one pajeet at an India remote is doing any of this shit.


Give it a REST

Inside the house it's kinda stupid/lazy these days to continue to serialize/deserialize JSON inside the same shop between service boundaries, You do this for your cussssstomer outside the shop, but internally you should have given up doing this by now.

Go to gRPC, which is protobuf. And consider that GraphQL is so much better at traversing tenuous data relationships than define-from-scratch REST endpoints. Going to GraphQL nukes more Indians.

Further: inside the same datacenter/region, consider dropping your connections down to UDP from TCP, and hand-managing your sockets to enforce your own keep-alive regime.

Raw TCP/UDP code handling seems to strike out yet another big population of Indians. These changes are also what you need to learn anyway in order to write code that can move TERABYTES of data in a request and live-streaming responses, instead of pithy little 1MB data returns. So learn this shit and up your power level.
 
-Have the code on startup look for a file called niggers.txt
-niggers.txt is outside of the git folder, on the root of the drive somewhere etc
-Have niggers.txt contain string data that is some sort of conversion operation off their Windows or Linux username so it will be different every time
-ie convert JohnDoe to base64 or rot13 it or whatever you want to do here
-Hook the data access layer or something critical into the check so that if the file doesn't pass, it removes every odd or even row from the return, or come up with something like that, you could also do a bitwise operation on the current day of the month so that it's inconsistently consistent
-This will cause them to start asking retarded questions on their own and make it seem like they are incompetent
-When onboarding white devs, let them struggle with it for a few hours and ask a bunch of questions to hide the check in the code as one of your questions, step them through making niggers.txt but have it be as part of 10 things you do, so that nobody mentally remembers niggers.txt so that white devs don't accidentally try to help jeets, if they know how to make niggers.txt then they will let the jeets in

Jeets get fucked

Stay the fucking fuck out my white people code
 
Back
Top Bottom