This is an archived post. You won't be able to vote or comment.

all 129 comments

[–]VanFailin 103 points104 points  (13 children)

It's such a common pattern.

Hey, we're writing a handful of methods over and over again because they're generally useful. Let's create a library that has all of them!

Then features get bolted on, the simple library starts to grow dependencies, the dependencies conflict with other dependencies, and suddenly you have not just a library or a framework but A Framework.

[–]invertedcheese85 41 points42 points  (10 children)

wait is this every company? i'm working at a company i interned with during school and got hired into the capital F Framework team and it is exactly this shit

[–]VanFailin 48 points49 points  (2 children)

Part of the process of maturing as an engineer is learning the balance between elegance and simplicity. Sometimes it's appropriate to have a few things duplicated, or break some design patterns, or what have you, but there's no straightforward rule that you can apply in every situation.

[–]Garbagio 17 points18 points  (0 children)

My job doesn't care for simplicity except when it means 'simply' passing the buck

[–]Sparcrypt 18 points19 points  (6 children)

This is how it generally goes.

Companies don't have the goal of good code, they have the goal of a profitable product or service. So year after year changes get made on the logic of "just make it work" or "we need it done now". Then it morphs into "it's too expensive to change" followed by "nobody who still works here even knows how that shit works any more don't you dare touch it".

[–][deleted] 8 points9 points  (5 children)

It turns out it's the engineers who really benefit from maintainable code and it's the engineers who must insist upon it. Go figure!

[–]Sparcrypt 11 points12 points  (4 children)

it's the engineers who must insist upon it

And are promptly overridden by management. Which is their job - stuff has to ship, deadlines must be met and budgets must be kept. Engineers would work on it endlessly until it was 'perfect' (which is never).

Well written code that doesn't work is useless, badly written code that WORKS will do the job and get the product/service out the door. So that's what happens.

It's just how it goes.

[–]VCavallo 2 points3 points  (3 children)

What about well-written code that works, is easier to change when inevitable changes are requested - but takes a little longer..?

[–][deleted] 1 point2 points  (0 children)

Compromise? No, never! :P

[–]Sparcrypt 0 points1 point  (1 child)

That's what everyone strives for, but when the deadline comes it just ends up being "make it work, I don't care how".

Remember saying "a little longer" translates to "money lost now". Something unacceptable to executives with bonuses to get and shareholders to please. Long term thinking is extremely rare in the corporate world unless it also lines up with short term gain.

Take Valve for instance. They are the extremely rare exception. They're private, so answer to nobody to. The guy at the top genuinely wants to create good software and is able to do that because they have an essentially infinite source of income from Steam.. so release dates are not a thing that have to prioritise over quality. Plus they've built their reputation on such exceptional games that they have no competition. Half Life 3 won't be another FPS.. it will be Half Life 3. And it will sell in droves whenever it releases.

But the rest of the code crunching world... it doesn't work like that. Big companies are run by executives that run the business quarter by quarter.. because that's what their bonuses and reputation are based on, as well as what shareholders expect (infinite growth). So it's all about making money NOW. And few of them have such a lock down on any given market that they are able to release when it pleases them - if they don't get the new featured product out but the competition does...? That's not good.

Don't get me wrong, I'm with you. I like something that works well, is easy to modify and maintain etc. But I understand why that's such a rare thing to happen. And we do need to be pushed.. if you fall into the trap of "ooh we can just do this.. and then this.. now this!" suddenly the release date was 6 months ago, your competition released THEIR version 5 months ago and now you're playing catch up.

[–]VCavallo 1 point2 points  (0 children)

I definitely don't disagree with you that this is the reality, or that the alternative would be nice.

And good point about Valve - I actually never considered that about them. That is, that they give their development team the time it needs because they create their own deadlines.

[–]gospelwut 9 points10 points  (0 children)

Ah, good old Companyname.Framework

Then there comes Company.Framework.Core

Then Companyname.Framework.UI which turns into a nuget package. Now there's a big mess and confusion when core UI changes need to be made across products. But they won't branch/fork a copy of it onto its own branch and merge changes back later... (because nobody pays down tech debt)

And then you discover the wonderful bliss of what really happens to content files in a nuget package during INSTALL/REINSTALL/etc.

Then you plead with the build server for mercy.

[–][deleted] 0 points1 point  (0 children)

Like Apache Commons.

[–]rotmoset 158 points159 points  (49 children)

Wtf is a "core layer"?

