What's the hardest concept in programming that you've ever learned and wanted to puke while learning it?

I remember my "a-ha" moment when Binary Search Trees clicked. It was little but it was nice

Interfaces declare how you can interact with particular objects. It's part of object oriented programming.

Imagine having a box with a button on it. You don't know what will happen or how will it happen, but you can be sure that you can press that button.

It's been awhile since I programmed in Jave. I think that's the implements keyword. So it will inherit methods from a superclass. So you don't have to create them again.

If this is completely incorrect sorry, I'm a CS dropout who hasn't coded in 2 years.

Yeah, I bet. I remember when I finally understood loops. That was a big moment for me. I'm

Recursivity

Okay that makes sense. So they work something like this: Class vehicle has a vehicle.drive() method, if you created a new Class called Sedan, you'd instantiate it as public Class Sedan implements Vehicle
and it would inherit the the vehicle.drive(); method?

>wanted to puke while learning it
Design patterns.
>hardest
Formal verification of programs, but I actually enjoyed that.

Loops

It really means "must contain"

Making a function declared in one file being usable from another file in C. It's like it WANTS me to do everything in one file.

interface vs abstract and when to use what

Here's a diagram i drew to help me remember

Attached: interfacevsabstract.png (800x600, 76K)

By implementing interface B you're already implementing A.

you should never return put a pointer as the return from a function, always put it as a parameter

Attached: 077 (2).png (310x544, 116K)

The first few lines of code I ever read as a kid took me months to read. I was not smart. It's been all easier from there.

Multi threading, especially when you go in-depth on the topic.

Object orientation and event handling

Recursion.

I mean I love it now, but anyone who claims they immediately got it is a fucking liar.

I’ll explain it like the brainlet zoomer you are:
They’re kind of like strictly enforced hashtags. If you put #BLM on your tweet it better contain things about BLM or you can’t post it. A tweet can have many hashtags.
That’s it.

I think it has to do with having it explained well right out of the bat. I have seen very bad programmers understand and use pointers, assembly language, etc. right out of the gate because of how it was introduced. good mental models make all the difference

Neural networks. Making them from scratch

It's fine to return a pointer to heap or global memory, or more generally, anything still within the caller's scope. Not ok to return a pointer to the callee's stack. That's all

What is the point of using interfaces then if they're so restrictive?

Also >zoomer lmao no, just brainlet

Absolutely disgusting. I feel bad for anyone who has to deal with shit like that.

Companies use interfaces because you don't know how many people are going to be contributing to the same code, allowing for uniformity.

manual memory management

It makes no sense that a printf doesn't need any memory to be freed again, but other shit does. I still don't get it I'm dum

>It makes no sense that a printf doesn't need any memory to be freed again
It does. Stdio files have an internal buffer which they write to, and gets flushed regularly.

How to use the IO monad in Scala (cats-effect). I think I got the theory behind it but I still have to go ahead and use it in our production code w/o my boss getting mad.

Thank you for explaining it to me. I don't have the necessary eye to see where I need to manage manually and where I don't. I always hope the compiler complains at the correct line and then fuck around by trial and error until it works (only for private stuff, relax).

Luckily there's tons of babbylanguages nowadays that do all that shit automatically (but way less performant).

Attached: 91 - gOcmefQ.jpg (400x400, 23K)

oshi-
was meant for
Excuse me.

>Formal verification of programs, but I actually enjoyed that.

Same. I think the word "hard" is itself hard to define. Something like this is technically hard, but we don't bitch about it because it's not terrible.

If javascript coercion rules are not that hard, but worth bitching about because every one gets them wrong every time because everyone hates them, are they harder?

OP here, there's this fucking guy in our class that didn't even program before going to comp sci college, but I must mention he did went to a very hard high school.

The dude is a beast, he understands concepts immediately and does assignments in the shortest time possible. At the end of the semester we had recursion and everybody kind of scratched their heads when we got recursion assignment and normally it took you 1 day or two to finish it. However, this fucking guy thought about it for a hour or so in school and came up with solution during exercises. We were all just kind of looking at each other like wtf. Same with few other exercises, where most of us spend days on finishing some shit and he would do it in the same day in the same class that we've just start to discuss the topic.

Sure, he probably learned fundamentals really good, but I asked him about his thought process and kind of joked about how faster he is and why he thinks so much better.. so I pull up and assignment and ask him about it, but he just pointed out to things and said "it just seems logical to do this and this, I can't explain it". So you have these guys also.

There's another guy that went to really easy high school and never before programmed anything and is also a beast, but I think that guy is just really humble, lonely and commited for whatever reason.

Attached: wat.gif (300x224, 2.16M)

If you implement Serializable then it had better be actually fucking serializable, for example. It enforces behaviors and properties so you can write generic shit like writeToFile(arg) and accept any Serializable object rather than writing a separate method for every fucker that needs to be dumped to disk.

You can use interfaces to group different implementations through polymorphism, eg. list of Animals (interface) can include Cats, Dogs, and Quokkas (classes).
It's good practice here to use interfaces instead of a parent class when there is no logical implementation for a base 'Animal' only specific variations.

> OP "whats the hardest concept"
>pointers, trees, design patterns, interfaces, recursion
hello fellow first year cs students

Attached: 55SpYrF.jpg (550x336, 52K)

Not really a hardest one but to me, every explanations make me want to puke.

Dependency injection.

Can you tell us what to really dig into for upcoming years that is harder?

Monads.

Fucking haskell. It's one huge the hardest concept i've even tried to learn. But i keep trying to understand it.

You declare an "interface" that is required for you to work and the system gives you an object that implements the said interface. Imagine asking mom for money.

Thank you for an explanation but I already understand it.

