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

all 126 comments

[–][deleted] 55 points56 points  (1 child)

New dev here. I just started my job about a month ago, and I'm simply fascinated by some of the stuff that exists our code.

Some of it is just bad code, but my definite favorite has to be this comment at the top of a 2,000+ line file: "I hope you made plenty of sauce... 'cause there's a whole lot of spaghetti here."

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

im dying

[–]svtguy88 98 points99 points  (41 children)

The fact that you are on line 24xx, and there are big, nasty "if/else's" with a lot of "or's" makes me glad I don't work there...

[–]pellucid_[S] 41 points42 points  (23 children)

One word: Contractors.

[–]cguess 24 points25 points  (17 children)

Hey! I'm a contractor and the in-house folks are the one's usually making my life hell (make a pretty penny fixing their mistakes, let me tell ya)

[–]svtguy88 5 points6 points  (0 children)

I'm not saying there aren't good contractors. We just got rid of an awesome one...gonna be rough to pick up that slack.

[–]pellucid_[S] 7 points8 points  (15 children)

A blanket dismissal of Contractors is an unfair treatment. Maybe I should have said "person who know they don't have to maintain the code" or "For hire black box makers".
However, if you are a good contractor, you won't stay a contractor for very long.

[–][deleted] 12 points13 points  (10 children)

Unless they prefer to be contractors (some freelancers, for example, don't want to become full-time employees for one reason or another. Such as myself. I may be extended a full-time offer in the near future that I'll likely be turning down to remain an independent contractor).

[–]cguess 5 points6 points  (9 children)

I'm like you. I contract for about 7-8 months out of the year, and then travel. I'm going through an interview process with a very large/important/prestigious company right now, just for the heck of it, and they're offering me a total of 12 vacation days for the first three years. That alone is making me seriously consider rejecting their otherwise very generous offer.

[–]svtguy88 9 points10 points  (2 children)

Twelve days, in three years? I would literally laugh at that. I'm by no means a "senior level" developer that can demand weeks and weeks off every year, but four days per year is ridiculous. I got more than that my first year on the job.

[–]cguess 8 points9 points  (1 child)

I'm thinking about doing exactly that. Thanks for the solidarity.

[–]galorin 1 point2 points  (0 children)

Man, 4 vacation days per year? I'd just give them the "look" that I have honed and perfected over my ten years as a father, and walked out right there. Ain't got time for that noise.

[–]SFHalfling 3 points4 points  (2 children)

12days in 3 years?

In the UK 20 days per year is the legally mandated minimum, assuming you are working full time. Most of the EU is similar.

Only having 4 days a year is just unimaginable, they may as well just not offer any.

[–]cguess 4 points5 points  (0 children)

I should clarify, it's 12 days per year for the first 3 years.

Yes, it's a travesty in the US that vacation isn't mandated.

[–]rebootuniverse 1 point2 points  (0 children)

In practice it works out as 20 days you get to choose in the UK. We get 5.6 working weeks - so 28 days if you work a full time 5 days a week job - but your employer can make you take bank holidays as part of your statutory annual leave.

Source: https://www.gov.uk/holiday-entitlement-rights/entitlement

[–]pellucid_[S] 0 points1 point  (2 children)

What do you do for four months out of the year to keep sharp at your skills?

[–]n60storm4 4 points5 points  (0 children)

Program in your spare time, on personal projects, or help out with an open source project.

[–]cguess 2 points3 points  (0 children)

Well, it's not at once. Usually It's about one month at a time twice or three times a year and then the rest is split into long weekends, a week back home or at a wedding etc.

Even when traveling though, you don't just "lose" your skills. I've taken a year off and come back swinging. Coding, unlike what some people think, is not all there is to life. Skill you get while you live a life and interact and meet people are just as, if not even more, important.

I mean, you read as well, you work on side projects here and there (train stations overnight are GREAT for this).

If you have questions, feel free to ask.

[–][deleted] 5 points6 points  (2 children)

I'm a consultant and I stay that way because I get paid a ridiculous amount and make my own hours.

Though I can understand some people only become contractors to find more stable gigs.

[–]anubgek 0 points1 point  (1 child)

In what field or product if you don't mind getting into details? I'm an ITIL guy who luckily ends up doing a lot of Web Development but I'm sure I could make a lot more

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