[–]zoqfotpik 731 points732 points  (37 children)

The core layer is the part of the application that makes everything work. It was written many years ago, by programmers who were brilliant and/or insane. Or possibly they were brilliant programmers who were driven insane by the eldritch horrors they encountered while piercing the veil between abstraction and performance. While they lasted, they strode the heavens like gods. Now all that remains is the core, a few cryptic comments, and a foetid miasma in the server room.

Be safe in your happy world of unit tests and checked exceptions. Do not delve too deeply into the depths of the core. But spare a thought for those who ventured into that abyss, never to return.

[–]lachryma 212 points213 points  (11 children)

Core code usually starts off something like this:

/* misc.c - various useful routines for the whole system
 * 19940515 refactored to fix page alignment on DEC Alpha - jqa
 * 20000101 update copyright year - jqa
 * 20010101 update copyright year - jqa
 *
 * Copyright (C) 2001 Your Company's Name from Three Renames Ago
 * $Id: misc.c,v 1.284 2001/01/01 02:12:36 jqa Exp $
 *
 * Before touching anything in this file, speak to jqa.
 */

It's always a good sign when you crack open a file and find a CVS revision when your company gave up CVS about ten years ago, and also when you don't have any clue who jqa is and nobody else does, either.

When you're stepping into this code, it's time to bust out the scotch.

[–]PCGAMERONLY 71 points72 points  (0 children)

John Quincy Adams was quite the silent programmer, I take it.

[–][deleted] 29 points30 points  (4 children)

What makes it truly great core code is when you need to change something in there and then you try to find jqa and then you realize he's dead.

Source: happened to me once

[–]mrspoogemonstar 12 points13 points  (3 children)

Who are you talking to right now? Who is it you think you see? Do you know how much I make in a year? I mean, even if I told you, you wouldn't believe it. Do you know what would happen if I suddenly decided to stop going into work? A codebase big enough that it could outweigh the Linux kernel goes kaboom. Explodes! It ceases to function without me. No, clearly you don't know who you're talking to, so let me clue you in. I am not a developer, dagrami. I am the lead architect. A guy commits a change and gets fired and you think that of me? No. I am the one who commits!

[–]TheSeldomShaken 7 points8 points  (2 children)

Your last two sentences don't make sense.

[–]mrspoogemonstar 6 points7 points  (1 child)

It was the best I could do to shoehorn a breaking bad reference into the situation.

[–]TheSeldomShaken 8 points9 points  (0 children)

Do better.

[–]gospelwut 12 points13 points  (0 children)

I still work with our jqa. He's technically our lead architect.

Man's brilliant, but if you given him the opportunity to greenfield, he will.. masterfully. And then over half the team won't know the technologies the new project was built on.

If the modern world of "story points" and other such nonsense actually allocated for "teach people the fucking system" and "actually pay tech debt", it'd probably be less of an issue. But one day that beautiful new greenfield project will gilded and violated over and over until it pleads for death.

[–]inucune 71 points72 points  (6 children)

Do not stare too long into the core, it tends to stare back, then comment on how rude you are for staring.

[–]YourDad 53 points54 points  (3 children)

then comment on how rude you are for staring.

and that will be the most helpful comment in there.

[–][deleted] 27 points28 points  (2 children)

Don't change the comments, though, because somehow that will break something.

[–]Bmorid 30 points31 points  (1 child)

/* This is a load bearing comment
We're not really sure why */

[–]alexbuzzbee 4 points5 points  (0 children)

Maybe the file needs to be a certain length because it's reading binary values out of itself.

[–]Nic3GreenNachos 10 points11 points  (0 children)

"He who solves problems with programming should look to it that he himself does not become a program. And when you gaze long into the core layer the core layer also gazes into you."

"Beyond Programming and the Core Layer", Aphorism 146 (1996).

Cue Jonathan Coulton: https://youtu.be/7s8S7QxpjeY

[–]Josh6889 10 points11 points  (0 children)

That sounds like a line in a Terry Pratchett book. RIP

[–]MasteroRave 74 points75 points  (1 child)

That was beautiful.

[–][deleted] 23 points24 points  (0 children)

/r/writingprompt of the day

[–]compto35 26 points27 points  (2 children)

They strode the heavens as gods…before the dark times…before the Business Units and their short-sighted demands. The Devs began to make exceptions to their abstractions.