It is just that all explanations seem to go on an on non-stop, usually with example that both useless and missing the point.

the import statement in python

Attached: Computer.gif (640x480, 1.26M)

Aye. This is what happens when you try to dumb everything down so common denominator would understand it.

Djikstra was right. Science stuff needs to be explained in abstractions.

youtube.com/watch?v=7uLzaKlZSQQ

I have never encounted something which was hard *and* made me want to puke.

Learning Java at community college made me want to puke.

Learning how to write a program with real-time IO in haskell was pretty hard, and honestly I can't even explain how that shit works, I just got a feel for it, it's totally unintuitive to use pure functional programming for interactive software though....

Based and checked

>build systems
>threads, locks, IPC
>networking
>security
>working with awful platform APIs
>debugging threaded code and distributed systems
>debugging platform/compiler/hardware issues
>low-level x86 and ARM optimization
>writing good code in bad languages
>writing good code at all

None. I love programming with my wife Haskell-tan.

Attached: haskell-chan.png (1000x1300, 786K)

That's because dependency injection is an insane solution to a problem that only people whose brains have been fucked up by Java have.

>I always hope the compiler complains at the correct line
Well, Rust tries to do exactly that
>then fuck around by trial and error until it works
I'm not sure if that would work in Rust though

>lazy evaluation
>monoids in category of endofunctors
>types are formulas and programs are proofs
>what does "while true do skip" mean?
>makings programs actually run

>>working with awful platform APIs
this is the bane of my existence
in what universe should it be this difficult to send a simple http request

Just use libcurl. Even without a library, that shit isn't that hard.

no libcurl isnt hard.
what is hard is decoding what the fuck is actually required at an api endpoint to actually extract data from it
ive seen some very esoterically defined endpoints, and some were the specification wasnt even correct, so i had to thinker endlessly with different types of requests and inputs

JSF and xhtml in java and to some extent magento

That's literally what Rust pajeets (98% of the userbase) do when the borrow checker complains about something

the BLE stack on linux. that one took a while to chew

Learning this now, really simple recursion is easy but anything more complicated is tricky, I puzzled over tower of hanoi for hours before I realized it had to have branching recursion

variables
like.. how?

WinAPI
Learning that doing something from the main thread sometimes doesn't work from a different thread.

C++ constructors

They're just superclasses without any methods, and unlike a superclass one class can have multiple interfaces.

Load balancing.

This has to be bait. Recursion is as trivial as iterative code if not simpler because the distinction between mutated state and and immutable state becomes to pronounced.

bullshit

Implementing support vector machine and validation method for it knowing plagiarism leads to automatic boot from course. I actually did throw up from stress. Three times.

Some legacy codebase that reimplements OOP with passing lots of strings and also mixes it with database crap, COM objects and other stuff mixed with interface parts to other languages. Just like most reimplementation of OOP it's not really hard to learn, but crap-tier documented and abysmal to debug, but this thing takes it to the top.

am I a brainlet if I say I had troubles with regular expressions

X86 paging. it took me 1 month to recover and i still don't fully understand it

Attached: file.png (1024x653, 56K)

Even more fun than branching recursion is mutual recusion!
data NodeT = NodeI | NodeR | NodeL | NodeLR ([NodeT], [NodeT])

foldrFst n = foldr ((:) . (,) n) []
foldrSnd n = foldr ((:) . flip (,) n) []
leftN n = foldr ((:) . (:) n) []
flatLR = foldr ((:) . pure . NodeLR) []

genComp [] = []
genComp ((a, b):xs) = foldrFst a f ++ genComp xs
where f = genNodes b

genNodes' :: Int -> Int -> [([NodeT], Int)]
genNodes' n c
| n

You might be retarded or something. Anybody with basic self-awareness can see how repeating given steps is an easier concept to understand than defining a thing relative to itself.

I think that's actually pretty intuitive once you write a recursive descent parser.

You shouldn't have to touch this shit

Communicating Sequential Processes is the right way.

The Actor Model is also decent - you won't even block on send

brainlet.

Rust is difficult only for JS cucks or Java pajeets

using libraries

here is a man of culture among plebs

How to actually write good software using FP patterns. Gotten way better at it now but it was a struggle

And of course LR parsers, jesus fuck that was hard when I learned it. Compilers in general have a lot of difficult stuff

Fuck, this site if full of literally degenerates who cosplay or impose a programmer

And I am unemployed for years in a third-world shithole

Learning how to not be a fag is near insurmountable for you

That's brainlet talk.
Come back when you know more about programming.

There is no demand to this level of knowledge (compilers). All the current market needs is JS cucks and Java pajeets.

Angular2, Docker, some fucking Java Spring or what the fucking fuck it is

I'm writing a compiler in Haskell right now so I like to think I know something. I'm still not an idiot with no self-awareness - recursion was definitely harder to grog than iteration, one is very abstract, the other is trivially intuitive.

Conceptually it's very simple, for instance depth first tree traversal is something every undergrad should intuitively understand.

Are you on the scala gitters? They're super helpful. Grokking IO and friends was a real hurdle for me too, but now I've gotten quite proficient at it. Also use fs2, it's amazing, I'm the guy with the patrick bateman portrait, feel free to ask

why, fren? try to write a parallel mergesort first

good (ironic) post user

>calling me a fag while implying that Haskell-tan isn't the cutest
It's like you're projecting your gayness onto me.

this
race conditions, semaphores, memory leaks .. fucked me real bad

>recursion
>abstract
>compared to repeated arbitrary state manipulation on an abstract machine

for me it's x86_64 alignment
thanks god I migrated to full 32-bit ARMs for low-level development

anime belongs in the trash weeb.

Attached: 1514984743324.png (789x558, 49K)