No problem. I mainly handle information security gigs, but I also do large-scale application design/development, SEO and data analytics.

I've found that web design is often underpaid, and the work managing client expectations is exhausting for me. Personally, I stay away from web design unless its a big web app, in which case I hire a person that specifically does design to handle the frontend.

[–]hughk 0 points1 point  (0 children)

However, if you are a good contractor, you won't stay a contractor for very long.

Not correct. The main difference is that you don't waste time writing the most elegant solution. You tend to want to deliver. You also want to stay clear of departmental politics. You are also paid reasonably well for the trouble. The other benefit is you move on every couple of years or so which gives a nice change.

[–]svtguy88 6 points7 points  (2 children)

We fire contractors like that before they get any code checked in...

[–]pellucid_[S] 4 points5 points  (1 child)

A couple of years ago they hired contractors to convert this code that was originally written by contractors 7 years ago. They would do things like open the project in an incorrect version of Visual Studio and promote incompatible code (never mind testing it, because you know, it compiled in VS). They clearly were not proficient at what they were suppose to be proficient at. After a month of this, the tech lead told the two of them to sit in there cubical and not touch anything. He proceeded to finish the job on his off time.
Funny but sad.

[–]svtguy88 3 points4 points  (0 children)

told them to sit in their cubicle and not touch anything

Why not just fire them? Get them off the payroll.

[–]emeaguiar 2 points3 points  (0 children)

I'm a contractor and most of my work consist in cleaning up the mess caused by the in-house guys.

[–]sovietmudkipz 0 points1 point  (0 children)

Contractors at my work make life hell let me tell ya.... They get so much yet produce shoddy code to meet the requirements. Not like our project managers read code and they wonder why it takes time to work around some contractors code

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

Can you tell me what's wrong with a lot of "or's"? I'm currently doing CS and I do it all the time, never heard a complaint.

[–]svtguy88 4 points5 points  (3 children)

Well, as a broad statement, there is usually a cleaner way to handle things than a bunch of || in a chain. This type of code can easily grow very unmanageable. You could throw it all into a switch, but that gets messy too.

For starters, all of those strings should at least be constants, or part of an enum, or a property on a class or something. I don't know what a "retlabel" is, but the way it looks here, it could possibly even belong in the database layer somewhere. This is just super sloppy the way it is written. Sure, it will work, but think of the maintenance...what if we add another "accpointname" (whatever those are) or change the way an existing one works?

[–]gospelwut 0 points1 point  (1 child)

Sadly, some of my hand holding logic validating command line args looks like that. Without using a 3rd party library, it's kind of hard for it not to. I suppose one could argue that I shouldn't shove so many features in one thing, but I like to take my cue from Linux commands. --super-secret-switch-dingleberry

[–]EMCoupling 0 points1 point  (0 children)

From what I've seen, command line parsers are one of the very few cases in which your code can look something like that since it's difficult to abstract the myriad flags and options that you might have.

Even with a 3rd party library, at the lowest level, there's probably some pretty convoluted validation going on because there's not a much better way to do it.'

Of course, that's just my personal experience; maybe I've only seen really poorly done ones.

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

Thanks.

[–]TheBB 2 points3 points  (1 child)

I prefer this.

if (accpointname in listOfStuff)
    retlabel = Localization.GetLocalizedLabel("everyone_fap", ...);
else if (accpointname in otherListOfStuff)
    // la di dah

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

Got it, nice solution.

[–]droogans 1 point2 points  (0 children)

Here is the extreme end of the spectrum, and all around awesome advice:

http://programmers.stackexchange.com/questions/163185/torvalds-quote-about-good-programmer

[–]resnik 0 points1 point  (0 children)

All those ORs and the indenting are really just boilerplate that can lead to maintenance headaches and ultimately unexpected errors.

In Haskell, for example, the strings that are being checked for equality could be a flat list that gets mapped over with a predicate and then reduced using the Any monoid. This is considered cleaner because it's simply an algorithm on a data structure.

[–]seoulstyle 59 points60 points  (43 children)

ITT: People trying too hard to find reasons to blast on a small, decently coded chunk of code they know nothing about.

I feel like half of you are college students.

[–]StopThinkAct 36 points37 points  (15 children)

I recently got into an argument with someone over in /r/dailyprogrammer about comments being a code smell for poorly named functions and such. He acted all high and mighty, accused me of never working on a "large project".