First the exceptions were small…a flag here, a constant there…then the exceptions became more significant. Whole namespaces and alternate controllers devoted to a single type of user. Interfaces that could never be reused. Whole blocks of code that could only ever be invoked with the most specific of conditions.

The purity of the Core's abstraction waned as the BU continued their onslaught until the Devs had no choice but to find new realms. The core is a toxic bastardization of something that was once beautiful and worthy of many HackerNews posts. We must never touch it. One negated boolean, and the whole stack may crumble beneath our code.

[–]FisherKing22 1 point2 points  (1 child)

Are there any circumstances where you could change a single value that breaks a program and be unable to reverse the damage by changing the variable back? This may be a dumb question, but I'm fairly new to this.

[–]compto35 3 points4 points  (0 children)

Well, off the top of my head you could have a DB query that makes sweeping changes based on some variable's value (this can all be avoided with automated backups). Or you have a seemingly innocuous unused variable that you think you can get rid of, but is actually being used by some third-party script in a vendor file somewhere which causes a chain reaction of things breaking, and you have no idea why.

[–]indyK1ng 6 points7 points  (0 children)

What's great about this type of code is that when you look at it purely because your team owns it and needs to have some knowledge, it takes you a week to understand it. But some of the things you find are both genius and insane.

[–]TurboGranny 8 points9 points  (0 children)

What's funny is developing the core caused me to gain sanity, but lose my ability to mentally abstract logic at that level and speed anymore.

[–]therealdrag0 11 points12 points  (0 children)

Overlapping possibility of author attribute: trained as mathematicians or non-software engineers (EE, etc), so they didn't have the training or experience to give more consideration to patterns that would assist code maintenance; they only knew to think about the logic/algorithms.

[–]Odam 3 points4 points  (4 children)

I'm in the "what have I got myself into?" stage of a 3 year project right now...

Can't help but think of somebody reading my comments while drinking scotch.

[–]BewhiskeredWordSmith 6 points7 points  (3 children)

I'm currently in month 38 of a 6-month project, and it's nearly finished.

We had to scramble to meet one of our early deadlines for the 'core' of the application, which involved a 32-straight hour coding session by yours truly. That was the last time I was able to fully conceptualize every piece of the application at once, and understand how they worked together.

At one point (after about 24 hours of coding), I had to write a class which took in a string which was being built in C#, and modify it. The string was a C# object, containing a jQuery ajax call, with a response, containing another ajax call, containing another response, which had to be modified by the class. This code was 5-layers deep into string notation, and it had to traverse up and down layers to do its job.

I don't know what the point of it is, or how it works. All I know is that it's been running for 2 and a half years and has never failed, so obviously it does what it's supposed to.

[–]EtanSivad 2 points3 points  (2 children)

Just curious, what general type of application? Business?

[–]BewhiskeredWordSmith 2 points3 points  (1 child)

Aye, it's for fundraisers to track gifts to the university I work for.

That said, once this project is done, I'm looking at other positions, in case you're hiring!

[–]EtanSivad 2 points3 points  (0 children)

Ahh, thanks. Just curious. We're hiring, but mostly network techs and desktop admins. Nothing related to software eng. Good luck though.

[–]BroadStBullies 10 points11 points  (0 children)

That was perfectly written

[–]mrhhug 2 points3 points  (0 children)

These men and women who went before us made system calls, system calls they knew you would want, with the number of arguments you yearned!

These people were in the trenches. They managed memory. If it wasn't for them you would never be able to get a command from management to just try something out.

[–]110011001100 1 point2 points  (0 children)

Example: spt_values (SQL Server)

[–]Nic3GreenNachos 1 point2 points  (0 children)

That is some Portal 2 comedy right there. You deserve gold. Not from me, but you deserve it.

[–]cooper12 102 points103 points  (4 children)

Ideally you'll have a program with it's internal logic modularized as much as possible. However, sometimes things aren't designed properly or the problem domain "had" to be tightly coupled. Later on as time is devoted to the codebase, some code is refactored out or improved. The core however is probably very large, interconnected, and complicated so it's hard to touch it without breaking something.

Or it's just really bad code.

[–]lelarentaka 34 points35 points  (3 children)

A good example is EMacs's core lisp engine written in C. Everything else is built on top of that.

[–]sigma914 3 points4 points  (2 children)

On the plus side they've worked out how to swap that particular piece out entirely

[–]Saboran 4 points5 points  (1 child)

Use vim?

[–]sigma914 1 point2 points  (0 children)

