For any CS majors or just anyone who has taken the class, is this a difficult class? How bad is it as far as workload? I'm taking 12 hours next semester and I have to take a CS elective and I was thinking about taking this class, but I have heard different things about it. What was your experience with this class?
Intro to Object Oriented Programming
Intro to Object Oriented Programming
What kind of shit tier school has such a course?
Apparently my shit tier school
If it's just an intro class then it shouldn't be difficult. I've only taken a intro to C++ class and it was the easiest class I've ever taken. Good luck, user.
Thanks man, I took a programming fundamentals class that was MATLAB based and just like you said was pretty much one of the easiest class I've taken. I just don't know how this class is as far as workload.
wtf, my cs2 class only gave me a week to learn OO programming. and you get a WHOLE SEMESTER. what a joke.
what a joke lol that shit takes a few days to learn. Programming is just a common sense test anyway.
Every school, since OOP is literally all you need to know in order to be a software engineer
C fags need to fucking die. This is how the real world is
well good for you but that doesn't answer my question.
intro programming class
Yeah your school is fucking shit, and you're a brainlet
Get fucked no it didn't
It's either CS1 which it's called at every other school or it's a brainlet tier course for people to dip their toes who aren't ever gonna do programming. Probably C++ or Java. The way it was structured at my school it's like 1 program per week. Difficulty depends on how you feel about programming, but there's a lot of non-CS people who have to take it so they keep it fairly straightforward. If you go to a large school they probably have tutoring, worst case scenario.
I never used MATLAB (we used mathematica and julia), but if you wrote code in it, you'll likely do fine.
cool story but doesn't answer my question
I'm taking physics 2, thermodynamics, complex variables, and mechanics of materials. Also I don't live in my parents basement like you so I have to work to pay rent.
The thing is, I'm required to take a CS elective for my degree and literally this is the only CS course I can take that doesn't require a prerequisite such as discrete math or such.
buy a good into book and go through it. Should take a week tops if diligent, viola you are ready to ace the class. If brainlet just stop now.
cool, any good book suggestions?
object oriented programming is what you learn in a weekend. Google that shit and pass the course while practicing leetcode problems to get into google. Follow my instructions and you'll thank me.
Just google best intro to Computer science books. Find one that is free and download it unless you plan to order.
For something like computer science the classroom experience is basically shit compared to self-learning. So just look up the course and make sure you learn every concept before day 1, easy A.
Go tell it to someone who cares, brainlet
obviously you do since you've been lurking this thread
It's probably a course about OO design (design patterns and such), software evolution/architecture, OO-based testing, etc.
Whatever man, at least im not a brainlet taking 12 credit hours and being a wageslave at some minimum wage cuck job since i dont have parents who care enough to pay for my education
Fucking kill yourself faggot
At my university, I had to complete a shit load of lab assignments every week. On top of that, I also had to complete a shit load of homework assignments. On top of all of that, I also had to complete a huge project within the last few weeks of class and study for the final exam
See now this is what I have been hearing about the class, I'm not sure whether it's a good idea to take it or not.
Haha so you're trying to insult me about working my way through college? Oh you sure got me, if only my parents would help me pay for shit like my internet so I could get butthurt on a math and science thread.
OOP classes tend to come after the weed-out intro-to-CS classes, so you're expected to be comfortable with programming, and I obviously mean more than hello world and fizzbuzz and all those /g/ memes. You should be familiar with loops, arrays, control flow, mathematical operations, and all that stuff (bonus points for boolean and bitwise operations.)
You'll have to actually read the book, but the assignments, while a lot, shouldn't be that hard if you stay on top of things and actually go to class
Functions and recursion as well, obviously
An OOP class is probably not gonna use bitwise stuff, it's more about higher-level software architecture.
Yeah, I'm just saying you're less of a brainlet if you know it
Where I went to school, OOP was the final weed out class and is kind of like a bonding experience for the kids that made it through. The amount of work assigned was like nothing I have ever seen. I only took one other class and could barely keep up. We also had to use C++ to do everything, the professor had all kinds of unrealistic constraints to force everyone to get better at certain skills (not allowed to use strings, all arrays had to be dynamic, for/while loops were limited, everything had to be done recursively, etc.). Also had 2 proficiency demos that had the potential to give you an automatic F if you did poorly, no internet, no notes, just your brain with the professor standing behind you. I still have nightmares about that class but my programming skills had pretty much tripled by the end. Good luck OP, hit the ground running.
Saving that pic, but did you not take a data structures class?
everything had to be done recursively
That's just retarded though? If you're going to avoid loops in C++, you should at least be using stuff in <algorithm> such as std::find_if, std::max_element, std::for_each, std::accumulate, std::transofrm, etc.
all arrays had to be dynamic
This is also pants-on-head retard. Dynamic array allocation is generally not very good practice as it's slow (syscall overhead, etc). Plus if you want dynamic, you should be using the STL anwyay (ie std:vector - or in future standards, std::dynarray). If you're not taking advantage of one of the biggest benefits of writing C++: RAII. You're going to have to write more code, have that code be more likely to be error-prone, plus possibly even give the compiler less to work with (since you've got arbitrary instructions vs things it knows more about)
Recursion/etc has little to do with OOP, so I don't know why they would put that constraint in there
I bet you guys had raw new/delete everywhere and the code was fucking atrocious.
If you're writing C++ and using new/delete, you're probably doing it wrong (outside of certain areas).
Did I fall for a bait post meant to trigger C++ programmers?
Or was this a course on how to write terrible pajeet-tier C++?
Probably taught by a professor that hasn't had a single day in industry and writes C++ as if it were C with classes, or writes it as if it were Java with delete...
C with classes
That's what it's supposed to fucking be you mong
yes, you had to complete data structures before oop, it was weed out part 1
I take it you've never actually extensively used C++? Or maybe you're misinterpreting what I meant by it. What I meant was writing it like C except you put everything in classes without using templates, RAII, etc and just write it like a God-awful hybrid of C + Java, heap-allocating everything. Or writing it like C but then just giving structs methods.
well, the thing is, it all depends on the structuring of your course. 3 ECTS credits are 90 work hours officially - most people put in probably 40-55.
So if you do a 3 credit module full time, you take barely over a week to go through it.
wait, that's all basic as fuck.
Not bait, it was generally insane trying to solve these problems. I had no prior programming experience so it was all just more of the same to me. The professor constantly reminded us that the purpose of the weird rules was to get extra practice with this stuff before moving on to upper division.
The purpose of dynamic arrays was constant practice with using new/delete. It was painful at first, but the point was to manage memory inside the constructors/destructor of a class instead of having new/delete all over.
Recursion was something that kids tended to struggle with later on. Overuse of recursion in this class got everyone comfortable with the concept of doing work on the way down then on the way back, and pass by value vs reference for this scenario. But you are definitely right that it has nothing to do with OOP, just an extra weed out concept.
The professor was actually decent, everyone that finished weren't ready to write industry level c++, but did have a solid foundation to learn future cs topics more easily, and everyone is extremely comfortable with arrays, pointers, etc. by the time they are done.
The purpose of dynamic arrays was constant practice with using new/delete
Why are they teaching you to use new/delete? You should almost ever ever be using those in idiomatic modern C++. Did you take this course in the 1990s? Use smart pointers, my dude. Even pre-move-semantics, shared_ptr and auto_ptr are great, although unique_ptr is far better.
I agree they should be taught about new/delete/etc - but they should be taught not to use them and do avoid heap-allocation whenever possible.
The course as you described it needs a serious part after it where you are forced to use STL, smart pointers, etc, as well as sharply punished for abusing heap-allocation, etc. That way they see how much better it is to not do manual memory-clean-up and instead use containers/smart pointers/move semantics/etc to have it be handled for them.
Not doing so is doing a massive disservice fo any of them applying to C++ internships.
Recursion was something that kids tended to struggle with later on
How exactly did they pass data structures before this?
Then you should be okay
If you can't use free/delete properly you're a brainlet programmer and the reason why modern HLLs are cancer
That is not the class to teach it in though. Why not a comp arch or such class where you learn ASM + C + the hardware. Or in an OS class with C/etc? Sure, you should teach new/delete, but you should advise against them and should teach alternatives.
Even when using smart pointers you still need to be aware of memory allocation. Additionally it helps to motivate stuff like move semantics as well.