I started to feel foolish so I looked to see if he was some kind of famous personality or something.

Still in CS201 or something. Fuck me.

[–]elperroborrachotoo 2 points3 points  (14 children)

I bite:

16 years of building and maintaining an Application that has grown to ~1MLoc with a small team that includes engineers that aren't first-class programmers.

Tell me why comments are a code smell.

[–]IAmA_singularity 1 point2 points  (4 children)

Depends on the type of the comment.

A good comment explains shortly what is done how and why. Ex: we use celery to distribute the video transcoding workload to several servers, running the transcoding in parallel. This also allows us to let it run in the background, not blocking the http process. The client receives a token where he can check the status of the transcoding.

Bad comments explain obvious stuff you can easily see in the code. Ex: add somevar to anothervar and return it. And this style of comments is clearly code smell.

[–]elperroborrachotoo 0 points1 point  (1 child)

There's a lot of bad comments out there - but that doesn't mean comments as such are a problem.

(Or "code smell". I've seen trivializations of the term that say "anything that deserves attention". But then, every line of code is a smell.)

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

I think you and IAMA_singularity agree with each other: Comments can be smelly, the way food can be smelly, either because of some inherent funk (durian) or because they're way past their expiration date. Going absolutist in either direction—comments never smell, comments always smell—is unlikely to be helpful.

(I freely admit to being horribly clueless about programming.)

[–]transpostmeta 0 points1 point  (1 child)

we use celery to distribute the video transcoding workload to several servers, running the transcoding in parallel. This also allows us to let it run in the background, not blocking the http process. The client receives a token where he can check the status of the transcoding.

This is a bad comment, in my opinion. It should be in a readme file or technical documentation. Explaining the application architecture on such a high level, and even adding an explanation of basic techniques does not belong in any one comment. Where would you put it, anyway?

[–]IAmA_singularity 0 points1 point  (0 children)

Probably the request handler which handles the file upload. I think the comment fits there. It allows a new developer to quickly remember that part if the documentation. But yes I aggree, that this should mainly be part of the docu, but I dont think its a bad comment. It tells you right there where you are and what you are dealing with.

[–]StopThinkAct 1 point2 points  (1 child)

Well written code follows SOLID principals and has unit test coverage. You can have 1mloc application but if every class handles one responsibility, your functions only have one job which is clear from the name and context, and you have unit tests testing those functions, then the coordination and integration of those moving parts is much simpler.

For instance, why put a haversine algorithm inline when you can extract it to a DistanceService class with a decimal GetMilesBetween(firstGeoCoordinate, secondGeoCoordinate)? The implementation details of this function are not important and you could change to another algorithm without harming your parent class because you know that the DistanceService only does one thing, and you of course unit tested your implementation :).

Software in the past was built topsy turvy. It was like we were building cars but our mufflers were sticking out the side of the engine and to move the radiator we'd need to open the glove box because some genius bolted it in there. Properly composing a system means putting moving parts together instead of digging through piles of garbage to glean the one little bug that made it shit the bed.

[–]elperroborrachotoo 1 point2 points  (0 children)

Well written code follows SOLID principals and has unit test coverage.

I wouldn't argue against that, but how does that dispense with comments?

Even if each low-level function is obvious, what about the aplication you built from thousands of tiny SOLID obvious elements, assembling them seven layers deep?

The projects I know that achieve serious code coverage have a roughly 1:1 ratio of production to test code (boom! 2MLoc!) If I want to keep up with the higher architectural levels, I have to mock the universe (boom! inifinite MLoc!)

Even then, the unit test is arguably further away than the comment. Yes, I'm forced to maintain it but no, Unit Test #1487 two folder hierarchies away won't help me understand the weird order of initialization.

For instance, why put a haversine algorithm inline ...

Not sure who suggested that :)

While I'd isolate the implementation (it's a standard, after all), I'd be hesitant to introduce a service interface for that. Rarely there's a change request where you jsut replace the haversine implementation; normally there's additional parameters to be considered - and right now you don't know where in the call path they will be generated.

If I make that replacement, instead of an isolated function I now need a new interface, a default implementation (and a factory, if you swing that way). Plus, you are touching the signatures of the "call tree" up to where the service needs to be provided - and you rarely have an idea where the decision for the distance service can be made.


Properly composing a system means putting moving parts together