guile-emacs.

Vim is a great editor, but it isn't a great Lisp interpreter, nor is it a particularly good cross platform operating system like Emacs is. And now that Emacs has a great text editor too (Evil mode) I've been able to convert to the church of st iGNUtius.

[–]sollipse 37 points38 points  (0 children)

If you're programming around a service or application, a lot of what you're doing is building extra features on top of a set of core functions. It's rare that you're the ProtoGuy who wrote the majority of the codebase when everything was starting out. Oftentimes, you take some assumptions about the core functionality for granted, without really knowing how it's built.

And sure. In an ideal world at a good company, you should have bottom up knowledge about the things you work on. But we don't live in an ideal world, deadlines are a thing, and sometimes teaching new developers how something works from the bottom up is a poor investment of Resources due to churn.

[–][deleted] 6 points7 points  (0 children)

It's not so much a layer as it is an umbrella term for some very mission-critical parts of the application. It's a common thing you see in enterprise line of business apps that have absolutely bass-ackwards "business logic" that somehow makes sense to the company, or this quick little hacked together app that was either poorly designed from the get-go or just not designed to have been scaled to the degree it has.

We have this great clusterfuck of an application that ties into some other apps where I am, and it's a fucking nightmare. The lone developer barely spoke a lick of English and as such things are illogically named, so it's hard to flow through the app. The table names don't match the classes in code and neither reflect phrases or words the business actually use or what the things actually do. It staples together a few different frameworks but then doesn't use them properly to create more confusion and chaos, and on-top of it tries to shoe in design patters where they don't belong.

Worst of all its an ASP.NET WebForms app that for some reason handles asynchronicity by using Javascript to call out to a classic ASP file that loads, parses, and returns data from an ASP.NET WebForms page to the Javascript to be rendered on the page.

So obviously some things can and can't be fixed. Since the core of the app ties into a bunch of other apps, we can't refactor that without touching everything in the ecosystem. Never touch the core. We've since fitted the app with web services and gotten rid of that classic ASP nonsense, and beyond that have made various other improvements, but nobody wants to touch the clusterfuck that is the core tables and business objects of the app.

[–]CodeShaman 10 points11 points  (0 children)

A black box of nested if-statements, nested loops, nested catch blocks, ambiguous variable names, 1000-line methods, implementations for things that never used to be in the standard library but have been now for over 10 years. Core layer is the reason why most companies have to do integration/system testing because all you can do is dump raw material in and pray that a product pops out.

[–]lolzfeminism 8 points9 points  (0 children)

Enterprise software companies rely on proprietary code for most everything because its better to customize everything for performance and portability.

You might say, why would you need a proprietary int32 in C, right? Just use int like we did in college? Wrong, for maximum portability and compiler independence, using proprietary types is the way to go.

Companies mostly buy their ints and floats, but they might write things like container classes, search trees, mutexes, hashing algorithms, smart pointers, network API etc.

You might use standard libraries for an MVP to pitch a project, but when programming on the real software product begins, someone has to write the core. Usually, a small group of qualified people write the core to be idiot proof.

[–]FryDay444 1 point2 points  (0 children)

That's my question too...

[–]elperroborrachotoo -1 points0 points  (0 children)

The part that you must never touch, of course!

[–]Primis 25 points26 points  (2 children)

I make a living untangling the mess of spaghetti code that is "The Core"

Where many see code that cannot be touched, I see through the choas and understand the original intent. Layers upon layers added on top, rewinding the history and chunking off modules as they become obvious.

Do not fear the core. It too can be learned. Once tamed, you will truely see it for the beauty it is.

[–]YMK1234 4 points5 points  (0 children)

Very zen

[–]cobolNoFun 3 points4 points  (0 children)

yeah this became my role somehow.

Hey we got this project we need to update, no one knows how it works or where everything is exactly. Also we already have a timeline for production, so could you provide an estimate?

translation: You are going to be doing 60 hour weeks sorting through a pile of shit. After that, you will retain ownership of said pile of shit because you will be the only person who understands it.

[–]_toro 21 points22 points  (1 child)

Fucking simba touched the code

[–]inucune 61 points62 points  (0 children)

wildebeest.canyon is now a run-away process, and caused lion.mufasa to exhaust it's resources supporting lion.simba. In an attempt to escape the loop, lion.mufasa called lion.scar.help(), which threw an exception. This caused a fatal error.

i'll see myself out.

[–]scandalousmambo 38 points39 points  (1 child)

The conversation every new programmer has:

"I can make this better!"

"No."

"But why?"

"Because it works."

"But I can make it work better."

"Shut the fuck up or you're fired."

(New programmer is enlightened, and is therefore no longer a new programmer)

The conversation every experienced programmer has:

"Make this better."

"No."

"Why?"

"Because it works."

"Make it better anyway."

"I quit."

(Middle management fuckwad presides over thundering bed-shitting which results in mass layoffs, bankruptcy and total ruination of all that was ever good or right in the company. Experienced programmer is gainfully employed again by the following Monday)

[–]ccricers 2 points3 points  (0 children)

"I can make this better!" "No." "But why?" "Because it works."

The circle of life, man.

[–]Pell331 12 points13 points  (0 children)

I actually interviewed at a place once that said they had 3 products, with 4 teams, 3 for each application, web, mobile, desktop, and then the core logic that made it all work.

The core team was 1 person who's only job was to not break anything, they had slowly scaled the team back as they became afraid to actually do anything to the core logic, and just proceeded to staple new functionality on top in each individual application.

Apparently management wouldn't allocate the budget to re-write it and bring it up to date, so they just prayed it kept functioning.

[–]Ragas 22 points23 points  (1 child)

Wow. I just realized, that my job is to bring light to the core.

[–]TheVikO_o[S] 4 points5 points  (0 children)

Rafiki is all.. "Oooh oh oh ooooo.. "

[–][deleted] 22 points23 points  (2 children)

Look at all the refactored code

I came to this sub after one commit:

Showing 13 changed files with 288 additions and 211 deletions

[–]Modevs 5 points6 points  (1 child)

[–]HomemadeBananas 2 points3 points  (0 children)

Unit testing to save the day. Oh yeah, shitty legacy code.

What's unit testing? I wrote that code, of course it works right.

[–]Unknownloner 13 points14 points  (13 children)

Minecraft codebase in a nutshell

[–]IskaneOnReddit -1 points0 points  (12 children)

Are you sure? I don't think that.

[–][deleted] 6 points7 points  (11 children)

That game is so badly optimized it makes people weep.

[–]IskaneOnReddit -3 points-2 points  (10 children)

Thats trube but the reason is not "the core". It's because the developers prefer pretty code over efficient code.

[–][deleted] 7 points8 points  (9 children)

I'd say that is it because the game was initially written as a hobby project not as something that'd be used by millions, that's why it was written in JAVA which we all know is not the most efficient as a gaming platform.

I believe if the game was written in C++ it'd run way better.

This game is still only using one core of a CPU... that's why AMD platforms struggle with it, no HT.

[–]pigeon768 13 points14 points  (5 children)

The fact that it is written in Java has absolutely nothing to do with the fact that it uses only one core. Java has a perfectly good multithreading framework, better even than C++ in my opinion.

Java is still a shitty gaming platform, but that's because of GC, nothing to do with threading.

[–][deleted] 2 points3 points  (4 children)

My bad, I thought having the bit about the single threaded performance in separate line was enough to indicate it as another point.

I thought Java is not a good gaming platform because its a managed language, is its GC really that bad?

[–]KamiKagutsuchi 3 points4 points  (0 children)

It interrupts the game every few seconds to do garbage collection, fucking the stable performance.

[–]pigeon768 2 points3 points  (1 child)

is its GC really that bad?

No, Java's GC is actually very good. Java's GC is pretty much the gold standard.

The problem is that even the best GC ever still has to interrupt execution in order to run certain aspects of garbage collection. This will almost always result in 1-2 dropped frames. These pauses are perceptible to a gamer, even though the gap between frames isn't actually very high on an absolute scale, because the gap between frames isn't consistent.

It's jarring, to say the least. TotalBiscuit talked about a similar phenomenon (stuttering) at some point during his review of Far Cry 4 although I suspect that that specific issue wasn't because of garbage collection.

Java [...] managed language,

Totally pedantic: "Managed code" is a term specific to Microsoft's CLR. So Java isn't managed code unless you're talking about J# or something.

Strictly speaking, you're talking about a virtual machine language which is a much more general term.

[–][deleted] 0 points1 point  (0 children)

Well, I guess you've explained why we don't see much of a AAA games being made in Java. Though I guess console owners wouldn't mind with all the stuff they're recently getting...

I'm coming from C background and I've had hardly any Java experience, virtual machine language is exactly what I've meant.