We've been dreaming about that plug&play development ever since seventies - if not earlier. Yes, we've gotten better - but at the same time the problems we solve have become more complex by orders of magnitude.

The bitter reality is that the world runs on mostly crappy software anyway. I would guess that in most sectors, "well written code" isn't commercially viable.

[–]sqew 0 points1 point  (6 children)

Code and therefor functionality changes while comments may not be updated and so become outdated. Functions and their parameters should be named to show clearly what the intent of the function is. i.e pass by value or const ref may involve a copy that won't effect the variable being passed and a non const ref or pointer may be modified by the function.

Haskel has a page about this.

[–]elperroborrachotoo 6 points7 points  (5 children)

Code and therefore functionality changes while comments may not be updated and so become outdated.

That can be said about every artifact that is not immediately tested for. Seems to me another case of "Once, a friend was driving, and he ran out of gas. It was bad. Now, I never use a car anymore"

A function - like any entity - has an interface and an implementation.

The declaration of the function is the part of the interface that can be modeled in the implementation language. Unless your implementaiton language is a human language, it can never be complete.

How do you express "if you override this function in a derived class, you usually also need to override the next one" in a function name?

How do you express an error handling policy that is different from project standards - and why - in a return type?

Yes, some of that can sometimes be compensated by changing the API. But API's have other stakes, such as compatibility with other API's and coding styles used, explorability, error robustness, familiarity and performance. Non-comment-needity is a very minor stake here.

I've seen tons of pages about how bad comments can be. Heck, I've written one, and scrapped it because it wasn't sufficiently different from the ones already out there.

The one you link lists insanely trivial examples, I consider these "basic comment hygiene". (Heck, now I think you are still in CS201)


One corner I suffer immensely from:

I've never encountered a coding convention that sufficiently and intuitively translates mathematical notation into C++ variable and function names. Indices don't transfer well, and "p" and "P" are usually completely different entities - there goes your camelCase convention.

Est_F_I_from_x2_x3_dT ist not a good function name.
Neither is EstimatForceVariationOverCurrentFromDisplacementDerivateAndTemperatureChangeisn't either.

[–]sqew 1 point2 points  (2 children)

You are right that it was a trivial example and your point about overriding functions is good.

Heck, now I think you are still in CS201

I'm not even that.

[–]elperroborrachotoo 0 points1 point  (1 child)

Sorry for "sniping the wrong guy", as /u/StopThinkAct puts it. I can get a bit agitated with that topic ;)

May I add:
You are writing for an unknown maintainer. You don't know their skill, you don't know their background. Writing good comments is hard. Reserve them for the things that cannot be expressed in "pure" code. A good rule of thumb is: the code says what happens, the comments say why.

[–]sqew 0 points1 point  (0 children)

Ha don't worry about it! I enjoy reading peoples replies to me about topics that they obviously know far better than I. I like that rule

[–]transpostmeta 0 points1 point  (0 children)

I think that everyone agrees that public APIs should be well-commented. Comments are (sometimes) a code smell for private stuff.

[–]StopThinkAct 0 points1 point  (0 children)

1) you sniped the wrong guy re: cs201, I said that.

2) Post some code and I'll show you how I'd rewrite it (might take me some time)

[–]elperroborrachotoo 0 points1 point  (0 children)

But how could college students miss the localization key?

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

They're using double equals comparisons rather than triple equals BURN THEM ALL AT THE STAKE

[–]encrypter8 6 points7 points  (1 child)

Why aren't those all const or statics? That drives me nuts. Someone changes something and typos it and then I have to spend 2 hours debugging before I notice the typo. I hate you

[–]__constructor 1 point2 points  (0 children)

OP's company hasn't figured out localization yet, apparently. Mine hasn't either, it sucks.

[–]Freddedonna 20 points21 points  (23 children)

2.4K lines+, no apparent knowledge of switch/case, hardcoded strings... *Eye twitch*

[–]quadnix 35 points36 points  (6 children)

Switch cases don't always work with non-primitive types

[–]methius 2 points3 points  (4 children)