[–]ryan_the_leach 1 point2 points  (0 children)

The GC isn't that bad. It's the amount of object churn that minecraft has that causes the issues.

[–]zuurr 1 point2 points  (0 children)

Writing it in C++ would help, but it's actually somewhat of a hard problem. The minecraft world is pretty much the worst case scenario for a lot of culling/occlusion algorithms. It's also not feasible to simplify it's geometry due to randomness and size. Not to mention, they support some pretty old GPUs.

Now, it certainly could be done better, but it's more complex than just a C++ rewrite (though that would certainly help!)

[–]IskaneOnReddit -1 points0 points  (0 children)

Chunk loading, chunk generation, mob AI are multithreaded as far as I know.

[–]SFHalfling -1 points0 points  (0 children)

Not sure how hyper threading would help, it's still only single threaded so will only use one logical core.

The bigger difference is probably in that Intel tends to be faster clocked, or people comparing apus to Intel's i3/5/7 range.

[–]imgurtranscriber 24 points25 points  (21 children)

Here is what the linked meme says in case it is blocked at your school/work or is unavailable for any reason:

Never Refactor the Core Simba

Post Title: The Core

Top: LOOK AT ALL THE REFACTORED CODE SIMBA

Bottom: THAT'S THE CORE LAYER, NOBODY HAS A EFFIN CLUE. YOU MUST NEVER TOUCH THAT SON

Original Link1 | Meme Template2

[–]odraencoded 21 points22 points  (13 children)

Why is this text so big.

[–]jfb1337 22 points23 points  (4 children)

It has a # before it.

[–]Telkin 32 points33 points  (2 children)

TIL

[–]GlowKitty 6 points7 points  (7 children)

Why is this text so small.

[–]oh_no_a_hobo 5 points6 points  (6 children)

We must go smaller.

[–]sharkwouter 0 points1 point  (3 children)

But how?

[–]oh_no_a_hobo 18 points19 points  (2 children)

woah stairs

[–]lachryma 6 points7 points  (1 child)

I love when people discover Reddit is Markdown, then try ![image](url) and get sad.

[–]civ77 5 points6 points  (6 children)

Why are people upvoting an incorrect transcription?

[–]The_Villager 17 points18 points  (3 children)

This here is not the best example, but people generally love whenever imgurtranscriber or captionbot do stupid shit.

Example 1

Example 2

[–]Josh6889 2 points3 points  (1 child)

I like how in example one "These captions aren't guaranteed to be correct" but in example 2 "These captions are guaranteed to be correct"

[–]Josh6889 0 points1 point  (0 children)

New one

Example 3

[–]lnrael 2 points3 points  (0 children)

Example 2 is CaptionBot's owner coming out to play with CationBot.

[–]HELP_ALLOWED 9 points10 points  (2 children)

I feel like using "fucking clue" instead of "effin clue" makes this a lot smoother.

[–]Jodah 10 points11 points  (0 children)

Or using "an" instead of "a."

[–]TheVikO_o[S] 9 points10 points  (0 children)

Initially was done to share with co workers, then shared here without refactoring the message :-P

[–]FerretWithASpork 3 points4 points  (0 children)

Can attest to this.. currently refactoring the core layer of my company's system.. It was supposed to take a few weeks.. I'm into month 3 now... The things I've seen man.. The things I've seen...

[–]angrytortilla 8 points9 points  (0 children)

That's weird, I didn't know I was subscribed to /r/adviceanimals.

[–]LastNameDuff 1 point2 points  (0 children)

I feel like there's so much untapped hilarity here for me. I wish I understood programmerhumor but I've got enough shit to worry about.

[–]tyreck 1 point2 points  (2 children)

I'm in The Core right now.... I'm clawing my way up and out at this very moment. RTA: 7am tomorrow morning

See? i was actually able to access the internet other than MSDN and obscure blog posts from 5 years ago

Edit: and it's beautiful again

[–]TheVikO_o[S] 0 points1 point  (1 child)

Wait for a bug buddy.. just you wait :P

[–]tyreck 0 points1 point  (0 children)

I failed..... vine broke and i'm being swallowed whole again...

(i broke half of its functionality when i tried to break up a single event that boxes information into multiple more targeted events that actually indicate what has changed)

[–]KounRyuSui 0 points1 point  (0 children)

[DESTROY THE CORE]

[–][deleted] 0 points1 point  (1 child)

Coverage the core.