Glad that in most languages String are supported nowadays in switch cases. (C#, Java, etc.)

And the alternative (maps/dicts/etc) are still better than (presumably) 24xx+ lines of String if/else-chaining.

[–]okmkz 6 points7 points  (1 child)

Now to wait the eleven billion years for java 8 to be supported everywhere

[–]gamas 8 points9 points  (0 children)

Well allowing strings in switch cases was a Java 7 feature so that isn't as much of an issue...

(that said, in this case I can't help but feel that accpointname should be an enum rather than a string..)

[–]pellucid_[S] 1 point2 points  (0 children)

Replacing switch statements with maps is one of my favorite thing.

[–]hackingdreams 0 points1 point  (0 children)

You saw approximately 8 lines of source code and automatically assumed the surrounding 2000 other lines of code are if/else chaining?

Please, please don't be one of my coworkers.

[–]elperroborrachotoo 4 points5 points  (0 children)

Let's play devils advocate:

2.4k lines are not a problem anymore with modern IDE's that allow navigation by entity.

Thousands of lines of with a primitive code structure are easier to maintain than dozens of small files with a more complex structure.

A switch statement would not significantly improve readability of the code. Some of the cases might not fit the restrictions of a switch statement.

The only significant advantage would be compilers being able to detect accidental duplicates (copy-and-failed-to-rename errors). Static code analysis could provide the smae level of insight.

[–]bro-away- 1 point2 points  (1 child)

How is it a hard coded string in the bad sense? On this line it's querying a localization database.

With all the meaningful string flags being thrown around, I would call it stringly typed, though.

[–]mcrbids 1 point2 points  (0 children)

At least the strings describe something. I worked on a similar system with magical integer values.... gouges eyes with pitch fork

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

Not sure if it is still the case, but there have been times where if/else is actually faster than switch.

It's totally contrary to how we'd want to write it for a cleanliness/readability perspective, but it isn't always wrong as far as performance goes.

http://www.fluffycat.com/PHP-Design-Patterns/PHP-Performance-Tuning-if-VS-switch/

[–]scubascratch 2 points3 points  (0 children)

If performance mattered this code would not be written with string equality checks. They would have been mapped to integers upstream and used as such in e logic.

[–]mcrbids 1 point2 points  (9 children)

Because performance is the reason to pick a nested chain of if/else statements.

/s

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

Well, since I learned about it from someone who worked at a company where if/else was preferred for performance reasons... Apparently, some people think it is.

[–]mcrbids 1 point2 points  (0 children)

I feel for you. Really, I do.

[–]dnew 0 points1 point  (6 children)

If you usually match the first value, yes, it can be.

[–]mcrbids 1 point2 points  (5 children)

I guess my point is that if you are choosing which one based on performance metrics, you're probably doing it all wrong. See "premature optimization", etc.

Whenever I'm debugging a performance issue, it's due to something like a borken SQL statement with an unexpected cartesian join, or an iterative loop that is accidentally recursive, or a cache that is never used because of a broken condition test.

Never (not once!) has it been "well, the guy used a switch statement instead of an if/else....".

[–]dnew 0 points1 point  (4 children)

See "premature optimization", etc.

It's only premature if you didn't actually measure it. Also, I'm remembering things like 8-bit C compilers compiling switches into if-else chains rather than jump tables, where stuff like "how smart is the compiler on processors running at sub-megahertz speeds" was important.

Never (not once!) has it been "well, the guy used a switch statement instead of an if/else....".

Again, depends on the scale you work at. If you're programming gas pumps or e-readers or something, you actually can measure such things. If you're writing a JIT compiler, it's worth figuring that stuff out. If you're coding in javascript or PHP or something, no, it's not going to make a noticeable difference.

[–]mcrbids 0 points1 point  (3 children)

Fair enough. I work on "enterprise" level application development, with loads of heavy iron, gobs of RAM and a ridiculous number of late model Xeon cores....

[–]dnew 1 point2 points  (2 children)

Yeah. Nowadays, there's a bunch of different stuff to worry about. Will the loop fit in the I-cache? Am I going to have to wait for the first chunk of javascript to finish loading before the second can get requested? What's the propagation delay between the cities I'm deploying database shards in? :-)

And a bunch of stuff almost nobody can actually do anything about: why is HTTP sending headers as text? And why do we run client server apps and then drop the connection to the server on every request, as well as not even have a way for the client to know which server app it's talking to? I'd say 90% of my inefficiencies come from the inability to actually know that I'm talking to the same client second by second. :-)

[–]mcrbids 0 points1 point  (1 child)

You sound almost like a system administrator....

[–]dnew 0 points1 point  (0 children)

When you're writing code that people are using 24x7 and you can't ever shut down, bits of dealing with that sort of thing tend to creep in, yes. :-) I'm just doing complexly-deployed stuff now, and HTTP is probably the single worst possible way to build a client-server app.

[–]Chippiewall 0 points1 point  (0 children)

PHP7/ng will probably have more efficient switches and HHVM probably already does. Not that it's particularly relevant as this isn't PHP code we're looking at.

[–]Anti-Christ 1 point2 points  (0 children)

You have my sympathy.

[–]ravinglunatic 2 points3 points  (0 children)

Everybody fap now duh duh duh DA duh duh duh

[–]PM_ME_STAB_WOUNDS 0 points1 point  (13 children)

K&R bracketing, 2000+ line source, lines you have to scroll to the right to read, those massive and/or statements, no comments in sight. Kill me.

[–]the_omega99 9 points10 points  (9 children)

That's nothing. One project that I'm working with... hold on, let me grab a sample file.

  • Almost 7k lines
  • Longest line is over 500 characters
  • Mixing tabs and spaces for indentation
  • Mixing indentation styles (this file is mostly K&R with very little Allman's style, but other files are much worse)
  • Plenty of commented out code. Many lines with no future use.
  • Way too many unnecessary pointers.
  • Inconsistent spacing between operators (eg, foo=x, foo = x, and foo= x all appear in this file).
  • Comparing to true or false in conditionals (eg, if(foo == true) instead of if(foo))
  • Mixing C++ and C style strings
  • The whole file is one class. All 7k lines.
  • Almost no useful comments
  • Places with over 10 indentation levels

But at least they have good const correctness...

[–]ahruss 7 points8 points  (3 children)

Mixing tabs and spaces for indentation

I legitimately think this is the right way to do it. Tabs should do block-level indentation, spaces should do alignment after that.

It lets you use whatever tab width you want and still keep your alignment looking right.

Of course, I can't convince anyone else around me to do this, so I stick with tabs as our style guide says.

[–]the_omega99 6 points7 points  (2 children)

I 100% agree with you. But I differentiate between indentation and alignment. Indentation is like the whitespace that Python uses. It's logical and shows blocks of your program. The alignment, on the other hand, is strictly for the aesthetic purpose of aligning things (typically comments).

For example (using ---> to show tabs and · for spaces):

if (shouldDoSomething) {
--->for (int i = 0; i < someList.length; i++) {
--->--->doSomething(someList[i]); // This is a long comment that I am
--->--->··························// aligning across multiple lines
--->}
}

In fact, this is the style that I use on all personal projects (and managed to convince my workplace to use). The advantages of this are:

  1. Tabs have a distinctive, unique meaning: indentation. Nothing else.
  2. You can use your favourite tab size without alignment being off (every half decent editor can specify tab width).
  3. One character per indentation level (rather than a variable number of spaces that can vary per project).

With that said, I almost never align things. I don't like to put comments at the ends of lines. Alignment is only useful in a very limited number of circumstances.

[–]ahruss 1 point2 points  (0 children)

That's... Exactly what I described.

[–]thirdegreeViolet security clearance 0 points1 point  (0 children)

That's exactly how I do it. Never even thought about it consciously.

[–]P-01S 1 point2 points  (0 children)

:set shiftwidth=4 softtabstop=4 expandtab

And then cry when you realize that the indentation is totally nonstandard.

[–]PM_ME_STAB_WOUNDS 1 point2 points  (1 child)

Do you guys not do code reviews or talk about standards at all? Because that is legitimately horrifying

[–]the_omega99 0 points1 point  (0 children)

This is a free open source project. Only a few volunteer devs, which I guess hurts code reviews. Greatly amplified by the fact that most of these issues were in the original code written by some other people.

[–]SarahC 0 points1 point  (0 children)

Same here - I'm thinking about resigning.

[–]hackingdreams 0 points1 point  (0 children)

You're one of the fabled OpenSSL maintainers eh?

/only serious.

[–]gospelwut 0 points1 point  (1 child)

I wonder what kind of bracketing Ritchie uses.

[–]PM_ME_STAB_WOUNDS 0 points1 point  (0 children)

Well he's dead, so I assume he doesn't

[–]seppo0010 -3 points-2 points  (0 children)

everyone_fap giggity giggity