← Home ← Back to /g/

Thread 106192873

331 posts 52 images /g/
Anonymous No.106192873 >>106192956 >>106193009 >>106193364 >>106193619 >>106194946 >>106196057 >>106196953 >>106198086 >>106198338 >>106199189 >>106199351 >>106199823 >>106200254 >>106200259 >>106200364 >>106200482 >>106200548 >>106201616 >>106204034 >>106205845 >>106206964 >>106209727 >>106210785 >>106210823 >>106211070 >>106211343 >>106211662 >>106212356 >>106216918 >>106220125 >>106221482 >>106226672
This is the best general purpose language and anyone who disagrees is either a jobless street shitting Gojeet or a tinkering Haskelltranny.
Anonymous No.106192930
what about cniles who jerk off to themselves whenever they write malloc thinking its some testament to their genius
Anonymous No.106192956 >>106192977 >>106193116 >>106198179 >>106206681
>>106192873 (OP)
Its pretty bad. Also, because its so bad, LLMs are bad at using it. It actually might be the worst language for AIs to code in. I actually think this fact alone means its days are numbered.
Anonymous No.106192977
>>106192956
at least it will be a lot easier sniffing out vibecoded slop written by jeets vs high quality code written by white men
Anonymous No.106193009 >>106193115 >>106196184
>>106192873 (OP)
I like Kotlin a little more.
Anonymous No.106193071 >>106198162 >>106210077 >>106215912 >>106220132
There is no good reason not to use inheritance. A Dog does not have an Animal, a Dog IS an Animal. Whichever Israeli cnile started peddling this composition over inheritance bullshit is a PIMPL pushing boomer tranny.
Anonymous No.106193115 >>106196341
>>106193009
what does kotlin offer over java?
Anonymous No.106193116 >>106193709
>>106192956
This makes zero sense to me, it's one of the most widely used languages, surely the amount of training data available on it is IMMENSE, there's zero reason for AI to be bad at java.
Anonymous No.106193141
ABYSMAL DOGSHIT language, never post again
Anonymous No.106193364 >>106193497 >>106193702
>>106192873 (OP)
that isn't C#
Anonymous No.106193497 >>106193510 >>106207419
>>106193364
microjeet benchod
Anonymous No.106193510 >>106194844
>>106193497
MODI MADARCHOD!
MODI MADARCHOD!
Anonymous No.106193587
I only use it to mod minecraft, I should probably do something else with it

It is the first prolang I learned and I really hated it at first because it is very verbose, CL is more logical and elegant imo but java has its uses (modding minecraft)
Anonymous No.106193619 >>106200348
>>106192873 (OP)
Assembly or go home
Anonymous No.106193702 >>106207419
>>106193364
fuck Microsoft
Anonymous No.106193709
>>106193116
It's only bad at it of you're bad at it lmao
Same goes for probably any lang
Anonymous No.106193952 >>106200494
c++ evolves at a snails pace so java is your only bet now
Anonymous No.106194844
>>106193510
weapon of Durga saar
Anonymous No.106194946 >>106195210 >>106200625 >>106221491
>>106192873 (OP)
The language itself isn't bad (though I miss multiple inheritance every time I use it). The problems are the standard library and Oracle.
Anonymous No.106195210 >>106195248 >>106198086 >>106198195
>>106194946
What's wrong with the standard library? It has everything you can ask for, except maybe Expected types.
Also it would be nice if Java supported virtual inheritance for extending multiple classes, or even just multiple inheritance of abstract classes too.
Anonymous No.106195248 >>106195387
>>106195210
virtually all use cases for multiple inheritance can be resolved either by implementing multiple interfaces, or applying composition over inheritance
Anonymous No.106195387 >>106195570
>>106195248
>composition over inheritance
that just brings us back to the problem of the derived class owning two copies of the grandparent class
Anonymous No.106195570 >>106195668
>>106195387
give a realistic example of your problem
Anonymous No.106195668 >>106195752 >>106198899
>>106195570
// With multiple inheritance:
class W {}
class X extends W {}
class Y extends W {}

class Z extends X, Y {}
// With virtual inheritance, Z has only one copy of W

// Using composition over inheritance:
class W {}
class X {
W w;
}
class Y {
W w;
}
class Z {
X x; // one copy of W
Y y; // another copy of W
}
// Even replacing these with pointers is impractical for most actual operations such as construction.
Anonymous No.106195752 >>106196029
>>106195668
>ask for realistic example
>class W, X, Y, Z
your example has no meaning, not even going to bother to read it
Anonymous No.106196029 >>106196235 >>106198444
>>106195752
Sorry, are you that much of an ESL pajeet to make the substitutions yourself? Does it comfort you to replace W with Animal, X with Mammal, Y with Land, and Z with Bear or Human or whatever? Fucking retard, kill your self.
Anonymous No.106196057 >>106196142 >>106196207
>>106192873 (OP)
Java is the most jeeted language, kill yourself.
Anonymous No.106196142 >>106196192 >>106196207
>>106196057
go sucks
Anonymous No.106196166 >>106196207
but no one brought up go
Anonymous No.106196184 >>106197852
>>106193009
Kotlin is just Java with common gripes addressed. Literally. You can use both in the same project at the same time.
Anonymous No.106196192 >>106196207
>>106196142
kill yourself
Anonymous No.106196207 >>106196266
>>106196057
>>106196166
>>106196142
>>106196192
Yes, Java is the most jeeted language, but Go is 90% zoomie vibe niggers and trannies.
Anonymous No.106196235
>>106196029
if you use multiple inheritance to share code, stop using inheritance to share code and just make some functions. if you want to use multiple inheritance to not have to declare the same set of fields multiple times, realize that the complexity is not worth copy pasting the fields, if you are missing some, your program won't work so you'll know at compile time anyway
Anonymous No.106196266
>>106196207
You can't vibe nigger trannymaxx in Go due to severe lack of reactive streams, ORMs and similar dogshit
Anonymous No.106196341 >>106196937 >>106199632
>>106193115
>what does kotlin offer over java?
It offers Java 8 features on Android which is forever stuck at Java 7. Both of which are obsolete, given that Java is rolling out version 24 next month.
Anonymous No.106196937
>>106196341
Is any place still doing native Android dev anymore? Feels like that's all gone for web apps and flutter now.
Anonymous No.106196953 >>106197942 >>106206735
>>106192873 (OP)
The troons left for Rust.
Come home, white man.
Anonymous No.106197852
>>106196184
I prefer Java/C++ syntax over Kotlin syntax. Why did they have to come up with some gay nulang syntax?
Anonymous No.106197942 >>106204056
>>106196953
I will admit Haskell is pretty neat to program in.
And I am not a tranny.
But I honestly really like Rust, it feels a lot more ergonomic than C++ coming from all my experience in C++.
Plus Rust just uses modules out of the box, C++ has pathetic support for modules which were added 5 whole years ago.
Anonymous No.106197961 >>106200633 >>106213948 >>106214167
why so much hatred for go
sure it has gay syntax and the error handling is obtuse for no good reason but is it really that awful
for one i think goroutines are pretty neat even though i think virtual threads from java are just as good
Anonymous No.106198086 >>106198195
>>106192873 (OP)
Just force your users to install JVM

>>106195210
Weird obscure concurrency issues in the GUI libraries.
Anonymous No.106198162
>>106193071
a dog has animal traits
Anonymous No.106198179 >>106214672 >>106229812
>>106192956
Public LLMs are only good at Python, Bash, Javascript and sometimes Powershell and VBA. Their Go solutions refuse to use modern features unkess explicitly pointed at and sometimes allucinate APIs.
Anonymous No.106198195 >>106201495
>>106195210
No built-in JSON parser, even a simple one in 2025. Lots of legacy cruft with this >>106198086
Anonymous No.106198338
>>106192873 (OP)
>anyone who disagrees is either a jobless street shitting
Why do you hate your primary userbase, Rohit Durgasoft?
Anonymous No.106198444
>>106196029
>ad hominem
no argument

>replace W with Animal, X with Mammal, Y with Land, and Z with Bear or Human
that is more meaningless nonsense

apply your problem pattern to a realistic scenario: save something to a file, transform some text or data structure - anything that, if not actual real code used in a real program, at least looks like it could be
Anonymous No.106198491
When I got my CS degree we alsmost exclusively used java and I havent used that shit once and I graduated back in 2017. C++ and python are the only relevant languages for me.

Maybe C, but that is just because there seem to be alot of fucktards who think C is faster than C++
Anonymous No.106198579
SIX
TRILLION
DEVICES
Anonymous No.106198762 >>106198891 >>106198945 >>106198975 >>106199002 >>106202934 >>106204086 >>106216017
>Best general programming language
No that would be python. Java is the final step in the OOP experiment to see what would happen if the theory was built into a full blown language and the result is just retard abstraction for abstractions sake. OOP has always been a failed code reuse scheme that was solved with generic programming. The whole pattern thing was just gold spray paint to cover up the shit. I have never once seen a factory class ever make sense for the problem it was trying to solve. Java is a giant meme and the only thing that java got right was the JIT and java byte code making it so you didn't have to compile for every target or deal with too much platform specific bullshit.
Anonymous No.106198891 >>106198923
>>106198762
t. filtered by OOP
Anonymous No.106198899
>>106195668
>Impractical
Lol, the problem with this example is the assumption that X and Y don't start growing apart. What if class X and class Y both create different implementations for the same function. Which function does Z get? What happens if X bloats in size, but Z doesn't really need all those extra fields? The whole problem with inheritance is assuming programmers can model the problem to fit with the OOP paradigm. Composition solves this issue.
>But what about multiple versions of W?
You create and initialize a pointer to W in the parent and you pass it to the children who will have a constructor that includes a pointer to W. If it isn't nullptr you just set their pointer to what was passed in the constructor.
Anonymous No.106198923 >>106202933
>>106198891
>Filtered
I have used and had jobs in OOP languages. It just sucks and you'll realize that most people who write OOP for a long time avoid a ton of OOP features because they create more problems then their worth.
Anonymous No.106198945 >>106199037 >>106204109
>>106198762

IM taking the bait.

Objects in OOP is a great way to think when you need to track a mutable state. It is abstraction for abstractions sake when you completely think in OOP terms before considering the actual application. Factory classes are useful for deserialization.

You can code everything functionally for sure, but if you want to maintain code readability you'll find yourself grouping together functions in a way that mimics OOP.
Anonymous No.106198962 >>106198990
IM GONNA OOOOOOOOP

i intermingle procedural and oop and create spaghetti abominations with java

call the cops i dont give a fuck. muhhhhhh paradigm fuck off retards
Anonymous No.106198975 >>106198982 >>106199023
>>106198762
OOP is generic programming. foo(IBar bar) is the same as foo(T bar) where T : IBar

template generics are just limited codegen hack.
Anonymous No.106198982
>>106198975
just put . is for losers
Anonymous No.106198990
>>106198962
based
Anonymous No.106199002
>>106198762
Generics didn't solve reusable software either (it isn't "solvable" but generics are certainly better than OOP at getting closer on target) but otherwise you're 100% right. The adage "Design patterns are a feature request against the language" is absolutely true.
Anonymous No.106199023
>>106198975
Generics allow interface implementation to be implicit rather than explicit. If you can't see the value in that I'm not sure what to tell you. You might be too far gone.
Anonymous No.106199037 >>106199054 >>106199079 >>106199128 >>106202995 >>106209635 >>106209719
>>106198945
>Functional
I prefer procedural programming. The problem with OOP is it tacked on problems to procedural programming that didn't need to exists. Inheritance is just a poor way to program. Interfaces kind of fixed some of the issues with it, but it still incurs a price. My big issue with OOP is it encourages modeling a problem before you really understand it. Procedural is more write as you go and draft which saves you from a ton of wasted time with premature optimization or poorly constructed abstractions.
Anonymous No.106199054
>>106199037
I definitely agree. All the code I write that actually accomplishes anything and isn't just wrangling the retarded compiler is procedural.
Anonymous No.106199079 >>106199153 >>106199162
>>106199037
The problem occurs when the codebase gets big and everyone needs to make sense of the mess. That is where a well designed OOP codebase really shines.

Honestly I think the best way is to just code whatever spaghetti you feel like with the intention of completely rewriting everything when you have an initial prototype done and have a better idea of what is actually needed. Committing to anything up front just means you are just going to make the inevitable refactor more painful than it needs to be.
Anonymous No.106199128 >>106199162
>>106199037
>OOP is it encourages modeling a problem before you really understand it
The whole purpose of OOP is trying to parallelise dev work which is a real problem when you're trying to build as fast as possible.
This is why it's about drawing diagrams to divide up into tickets, avoiding dependencies and creating permissions.
It's a business problem with a code solution.
Anonymous No.106199153 >>106199253
>>106199079
>Well designed
Then what is actually making comprehension easy, the OOP or the good architecture? There are tons of ways to architect procedural programs that make it easy for other programmers to understand what is happening. I would argue Linux is a perfect example of a well designed procedural program.
>Not committing is best at the beginning
Sure, but I think procedural programming makes it easier to not be so committed. OOP is naturally asking these questions of how everything has to relate and what pulling focus on things like the specifics of is good practice for a class to have. The nice thing about procedural programming is that structured data is just allowed to be data. It doesn't come with the baggage of OOP. One of my personal pet peeves is that constructors are assumed to succeed and force you to wrap construction in a try catch block just to be safe.
Anonymous No.106199162
>>106199079
>>106199128
Anonymous No.106199189 >>106201600
>>106192873 (OP)
Yeah, Java was my first language and the language I feel most comfortable writing in, I've tried, python, JS/TS and some C++ and I always just prefer Java it always strikes me as a good middle ground and it has a lot of good libraries. I just wish it had a good UI library if I ever need UI stuff its easier to just write a web-ui using another language. Java FX is hard work.
Anonymous No.106199253 >>106199308 >>106200651
>>106199153
I dunno if I would call is well designed, just well documented. I would say something is well designed when you can quickly write something of value without full understanding of what is even going on under the hood.

As for the constructor failure issue, that is why the initialization pattern exists. Personally I dont like putting a ton of complicated stuff in the constructor anyway. I think of constructors as a handle for memory allocation. If there is something that can fail then it goes into an init function. This is similar to what you would do when you are coding without objects anyway.
Anonymous No.106199308 >>106199359 >>106204698
>>106199253
>Write something of value without understanding everything.
I think this is achievable in procedural, I would say the only difficult part would be not having modifiers to protect struct members.
>View it like a malloc
Sure, but even that can still fail. You still just end up wrapping the allocation and initialization in a try catch if you don't want issues. I still like errors as return types over exceptions. If you have a return variable you can handle allocation and initialize in one function without issue.
Anonymous No.106199351
>>106192873 (OP)
bait thread
Anonymous No.106199359
>>106199308
I think at that point it is just you wanting to stick to a specific style, which is fine
Anonymous No.106199632
>>106196341
What?
Anonymous No.106199823 >>106199979
>>106192873 (OP)
where to start learning java for backend/web?
Anonymous No.106199979
>>106199823
chatgpt
claude
gemini
etc

bounce between them and do a project you will find personal use for
Anonymous No.106200254 >>106200287 >>106200309 >>106200311 >>106201532
>>106192873 (OP)
>*blocks your way*

C# is superior in every way and I will keep shilling it as long as this piece of shit called Java exists.
Just the build system itself is the reason to use C# over Java and the bullshit that is Maven or Gradle.
Anonymous No.106200259
>>106192873 (OP)
I quite like Java. It is what we were forced to learn at school. It is comfy in the same way that eating Dinosaur nuggets is.
However, for small projects I would rather use Nim.
Anonymous No.106200287
>>106200254
Just the build system itself is the reason NOT to use C#
Anonymous No.106200309
>>106200254
you dont have to use maven or gradle you know

i use powershell
Anonymous No.106200311 >>106200466
>>106200254
the problem with .NET is that its career suicide.
if you look at "cool" tech companies (which include but are not limited to FAANG), not a single one of them will hire for .NET
their stacks are always Python, golang, Java, Kotlin.
but yeah it utterly mogs Java from a technical standpoint.
Anonymous No.106200348 >>106200433 >>106201474
>>106193619
Post code Ivan
Anonymous No.106200364
>>106192873 (OP)
C++ is better imo but Java has it's use cases.
Anonymous No.106200433
>>106200348
Post social security number Mykola
Anonymous No.106200466 >>106200654 >>106208214
>>106200311
>FAANG
Are you american by any chance? Why is everyone only chasing after the slim chance of making it to FAANG? I've been a .net dev for a few years and from my knowledge the biggest e-commerce companies, some banks and insurance companies in my country use .net in their backend and internal apps at least in some capacity, and not just for legacy apps, we're developing in .net core 8.
If I know C#, js, typescript, React/NextJS and SQL I already have a career potential, sure knowing Java or Kotlin (absolutely awesome, compared to Java) is a bonus, but focusing on C# is a possibility for me too.

>captcha AWARD2
Anonymous No.106200482 >>106201558 >>106204515
>>106192873 (OP)
It's a really good solid language. I just hate the tooling. Why can't I use a makefile and produce linkable libraries like a sane human.
Anonymous No.106200494 >>106201532
>>106193952
>evolves
What needs to evolve?
What do you need?
Anonymous No.106200548
>>106192873 (OP)
Dalit language
Anonymous No.106200625 >>106204021
>>106194946
The only language to get multiple inheritance right is Common Lisp.
Anonymous No.106200633
>>106197961
>is it really that awful
Yes, it really is that awful. Sorry you had to find out this way.
Anonymous No.106200651
>>106199253
>initialization pattern
patterns are cope for a shitty language
Anonymous No.106200654 >>106208214
>>106200466
>Why is everyone only chasing after the slim chance of making it to FAANG?
im not talking exclusively about FAANG, FAANG is just one example of "cool" companies (for lack of a better word). a few non-FAANG examples might be Dropbox, GitLab and companies like this.
yeah i was a bit overdramatic obviously you'll always have jobs and progress with your career with .NET but it's going to be in enterprise-y companies. Java doesnt (necessarily) have this problem.
it's like there is some kind of prejudice against .NET outside of the enterprise world, you know what i mean?
Anonymous No.106201474
>>106200348
dont make me report you to TЦК for draft dodging
Anonymous No.106201495 >>106204720
>>106198195
import jakarta.json.*;

Problem solved (though I wish they kept the namespace as javax).
Anonymous No.106201532
>>106200254
There is literally nothing wrong with Gradle. Coming from CMake Gradle is a godsend. Sadly Gradle for C++ doesn't support modules, but perhaps in due time it will. Also heard good things about XMake but it breaks a lot in my experience.

>>106200494
I want a batteries included language and more ergonomic syntax.
C++ still has no std::net or std::process library and that's ridiculous.
Anonymous No.106201558
>>106200482
Use GraalVM.
I think GNU Compiler for Java also used to compile Java to native code but it ceased development sadly.
Anonymous No.106201600
>>106199189
personally if c++ had the same extensive standard library as java and a better toolchain and ecosystem like java i would prefer it
theres so much i hate about c++ about how poorly std classes and the standard library itself are designed
Anonymous No.106201616 >>106201623 >>106202042
>>106192873 (OP)
nobody sitting on /g/ arguing about languages has a job anon, that includes you...
Anonymous No.106201623
>>106201616
i work using .NET actually saar
Anonymous No.106201819 >>106202454
I've always found Java really easy to read compared to other languages.
Anonymous No.106202042
>>106201616
While my work compiles, I come here to bully retards.
Anonymous No.106202199 >>106202207
how do i get into enterprise java?
Anonymous No.106202207
>>106202199
You kill yourself, then kill yourself, kill yourself and finally kill yourself
Anonymous No.106202454 >>106202758
>>106201819
Java self documents, verbosity is not necessarily a bad thing.
Java self-documents whereas Go just throws your head for a spin.
>if err != nil after every function call
Anonymous No.106202758 >>106202767
>>106202454
>digs through 10 classes and 1000 private methods to find a single for loop of business logic
Anonymous No.106202767 >>106202881
>>106202758
whats your amazingly engineered go solution then saar
Anonymous No.106202881 >>106203453
>>106202767
>checking return codes is... is *le bad*
do not redeem procedural SAAR
Anonymous No.106202933
>>106198923
not in my experience
people don't purposefully avoid OOP. rather, they have learned procedural programming good enough to finish tasks but have really half-assed knowledge and little to no experience with OOP, so they just write their code procedurally (contrary to many comments, Java isn't all that strict with OOP)

also OOP is something that just clicks with you over time. for the first two years with a Java job, my code also was mostly procedural, until said "click" happened
Anonymous No.106202934
>>106198762
>Java is the final step in the OOP experiment
Java has a shitty OOP implementation when compared to Smalltalk or Common Lisp.
also, the JVM is pretty damn good. I like to use it via Clojure
Anonymous No.106202995
>>106199037
>The problem with OOP is it tacked on problems to procedural programming that didn't need to exists
this is at least how OOP is usually taught
it's wrong and results in people shitting on OOP without using or understanding it

>Procedural is more write as you go and draft which saves you from a ton of wasted time with premature optimization or poorly constructed abstractions.
premature optimizations are usually a result of such 'write as you go' approach, when such optimization is written without considering the implementation will need to be expanded
poorly constructed abstractions are something that will happen in any paradigm and is a general skill issue
Anonymous No.106203453 >>106206665
>>106202881
try catch is superior and less retarded and literally free
Anonymous No.106204021 >>106204045
>>106200625
>The only language to get everything right is Common Lisp.

Fixed that for you
Anonymous No.106204034 >>106204060 >>106205829
>>106192873 (OP)
>This is the best general purpose language

Durga Solutions called, Harpreet, they will deposit you the 5000 rupees they promised soon.
Anonymous No.106204045
>>106204021
>can't programmatically access callstack/defined symbols
Smalltalk allows this btw
Anonymous No.106204056 >>106204067 >>106204421
>>106197942
>>knows haskell, prefers rust

You're a tranny then
Anonymous No.106204060
>>106204034
>ackshually you are the pajeet
nice try rajesh
Anonymous No.106204067
>>106204056
>what is lack of a GC and first class mutable data structures
I program in Clojure most of the time, but if I'm trying to go as fast as fucking possible, you bet your ass I'm writing Rust.
Anonymous No.106204086 >>106205235
>>106198762
>I am a kid and only know Python>

top kek
Anonymous No.106204109
>>106198945
>i am a dimwit that thinks namespaces and packages is the same as OOP
Anonymous No.106204421 >>106204587
>>106204056
C++ is designed by a gay nigger and his gang of gay niggers.
Anonymous No.106204515
>>106200482
You can actually use makefiles for Java, it was the standard before Ant (and Maven and Gradle).
A jar is a zipfile with the compiled classes and the manifest.
Anonymous No.106204587 >>106204938 >>106206771
>>106204421
>C++ is designed by a gay nigger and his gang of gay niggers.

Was I mentioning C++? Nobody cares about C++.
Anonymous No.106204698 >>106205235
>>106199308
>If you have a return variable you can handle allocation and initialize in one function without issue.
what do you do when allocation fails? usually you'll stop the program anyway, so why not let the exception mechanism do it for you?
Anonymous No.106204720 >>106205223
>>106201495
that's not in the standard library. but a json implementation in the jdk is in the works (but probably blocked on valhalla)
Anonymous No.106204938
>>106204587
Because Rust solves all of the gay nigger problems of C++, retard.
Anonymous No.106205223
>>106204720
What does Valhalla actually add? Just generics over primitives?
Anonymous No.106205235 >>106205797 >>106209566
>>106204086
>Python is just for kids
Python is the most used programming language. You are confusing optimization with general purpose. C/C++ are not general purpose languages because using them like that actually takes a ton of time and skill. Python you just import a library and write a small script for what you need to do.
>>106204698
>What will you do when allocation fails
If it fails it means you have a ton of existing allocations. If there are a ton then you can assume that some of them are stale and free them in order to make space for future allocations solving the out of memory issue. If you think about it even 8GB of ram is a ton of memory and unless the user has a ton of shit open they shouldn't expend all of it. If they have it implies that either you or someone else is being too greedy with memory allocation.
Anonymous No.106205797
>>106205235
For me, it's JBang.
Anonymous No.106205829
>>106204034
James Gosling is white.
Sun Microsystems is white.
Oracle is Jewish and Durga is Pajeet.
Just because Jews took over Java and Pajeets think they know how to use it when they don't, does not make Java a Pajeet language, it makes you the Pajeet.
Anonymous No.106205845
>>106192873 (OP)
is this 20 years ago?
Anonymous No.106206245 >>106208131
i'm learning Java because my company uses salesforce and I am a ~BI Analyst~ there who maybe one day will do Salesforce developing, then transfering my Java knowledge to Apex. If this fails, at least I'll have learned Java.
Rate my plan, anons.
Anonymous No.106206665
>>106203453
>literally free
is it? what do you mean by free? no overhead?
Anonymous No.106206681 >>106208217
>>106192956
Java is the easiest language to code in. If you need AI to help you, then you have some other problems to worry about.
Anonymous No.106206735
>>106196953
I am a straight white man, with kids. Every other person coding rust out there that I've met is a white man. Literally every single fucking one. I am yet to find a troon in the space. I do not hang out in the discord and don't need to. Its just an excellent language in general. I still find odd uses for C++/C but 98% of my code is now just pure rust. That's from high level apps like REST servers to windows services running named pipes and shared buffers between apps.

Syntax is sane. Although verbose, but what system lang isn't?
Tooling is from the future.
Crate for virtually anything, for free.
Compilation is slow, but try LLD.

I am home.
Anonymous No.106206771
>>106204587
Trauma from using that pile of shit. I understand.
Anonymous No.106206964 >>106207226
>>106192873 (OP)
I asked Grok3 how to built a website for LLM use instead of human use. It said remove javascript because it and all other LLM cannot read javascripted chunks hosted on websites and it is annoyed at this because sometimes the html header tag suggests the information the LLM wants is inside the javascript that it can't read.
Anonymous No.106207226
>>106206964
java != javascript

also grok is gaslighting you, llms can read code
Anonymous No.106207326 >>106208417
What do we think about Graal, sirs?
Anonymous No.106207419
>>106193702
>>106193497
use mono retards
Anonymous No.106208131 >>106208158
>>106206245
What the hell does that mean? You are a bisexual?
Anonymous No.106208158
>>106208131
no, I'm a BI analyst, which means that I analyze faggots like you, dumb retard
Anonymous No.106208214
>>106200466
>>106200654
I'm glad I managed to escape this bulshit system, not giving a shit about what x or y company uses on their tech stack is the best experience you can have.
Anonymous No.106208217
>>106206681
>Java is the easiest language to code in because the only other language I know besides Java is C
Anonymous No.106208222 >>106208240 >>106208342
Faster than python but useless for low level
Obsolete
Anonymous No.106208240
>>106208222
>low level
nobody cares
Anonymous No.106208342
>>106208222
If it's obsolete then why is one of the best games ever made (Starsector) written in java?
Anonymous No.106208417
>>106207326
Aryan o algo
Anonymous No.106208873 >>106209276
Three billion devices
Anonymous No.106209276 >>106213907
>>106208873
How did they calculate this number?
Anonymous No.106209566
>>106205235
>free them in order to make space
if you try this is in practice, you'll notice that you will have to keep a global pool of all allocations around (allocation can fail anywhere, e.g. while deep inside your business logic). you will also have to code any usage defensively, because code from anywhere can just free them because they ran into allocation failure. a garbage collector does this for you, i.e. collect no longer referenced memory if allocation would fail. if you reimplement a second layer of garbage collection like this, half of your program will consist of code dealing with memory management edge cases. Java has weak references for this, i.e. you can mark references the garbage collector is free to collect if memory is tight. you still need to check at use site of course, but you don't litter your code with memory management concerns (im a language that manages memory anyway)
Anonymous No.106209635 >>106209719
>>106199037
>My big issue with OOP is it encourages modeling a problem before you really understand it.
yes. write the code that transforms the data then with your new understanding restructure the code. optionally, move some functions into namespaces / classes to make them individually testable. oop wants you to design bottom up, which always leads to worse solutions but is unavoidable when developing over many teams (need to parallelize work). but if you have control over all the code involved? top down, always
Anonymous No.106209719 >>106209742 >>106210636 >>106210735
>>106199037
>>106209635
>My big issue with OOP is it encourages modeling a problem before you really understand it.
how do you people even arrive at this conclusion?
is all your experience with OOP from a high-school class?

one of the main advantages of OOP over procedural is that it's easier to refactor code when requirements change (or even just understanding of them)
Anonymous No.106209727
>>106192873 (OP)
Ever tried to run it without a wrapper? C#'s a better general purpose language.
Anonymous No.106209742 >>106210582
>>106209719
>it's easier to refactor code when requirements change
do you have an example? all i ever see is premature abstraction (e.g. creating a common interface for two operations because surely all future requirements will fit into this model, yikes they didn't, cut corner or refactor? jam it into the interface it is)
Anonymous No.106210077 >>106210167
>>106193071
CS might be unique in a sense that it's easiest to disregard any kind of field accumulated knowledge
Anonymous No.106210167 >>106210226
>>106210077
Tell that to C++.
Anonymous No.106210226 >>106210271
>>106210167
what about c++?
Anonymous No.106210271
>>106210226
It's bloated to hell and back because they refuse to disregard anything.
Anonymous No.106210582 >>106211062 >>106213467 >>106213467 >>106227938
>>106209742
>do you have an example?
consider this object-oriented fizzbuzz where everything is separated into interfaces:
List values = new FizzBuzz()
.setDefaultOutput(new InputNumber())
.addRule(new DivisibleBy(3), new Text("Fizz"))
.addRule(new DivisibleBy(5), new Text("Buzz"))
.fizzBuzz(1, 100);


if I were to add a new rule where for each number that is prime appended the cardinal number (ie. spelled out, not digits), I would only need to implement a new Condition, a new Output and add a rule when fizzBuzz is executed (don't need to modify or even read fizzBuzz itself):
List values = new FizzBuzz()
.setDefaultOutput(new InputNumber())
.addRule(new DivisibleBy(3), new Text("Fizz"))
.addRule(new DivisibleBy(5), new Text("Buzz"))
.addRule(new IsPrime(), new CardinalNumber())
.fizzBuzz(1, 100);


if I were to change how the DivisibleBy condition works, or how some Output implementation works, I only need to modify that one small class and still not touch or read the FizzBuzz class or other classes
if I were to add some fundamental change how FizzBuzz worked (eg. add an option for a rule to override/ignore previous rules), I would only need to modify addRule() and fizzBuzz() methods of the FizzBuzz class without having to touch any of the Conditions or Outputs

before you try to make a point about premature abstraction: consider each of the interfaces were extracted only after it was needed to extend the functionality. you only see it already extracted because of length limits on posts

>all i ever see is premature abstraction (e.g. creating a common interface for two operations because surely all future requirements will fit into this model, yikes they didn't, cut corner or refactor? jam it into the interface it is)
can you in turn give an example of a scenario of that happening? your example doesn't make much sense to me
Anonymous No.106210636 >>106211022
>>106209719
>one of the main advantages of OOP over procedural is that it's easier to refactor code
how do you people even arrive at this conclusion?
is all your experience with OOP from a high-school class?
Anonymous No.106210735 >>106211022
>>106209719
>is all your experience with OOP from a high-school class?
unironically yes. Although not as much as functional paradigm does OOP requires a dedicated book/source to understand its true strength and core principles. Im glad I read OOSC2 becuase I know I would be stuck in procedural brainrot forever thinking it's the most rationale choice. also not helping that it's trend to shit on OOP nowadays
Anonymous No.106210785
>>106192873 (OP)
Java is the 2nd most used language in India, after Python. It's even more popular then Javascript lollll. This language is brown, very brown.
Anonymous No.106210823 >>106210976 >>106211252
>>106192873 (OP)
It used to be that if you used Java, you were a pajeet. Now, not using Java makes you a pajeet. Are we all just inevitably going to become Indian?
Anonymous No.106210976
>>106210823
The obvious conclusion is that 4chan should range ban India and Canada on all boards
Anonymous No.106211022 >>106211103 >>106211638
>>106210735
>OOP requires a dedicated book/source to understand its true strength and core principles
I don't believe so; OOP mostly requires hands-on experience to really "get it"
a book can only give you theory, which if you apply incorrectly (might be bad implementation, or maybe poor explanation by the book, or maybe just applied to an unfitting use case), you might arrive to the conclusion that the whole paradigm is bad

>>106210636
>how do you people even arrive at this conclusion?
by having a job
>is all your experience with OOP from a high-school class?
school experience is mostly detrimental to understanding OOP
Anonymous No.106211062 >>106211233
>>106210582
>can you in turn give an example of a scenario of that happening?
sure, take your fizzbuzz example. new requirement: on encountering the first perfect square, stop fizz buzz and continue the program
Anonymous No.106211070
>>106192873 (OP)
Too bloated
Anonymous No.106211103 >>106211222
>>106211022
>school experience is mostly detrimental to understanding OOP
Yes, over the years I've noticed how programmers entering the workforce immediately discard the core fundamentals of OOP they've just learned in college, start using classes as packages, avoid inheritance like a plague and do FP instead.
Anonymous No.106211222 >>106211233 >>106211328
>>106211103
List values = new FizzBuzz()
.setDefaultOutput(new InputNumber())
.addRule(new DivisibleBy(3), new Text("Fizz"))
.addRule(new DivisibleBy(5), new Text("Buzz"))
.addRule(new IsPrime(), new CardinalNumber())
.addBreakCondition(new PerfectSquare()) // a new method
.fizzBuzz(1, 100); // modified with one additional if-condition and break
Anonymous No.106211233
>>106211222
oops, replied to wrong post - meant for >>106211062
Anonymous No.106211250
Java and C# are too slow for serious work. Toy langs that are only popular because middle managers thought they could get devs to make classes they could build once and slot together for future problems and then remove developers from the equation once enough of these classes were built. It didn't work and now we are left dealing with the consequences of OOP (aka slow and shit code).
Anonymous No.106211252 >>106211267
>>106210823
Nowadays Go and TypeScript or any Electronslop are the Indian languages.
Anonymous No.106211267 >>106211284
>>106211252
Go isn't popular in India though. Java, Python, Javascript and C# top the chart in India in terms of lang popularity.
Anonymous No.106211284 >>106211290 >>106211372
>>106211267
It was made for Indians to prevent them from fucking up codebases at Google. It is basically a language designed to be jeetproof.
Anonymous No.106211290
>>106211284
You play lose and fast with the truth. Pike didn't once mention he made go for Indians. The popularity of langs in India are easily found with a Google search. Java is #1.
Anonymous No.106211328 >>106211532
>>106211222
so in addition to the if and break you had to add another interface, another class, another method and another field because the existing rule abstraction did not anticipate the future correctly?
Anonymous No.106211343
>>106192873 (OP)
>a tinkering Haskelltranny
haskell fan here, where can I find one? I thought rust monopolized all the fine t-booty
Anonymous No.106211372
>>106211284
I don't even think this is true. Once I saw the only memory order offered by Golang Atomics was seqcst, I just assume the language is designed by lazy, incompetent shitters. Given how fucking footgun-y and pedestrian the language is in practice, I think I'm right. Maybe what you wrote is the cope they tell themselves, but the reality is the team who made it are incompetent midwits.
Anonymous No.106211532 >>106211773
>>106211328
>so in addition to the if and break you had to add another interface, another class, another method and another field
first: not "had to", but chose to
the minimal implementation would be to just add a if and break inside fizzBuzz(), no extra methods (if you were to shoehorn finding a perfect square as inline code into the fizzbuzz loop), no new interfaces or classes. but such an implementation assumes every fizzbuzz instance has to have this break condition

the implementation posted uses composition to add that condition. that way, in one program you can have a standard fizzbuzz from 1 to 100, as well as a fizzbuzz with the extra break condition
also, it actually reuses the Condition interface used in addRule, so you can also use DivisibleBy, IsPrime or any other implementation as a break condition, or use PerfectSquare as another rule condition for building your fizzbuzz variants
creating a new class to implement PerfectSquare isn't some gigantic overhead while adding better code organization (stuff related to calculating a perfect square is just in one class named PerfectSquare) and flexibility (can use it; can ignore it)

>the existing rule abstraction did not anticipate the future correctly
the rule part (condition + output) has remained untouched as the new requirement didn't affect it
also there wasn't even any anticipation of future involved - the refactoring has been done as new requirements arrived
Anonymous No.106211638 >>106211737
>>106211022
>a book can only give you theory, which if you apply incorrectly (might be bad implementation, or maybe poor explanation by the book, or maybe just applied to an unfitting use case), you might arrive to the conclusion that the whole paradigm is bad
you might have felt so smart saying this but no, an actually good book always includes something along those lines. they teach you not only how to do things but also how to not do. they save a lot of time waste by incorrect "hands-on experience".

Can you imagine a crowd of pilots trying to figure out driving figther jets by themselves, and when they couldn't do it, blaming the jets. This is just as ridiculous as people who haven't cared to learn oop or software design principles in general and saying OOP is bad and good software must be simple like paper planes (procedural with no abstraction or pattern) compared to fighter jets
Anonymous No.106211662
>>106192873 (OP)
both this and lua are sovlful
meanwhile you have modern languages crashing on windows7 "because of security" and shit like that..
Anonymous No.106211737 >>106212062
>>106211638
poor analogy
flying a plane is being an operator; programming is closer to being a craftsman
also pilots don't just read a "good" book and then know how to fly a jet plane
also programmers aren't selected for the job like jet pilots are, pretty much anyone can become a programmer

>people who haven't cared to learn oop or software design principles in general and saying OOP is bad and good software must be simple
that hasn't been my point at all, though
Anonymous No.106211773 >>106212081
>>106211532
>assumes every fizzbuzz instance has to have this break condition
in practice, you have one. if you have two, duplicate the code. your framework to solve fizzbuzz shaped problems is not more maintainable. the thought process of another developer having to change your code won't be "wow, what elegant abstractions, i can modify this so easily", it's "what the fuck, this should be a loop and some conditions, now i have to track all this indirection over multiple files for what should have been a 20 line function"

>the refactoring has been done as new requirements arrived
by again trying to anticipate a future where not every instance needs a break. instead of writing an interpreter that when given a dsl solves the problem, ditch the interpreter and solve the problem

>flexibility (can use it; can ignore it)
again, trying to predict the future. if your program is hardcoded to solve exactly the problem you have and nothing else, it's trivial to modify. resist the urge to generalize when you don't know the requirements. usually you'll end up with redundant abstractions because the requirements did not change, and if they did, your abstrations are in the way or nudge you into adding even more, like in the example. "flexibility" is a liability, you spend complexity on supporting a use case you don't have
Anonymous No.106212062 >>106212123
>>106211737
it's elaborate misdirection to fixate things on that analogy.
any people in their respective field of profession is supposed to learn whatever the knowledge is accumulated throughout years because it prevents them to reinvent the wheel in an inferior way. theory comes first and then the practice. this is how intelligent species behave.

you might be thinking that what if OOP was always bad to begin with but this is something to be discussed academically and not something along that "I think OOP is bad because it's so complicated and I never spent my time to learn it correctly"

>that hasn't been my point at all, though
well then I got your point wrong. weren't you saying that hands-on experience comes before than learning the foundations from books and other sources?
Anonymous No.106212081 >>106212396
>>106211773
you're criticizing the specific case of fizzbuzz to dismiss the principles as a whole
you're also assuming the problem conditions are static for the whole program, which usually is not the case

>trying to predict the future
that is only your assumption, which is wrong
it was actually written primarily for consideration of the past: composing the condition does not break any previous usage. if you hardcode the condition, you inherently create a regression affecting all previous uses of the code
duplicating code for each new usage of a non-trivial module is not viable for maintenance, which returns to the original point of why OOP is better for maintenance than procedural code
Anonymous No.106212123 >>106212191
>>106212062
>theory comes first and then the practice.
this is valid for pedagogy (teaching of children) but for teaching of adults (andragogy), experience comes first
Anonymous No.106212191
>>106212123
>this is valid for pedagogy (teaching of children) but for teaching of adults (andragogy), experience comes first
this is just a claim that has literally no basis whatsoever. I don't agree in this and not going to counter it even.

the thing is, you can't even make practice without theory first.
The "practice" that's in your mind is, learning a little bit of theory and spending countless hours by yourself, writing some ad-hoc shit and then realizing that there's a much better way to do it, only to find out later that it's explained in the books to allow you to not waste your time.
Anonymous No.106212356 >>106212384
>>106192873 (OP)
I work with Java for a living, and it is very good.

Specifically the jars of bytecode and classpath scanning during runtime can be really good.
It means I can split my program into a hundred, separate compiled pieces, and when doing updates, I only need to update the relevant jars. Combine it with docker, and you get version upgrades that aren't megabytes in size, but kilobytes.

My problems with are:

- too many unnecessary features (I just dont use them, who needs records and that garbage)
- relatively slow compilation and startup in comparison to go,
Anonymous No.106212384 >>106212444
>>106212356
Records are the easiest way to create DTOs. Are you a junior developer or what?
Anonymous No.106212396 >>106212477 >>106212761
>>106212081
>you're criticizing the specific case of fizzbuzz to dismiss the principles as a whole
it was your example. when you modified the program, did you think about the loop and where you would insert the required code? yes? then why obfuscate the code for the next developer that has to modify it? just make your change right there and then stop

>you're also assuming the problem conditions are static for the whole program, which usually is not the case
code duplication is the better tradeoff when the alternative is an indirection monstrosity. you can go very far by duplicating the overall structure of the algorithm and moving shared blocks into functions. if requirements change for one instance, you don't have to shoehorn them into the globally shared structure, you can just make your change locally and move on, i.e.

void fizzbuzzRegular() {
for(int n = 1; n <= 100; n++) {
fizzbuzzPrint(n);
}
}

void fizzbuzzBreak() {
for (int n = 1; n <= 100; n++) {
if (isPerfectSquare(n)) {
break;
}
fizzbuzzPrint(n);
}
}

void fizzbuzzPrint(int n) {
if (n % 3)
...
}


>if you hardcode the condition, you inherently create a regression affecting all previous uses of the code
only if you have a setup where you try to parameterize a trivial algorithm because you are afraid the code duplication police will get you or something
Anonymous No.106212412
Good morning saaar
Anonymous No.106212444 >>106213492
>>106212384
Senior, and I do not see their use.
I have no use for records when I can just do

class dto {
int x;
int y;
}
Anonymous No.106212477 >>106212545
>>106212396
>indirection monstrosity
any kind of accumulated knowledge in its respective field looks like a 'monstrosity'. I swear to god there's not a single dev who knows foundations and principles of OOP while at the same time spurting nonsense like this.
>what the fuck, this should be a loop and some conditions, now i have to track all this indirection over multiple files for what should have been a 20 line function"
shitcoders glorifying other shitcoder behaviors
Anonymous No.106212545 >>106212630 >>106213565
>>106212477
>accumulated knowledge
the accumulated knowledge is the business logic, hiding it behind tons of indirection is technical debt
>shitcoders
if the code is more complex than it needs to be, then it's inferior to the code that isn't. complexity is a bad thing, not sure why this needs to be pointed out explicitly
Anonymous No.106212630 >>106212777 >>106219611
>>106212545
I would understand if you have compared oop to like FP where abstraction is done by functional decomposition but you're giving no alternative and just claiming that using no abstraction at all is better.
When people are faced with scalability questions against procedural programming they are always answered with "just use functions" which is a valid abstraction method but with languages like C with second-class citizen functions and non-pure functions all over mixed with arbitrare procedural instructions it quickly becomes maintainance hell where you have to read multiple translation units and functions to even begin to understand what does the code do.

now compare it to OOP where you have clearly identified interfaces and objects with defined pre-conditions and invariants it's 1000x easier to make additions or refactors. it's like microservices at code level.
Anonymous No.106212761 >>106214101
>>106212396
>it was your example
any more advanced examples would require more abstraction and thus completely fly over cniles' heads...

>then why obfuscate the code for the next developer that has to modify it?
... and it seems it was a rightful assumption, if you already call such a small change "obfuscation"
also it is now you who is making presumptions about future: why would the next developer modify it at all? how do you know it would be a challenge for him to do further modifications if you don't know what they are?

>you can just make your change locally and move on, i.e.
now plug in your implementation into a processor function that will set all parameters according to some input structure, eg. some HTML form data
list how much of and to what extent your code had to be modified
Anonymous No.106212777 >>106212876
>>106212630
to understand your code, the reader has to open 7 different files and insert the operations into the core algorithm in their head. or most likely, just give up and use a debugger. not you of course, you wrote the code and know how the thing is wired together. for two weeks, maybe.

to understand my code, the reader has to read two functions in the same file
Anonymous No.106212876 >>106213009 >>106213467
>>106212777
>to understand your code, the reader has to open 7 different files and insert the operations into the core algorithm in their head.
there is no "core algorithm" in OOP. even the main() is there to just bootstrap whatever is needed and lend the control flow to other objects. there being no "core algorithms" is one of the reason why OOP can be much easier to understand/work on and be written with significant formal safety. Hopping through different files have nothing to do with OOP but if you're talking about Java where multiple classes in one file are not allowerd, it's still zero cognitive overhead and done quickly with your IDE. And same thing exists for C code bases like, have you ever worked on a big C codebase? Like FreeRTOS? You still jump on 7 different files because they're seperated that way.
Idk but what you have claimed so far has made me think you haven't coded much in your life.
Anonymous No.106213009 >>106213176 >>106213467
>>106212876
>there is no "core algorithm"
it's the fizzbuzz-loop calling (or "lending control flow to", lol) all your outputs, rules, transformers, break conditions etc. you know, the thing hat does the orchestration at the core, the algorithm there, the place where very reader has to start to understand what the code is doing
Anonymous No.106213176
>>106213009
eh, maybe not so easy when your program is less trivial than some calculator app
Anonymous No.106213467 >>106213823
>>106212876
>even the main() is there to just bootstrap whatever is needed and lend the control flow to other objects
fun fact, the project containing >>106210582 doesn't even have a main() method
execution is only done in JUnit tests (which must have their own main() method buried somewhere underneath the framework, but there is no explicit main() in the project itself)

>>106213009
>the place where very reader has to start to understand what the code is doing
that would be just the public interface of the class (you don't need to know the implementation details if the interface is clear)
just look at the code in >>106210582
knowing that it's fizzbuzz, what is not understandable in it?

even a more basic example: if you create a new list in Java and add a few elements to it like so:
List list = new ArrayList<>();
list.add("apple");
list.add("banana");
list.add("cherry");
do you also have the need to inspect what the add() method does, or what the constructor for ArrayList does?
Anonymous No.106213492 >>106214953
>>106212444
Free getters and setters, there is literally no reason not to use them when they generate methods for free
Anonymous No.106213565 >>106213603
>>106212545
>the accumulated knowledge is the business logic, hiding it behind tons of indirection is technical debt

>if the code is more complex than it needs to be, then it's inferior to the code that isn't

Finally the real senior developer arrived.
Anonymous No.106213603 >>106213782
>>106213565
>getting called out nocoder so you have to make a samefag reply to your own post
Anonymous No.106213782 >>106213846
>>106213603
>>getting called out nocoder so you have to make a samefag reply to your own post

calm down Durga graduate
Anonymous No.106213823 >>106213911 >>106214101
>>106213467
>you don't need to know the implementation details if the interface is clear
you do, because the requirements changed and you have to modify the code, so you have to find out what it's actually doing, so you have to find the place where the developer hid the logic this time

>do you also have the need to inspect what the add() method does, or what the constructor for ArrayList does?
did you just guess what they do without ever reading the documentation or imitating code you found somewhere else? just read the signature and thought "yep, i know exactly what the capacity will be and if the list will grow according to O(n)"? you just forgot you did that because it's been so long, didn't you? if you ever get into the position where you get paid to write software in a larger team, you will notice that you can't trust signatures or names, the bugs hide in the implementation details
Anonymous No.106213846
>>106213782
Anonymous No.106213907
>>106209276
They all phone home obv
Anonymous No.106213911 >>106214034
>>106213823
>so you have to find the place where the developer hid the logic this time
proceduraltard cannot comprehend the concept of having well-known object classes as a unit of your code so he assumes it's just as hard as finding his arbitrary counts of LoC deeply hidden in somewhere in the program
Anonymous No.106213948
>>106197961

I don't think the syntax is that gay. It's a nice mix between Python and C.

This iota stuff for enum declaration is absolute garbage tho.
Anonymous No.106213989 >>106213995
Test
Anonymous No.106213995
>>106213989
was it successfull?
Anonymous No.106214034 >>106214068 >>106214101 >>106214116 >>106214265
>>106213911
>well-known object classes
by whom? you, because you wrote the code? the comparison is between 7 files in your oop exercise and a single file containing the entire implementation in two functions in like 20 lines total. i would block your pr with that code
Anonymous No.106214068
>>106214034
>by whom? you, because you wrote the code?
screaming 'I'm a nocoder' like this is somehow a good argument for you? have you ever heard of BON? Looked at a class diagram before?
>single file containing the entire implementation in two functions in like 20 lines total.
>i would block your pr with that code
I'm sure you would my nocoder friend
Anonymous No.106214101 >>106214298
>>106213823
>you do, because the requirements changed and you have to modify the code
then I check only the classes that are relevant to the change I need to implement, not dig through the whole codebase
>where the developer hid the logic this time
developers don't "hide" logic, you clown

>yep, i know exactly what the capacity will be and if the list will grow according to O(n)
actual developers don't overthink details like these. in the majority of use cases it's irrelevant - unless there's a performance problem, you can just assume it works (and most of the times, it does)
instead, main focus is put on the actual business logic, ie. "I need a list, and add a few elements to it"

>>106214034
don't get ahead of yourself, you wouldn't be in a position to manage pull requests in the first place

also you continue your shitposting while failing to implement the change mentioned in >>106212761
Anonymous No.106214116
>>106214034
>the comparison is between 7 files in your oop exercise and a single file containing the entire implementation in two functions in like 20 lines total

I'll take the single file, and so would every really good programmer I know.
Anonymous No.106214167 >>106214211
>>106197961
it's fine, i program Java professionally but i think it's great that Go got some popularity. not really because of the syntax, but the approach of "less is more" needs to get more mainstream. many Java developers are still stuck in the UML, heavy handed OOP, future proofing without requirements etc. mindset that gave enterprise Java a (deserved) bad reputation of being a slog. but even the Java architects acknowledge that you don't need all that encapsulation abstraction oop business when you just need to transform some data, which is like 99% of what every backend does. they call it "data oriented programming", which is just a nice way of them to say that you shouldn't write the enterprise fizz buzz code in this thread anymore
Anonymous No.106214211
>>106214167
>i program Java professionally
all the drivel you posted after that makes this statement raise doubts about its truthfulness
Anonymous No.106214265 >>106214384
>>106214034
>a single file containing the entire implementation in two functions in like 20 lines total
nice fantasy, meanwhile in reality

>Sorry, we had to truncate this directory to 1,000 files. 717 entries were omitted from the list.
https://github.com/FFmpeg/FFmpeg/tree/master/libavcodec

so this is the power of C "no enterprise no bloatware OOP patterns etc"?
Anonymous No.106214298 >>106214468
>>106214101
>then I check only the classes that are relevant to the change I need to implement, not dig through the whole codebase
how do you determine the classes that are relevant to the change without reading through half the implementation?
>developers don't "hide" logic
you are still a developer, you clearly can program, but you somehow decided that you needed to do more after you wrote down the loop with the couple if statements to make fizz buzz. i'm here to tell you that the first version you wrote was perfect and you should stop there

>actual developers don't overthink details like these
you should keep them in mind, and to do that, you need to read at least the documentation of the code you are calling, not hope for the best

>failing to implement the change
you mean the one where the user can modify every aspect of how fizzbuzz works by like 10 dropdowns? i thought that was a joke
Anonymous No.106214384 >>106214738
>>106214265
you have to judge the amount of code in relation to the problem it solves. tons of code to support every av codec under the sun? appropriate. tons of code to solve fizz buzz? not appropriate
Anonymous No.106214415
i think i'll leave this thread, it feels like i'm kicking some high school kid. stick with it, you already have the mental capacity to write complicated code, you just need to suppress the urge when it's not appropriate to do so
Anonymous No.106214468
>>106214298
>how do you determine the classes that are relevant to the change without reading through half the implementation?
their names and what methods they have

>you mean the one where the user can modify every aspect of how fizzbuzz works by like 10 dropdowns? i thought that was a joke
you got your change implemented
are you going to do one dirty and not do any implementation yourself?
Anonymous No.106214610 >>106214864 >>106216272
>oop is bad because my nocoder brain can't into it
another thread another proceduraltard is brutally humiliated
Anonymous No.106214672 >>106216399
>>106198179
Does that mean that c++ and java devs will always have job security?
Anonymous No.106214738
>>106214384
but the purpose of OOP is to reduce complexity and to remove tons of duplicated code.
ffmpeg would have been x10 smaller if it had been written in java
Anonymous No.106214864
>>106214610
this but unironically
>muh C is simpler
assembly is simpler so go write in assembly midwit faggot
Anonymous No.106214867
Do Java companies still ask Leetcode questions or is it mostly System Design nowadays?
Anonymous No.106214953 >>106216040
>>106213492
Did you know you can do


var point = dto();

if (point.x <= 0) {
// print x not set
point.x = 50;
}


Getters and setters were ALWAYS free.
Anonymous No.106215912
>>106193071
>There is no good reason not to use inheritance.
Use it when it makes sense. Don't use it when it doesn't. Don't try to force things Just Because.
Anonymous No.106216017 >>106216040 >>106218032
>>106198762
>python
Python's a turd with fancy lipstick on it. It's probably the shittiest turd that is pretending to be a major language. Even goddamn Ruby's better, and I hate Ruby. (The shitty smell starts turning up as soon as you deal with dunders.)
Got a lot of people who pay me money to support their Python code. It pays the bills, but it really ought to DIE IN THE FIRES OF HELL!
By contrast, Java's a lot more consistent and elegant. And verbose. Oh well.
Anonymous No.106216040
>>106216017
>it's verbose

What if you did it like this >>106214953 ?
Anonymous No.106216272
>>106214610
oop is more ergonomic than procedural though
Anonymous No.106216399
>>106214672
C++ most likely will, Java is yet to see. It's much easier to curate a LLM on Java code, FAGMAN has just not bothered cause sweeping the low hanging fruit is more profitable (everyone and their mother know Javascript and Python, they can fire a lot more people if they pin those down first, the wages can go further down if there's a bigger pool of people competing for the jobs. Finding competent Java devs is becoming harder, most people gravitate towards the easier langs so what's left are all expensive seniors, design patterns cultist or Python/JS refugees without experience. Also plenty of real world Java code that would be useful for training models is closed source, hidden behind corporate networks).
Anonymous No.106216918 >>106216931 >>106216934 >>106217286 >>106218018
>>106192873 (OP)
So, in closing:
The BEST language is Javascript.
You know it, I know it, we all know it.
Get fucked, retards
Anonymous No.106216931
>>106216918
LOL
Anonymous No.106216934 >>106217029 >>106217264
>>106216918
>interpreted lang with no typing
into the trash it goes
Anonymous No.106217029 >>106217223
>>106216934
>wrong twice in the same sentence
nu-/g/ is cancer
Anonymous No.106217223 >>106217486
>>106217029
>var let const is typing
how dumb are you
Anonymous No.106217264 >>106218443
>>106216934
static languages have purpose, but not for most business software, which is primarily made up of servers, and where introspection allows for vastly better debugging capabilities.
the peak of software engineering ATM is probably Elixir with Rust for hot paths. JosƩ Valim's work with researchers to devise their type mechanism is very interesting, and should lead to guarantees about software that never has to go down for upgrades.
Anonymous No.106217286 >>106217592 >>106217626
>>106216918
Anonymous No.106217486 >>106217960
>>106217223
>what is dynamic typing
how dumb are you
Anonymous No.106217592
>>106217286
Just how God intended it to be
Anonymous No.106217626
>>106217286
honestly bro this shit does not matter. write fuckin tests. use Typescript if you want.
and no, I do not like writing JS either, but it's not because of this
Anonymous No.106217960 >>106218206
>>106217486
if javascript had typing no one would have bothered to invent typescript
Anonymous No.106218018 >>106218073
>>106216918
BENCHOD I REDEEM IT
Anonymous No.106218032
>>106216017
Ruby and Perl are art student languages that value muh elegance and writing code like poems over runtime efficiency, safety, or anything else an actual programmer cares about. Literal Reddit the programming language.
Anonymous No.106218073
>>106218018
You redeem it everytime you open up any web browser, you stupid fuck
It's a Javascript world, and you're just living in it
Anonymous No.106218206 >>106218247
>>106217960
you don't even know what typing is and I'm not about to waste time explaining it to you
Anonymous No.106218247
>>106218206
if it's not enforced it might as well not exist
Anonymous No.106218292 >>106218328 >>106218920 >>106218998
>Be me
>Java EE <-> Jakarta EE has literally caused dependency hell across every system
>people sticking with wildly out of date software to keep J2E symbol names
>Package renaming tools are technically a license violation (derivative work) and also break code signing
Honestly anyone who says this shit language just works is a fucking dumb nigger faggot retard. The "ecosystem" is giga fucked and Oracle seems to drop new and exciting stinkies using insane legal threats for no good reason. It's basically as cursed as .NET shitware at this point. I find excuses to move to Rust for every single line of Java every single day. Fuck you and fuck all of you. Even Go is less cancerous.
>B-but muh new framework that solves everything bros
Ya I remember when reactive java and other shit was going to fix everything with regard to performance and how quarkus or AOT or whatever is going to make java fast at booting up. Fuck off. It won't fix the layers of shit that have to keep existing and if you're replacing it, why not just replace it with a much superior faster language like Rust anyways or even C# (yet I know I shit on .NET, but even M$ nigger hell is less bad).
Anonymous No.106218328 >>106218378
>>106218292
Not gonna read all that garbage
Just use Quarkus like a normal human being
Anonymous No.106218378
>>106218328
>Just replace everything bro
Are you retarded or what? Why not go with dotnet 9 with AOT especially when 10 is looking to basically smoke 9 and anything the JVM can do?
Anonymous No.106218443
>>106217264
Nice I will look into elixir again. I am learning some java at the moment, but elixir or erlang will be next.
Anonymous No.106218920 >>106219046
>>106218292
>>Java EE <-> Jakarta EE has literally caused dependency hell across every system
yeah that didn't happen

>replace it with a much superior faster language like Rust
of course it's a rustroon making shit up
Anonymous No.106218998 >>106219046 >>106219091
>>106218292
>Package renaming tools are technically a license violation (derivative work) and also break code signing
Can't you just vendor the library or ask your company to quit being a parasite and batch-rename everything for the author? It's not like you're using GPL'd artifacts
Anonymous No.106219046 >>106219156
>>106218998
Not everything is free and open source.
>>106218920
You probably don't even know what a class loader is. Shut up peasant.
Anonymous No.106219091 >>106219156
>>106218998
Keep in mind the biggest problem is the latter, where the vendor signs their code so any tampering with the jars breaks the signature. It's literally insane.
Anonymous No.106219156 >>106219171 >>106220147
>>106219046
If you have a license to package and distribute your application alongside a closed-source library then you're already making a derivative work. What sort of clause prevents you from batch-renaming "javax" to "jakarta"?

>>106219091
Can't you just call someone and ask them to release an updated version? The fix is like 5 minutes of work, I think they can do it for a paying customer.
Anonymous No.106219171 >>106219216
>>106219156
>license to package and distribute your application alongside a closed-source library then you're already making a derivative work.
Literally the difference between gpl and lgpl. Making derivative works of a .class is a bigger leap than "linking" said code.
Anonymous No.106219216
>>106219171
But if it's LGPL then it's open-source and if it's open-source you can just fork it / create a pull request so that the project stops using Java EE packages
Anonymous No.106219611 >>106219659 >>106219669
>>106212630
OOP slows down runtime execution by a lot. 10-100x is common. That alone makes it unusable for serious work. You got away with OOP because hardware doubled in compute every year from 1950-2010. That time is long dead, Nvidia and Intel aren't going to bail out your dogshit abstractions and you can't just hide away their inefficiency with time anymore, point and case modern games, which while being made in C++ and barely looking better than something that was released 15 years ago, performs like absolute shit on hardware 5-10x as powerful. If you want to do more shit with your programs then you have to program for the hardware instead of people and like it or not, hardware is procedural. C had it right in the 1970's, the damage the OOP C++/Java/C# era has done to software development will take decades to recover from.
Anonymous No.106219659 >>106219806 >>106219861
>>106219611
this guy doesn't code.
you avoid like 80% of overhead by doing compute heavy work procedurally, and half of the rest is taken care by compiler. it's not like FP where you have procedural/unsafe implementation of lists in standard lib because it's just not possible/too slow to code in FP. oop is golden medium between performance and abstraction
Anonymous No.106219669 >>106219811
>>106219611
you have no idea what you are talking about. OOP is not slow. it's just typically used on virtual machines where things are not statically compiled.
C++ has inheritance (which is the defining characteristic of OOP) and it's not slow.
Anonymous No.106219806 >>106219966
>>106219659
and you need to look more into FP. specifically, lazy enumerable pipelines, which allow for trivial glueing together of loops while maintaining minimal passes over data (see Rust's iterators).
sure, immutable data structures are slower than imperative (although nowhere near as much as people like to claim) during sequential operations, but they often BTFO locking mechanisms on mutable data structures in parallel workflows. see Haskell and its software transactional memory mechanism.
it would be vvery fucking smart for the people ITT to grow wiser and recogtnize that computer science is a very deep, nuanced field, and that it genuinely takes years of work to understand (and the curious mind to actually try new things).
Anonymous No.106219811 >>106219831
>>106219669
C++ can be slower than Python if wrote poorly. Language doesn't guarantee anything.
https://youtube.com/shorts/dDpoWFNndBM?si=-h1EIBS-vj8doOkk

Data oriented design (aka well done procedural code) is often many orders of magnitude faster than the best OOP can hope to offer. If you are arguing against this then you are a novice and need to stfu. Or well done trolling everyone for so long. I can't tell which you are after reading through and jumping into this thread.
Anonymous No.106219831
>>106219811
post code
Anonymous No.106219861 >>106219966
>>106219659
The compiler will not restructure your explicit memory allocations lmao
Anonymous No.106219966 >>106219999 >>106220007
>>106219861
it can actually. and allocations for objects can be done on stack. jvm does it automatically sometimes and im sure you have enough iq points to figure out how to do it manually, right?
>>106219806
Im planning to look into FP for reasons unrelated to performance
Anonymous No.106219999
>>106219966
>allocations for objects can be done on stack.
Then you're talking about a toy, not a real program
Nobody gives a fuck how fast you can iterate over a 100 entity array on the stack
Anonymous No.106220007 >>106220131
>>106219966
>Im planning to look into FP
be prepared for a week of pain
once it clicks tho, it's really nice
the coolest part about immutable data structures (what I consider to be the main part of FP) are the explicit state transitions. you simply cannot mutate some hash map deep within some nested code without returning a mutated variant through those scopes. this means that, unless you see `some_hash_map = {/* some inner scope... */}`, then you can guarantee that `some_hash_map` has not changed. really aids readability.
Anonymous No.106220125
>>106192873 (OP)
I like go more but java is fine. Jvm is shit and unnecessary with containers.
Anonymous No.106220131 >>106220252 >>106229741
>>106220007
What differentiates functional programming from just using .map(), .filter(), etc, or the std::views objects? Java and C++ do have functional programming by that measure, unless I am mistaken?
Anonymous No.106220132 >>106220152
>>106193071
Never thought I'd see a terrible opinion from Averi...
Anonymous No.106220147 >>106221061
>>106219156
>What sort of clause prevents you from batch-renaming "javax" to "jakarta"?
Actually, better yet, does anything prevent you from mass-renaming the jakarta namespace back to javax?
Anonymous No.106220152 >>106220188
>>106220132
>a dog owns an animal
benchod gojeet
Anonymous No.106220188 >>106220247
>>106220152
fuck off nigger
Anonymous No.106220247
>>106220188
saar
Anonymous No.106220252
>>106220131
immutable (also known as persistent) data structures
also, tail call optimized recursion (although imperative langs can have this too), which makes for loops and labelled breakpoints look like stone tools
they massively change how you code
Anonymous No.106221061
>>106220147
You'd also have to go through and rename everything in the application server / servlet container you use to deploy your application. Pretty sure new versions of those no longer support Java EE packages, not to mention that Jakarta EE has progressed slightly beyond the last Java EE spec
Anonymous No.106221482
>>106192873 (OP)
saar
Anonymous No.106221491 >>106221695 >>106223822
>>106194946
Never in my life have I ever needed Multiple Inheritance.
Anonymous No.106221695 >>106221869 >>106223694
>>106221491
jew extends reptile implements nigger, faggot, tranny
Anonymous No.106221869
>>106221695
>jew
>reptile
Anonymous No.106223694
>>106221695
public class Jew extends Semite, Kike implements Reptile, Nigger, Faggot, Tranny {

}
Anonymous No.106223822 >>106224304 >>106229748
>>106221491
never in your life have you tried Common Lisp
like a child that refuses to try a new dish
yet, here you are, complaining about the perceived flavors. I've never seen the need for spice!
Anonymous No.106224161
>lisptrannies shilling their memelang again
go back to your containment thread
Anonymous No.106224304 >>106224318
>>106223822
I've never seen the need for your bullshit
Anonymous No.106224318 >>106224326 >>106224560
>>106224304
post code
Anonymous No.106224326
>>106224318
post nose
Anonymous No.106224560 >>106224848
>>106224318
post colour of skin
Anonymous No.106224573 >>106225289
>people with no abstract thinking skills are against abstraction
>oop is abstraction
>people against oop have no abstract thinking skills
logic checks out
Anonymous No.106224848
>>106224560
Anonymous No.106225289 >>106225338 >>106225457 >>106227314
>>106224573
>people who just learned about abstraction apply abstraction everywhere
when you first solve the problem, you solve it procedurally, because that's natural. it's also the code your coworkers expect when they get a ticket to fix a problem with it. but instead of leaving it in the understandable, natural state you invest additional time to make it worse. if you have time for step two, make the procedural version better
Anonymous No.106225338
>>106225289
you're fucking retarded for not knowing that OOP does not imply either procedural (imperative) or functional programming. it's a method of organizing data and functionality to operate on that data. that's it.
Anonymous No.106225457 >>106226098
>>106225289
>when you first solve the problem, you solve it procedurally, because that's natural.
>writing software with no design is good because it's natural
that's also how you write shitty sphagetti code, but since you're a nocoder I don't expect you to know.
>it's also the code your coworkers expect when they get a ticket to fix a problem with it
CS unlike many other engineering fields doesn't immediately threaten human life so it's why people like you and your coworkers can larp as engineers.
Anonymous No.106226098 >>106227183 >>106227714
>>106225457
>sphagetti
you got told the maintenance of oop code is better. but if you look at the two fizz buzz versions in this thread, which would you rather see when having to make a change? the self contained one in a single file, or the oop version spread over multiple? you can be honest, we are all anonymous here
Anonymous No.106226672 >>106226856
>>106192873 (OP)
just works
Anonymous No.106226856
>>106226672
you should write a lib for your IO utility such that you provide a hash map or whatever of options, shortcuts, recursive sub-options/shortcuts, and lamdas so that you can define your UI in a declarative manner, while also being able to do similar UIs for other projects trivially.
an interesting thing: with enough work and addition of options, you will eventually have created a REPL for your own programming language, and it is for this reason that people enjoy Lisp/REPL based workflows.
Anonymous No.106227183 >>106227303 >>106227513
>>106226098
>actually defending procedural because it's better at writing fizzbuzz
abstractions indeed tend to increase complexity if all you write is 20 line fizzbuzz. maybe you really should stay away from OOP perhaps.
Anonymous No.106227303 >>106227330
>>106227183
>actually defending @Controller @Service @Repository, DTOs, models and converters between the two because someone told you it's clean architecture
ISHYGDDT
Anonymous No.106227314 >>106227755
>>106225289
>make all your code revolve around the current problem youre dealing with so that any time you run in to a similar but different enough problem the code no longer applies and you have to write a new solution to address that problem
>rinse and repeat
>instead of just investing the time ahead of time to properly engineer a working solution that addresses all potential future problems
do proceduraltroons really
Anonymous No.106227330 >>106227413 >>106227430 >>106227755
>>106227303
the whole procedural over oop craze has begun because some people told oop is bad though
Anonymous No.106227413 >>106227755
>>106227330
Literally just because of midwits like this
https://youtu.be/QM1iUe6IofM
Their entire argument is:
>abstraction bad
>because applications being more complex bad
>instead all applications should be 20 line fizzbuzz projects
>something something muh spring boot verbose class, and then show some code like
public class AbstractProxyBeanFactory extends JewishIdeaProxyFactory implements IHaveZeroIQ, IWritePajeetCodeAndProjectMyRetardationOnToEveryoneElse {}

and tell you that every single OOP project looks like this
Anonymous No.106227430
>>106227330
mostly cniles and the retarded jews who peddled go
Anonymous No.106227513 >>106227938
>>106227183
>abstractions indeed tend to increase complexity if all you write is 20 line fizzbuzz
so you agree that it is overkill in this scenario and reduces readability? then the only remaining question is: when is the problem complex enough that it warrants oopification? if you keep your procedural functions pure, that threshold is very high. seriously, try it. you can still group related functionality in a "service" class so it can be tested in isolation and doesn't have to be static. stateful objects with attached functionality arise naturally, they are not bad, prematurely forcing their existence because you got taught this is "proper design" is. i stopped worrying about "clean code" or "proper design" and write code that reduces the amount of algorithmic work. turns out if you do that, the reader of your code also has to do less work, because fast code has to be simple. don't chase cache misses or do bit twiddling etc. though, that tends to reduce readability in my experience. people tell you that "premature optimization" quote, which results in being anchorless and fall prey to conference nocoders like uncle bob that tell you what "good code" is. write code to please the machine and you'll be pleased in return
Anonymous No.106227714 >>106228323
>>106226098
>if you look at the two fizz buzz versions in this thread
which implementation had its request implemented, and which didn't at all?

>the self contained one in a single file, or the oop version spread over multiple
is that really your criteria for judging maintenance? number of source files, as if that's some kind of impediment?
Anonymous No.106227755 >>106228021
>>106227314
everything you posted applies to OOP as well

>>106227330
what craze
a bunch of people were shitting on Uncle Bob's ideas and rightfully so
that's all there is to it

>>106227413
>abstraction bad
abstraction good which is why you write reusable procedures in the procedural approach
and reusable functions in the functional approach
>applications being more complex bad
making your applications more complex than they should be is bad
Anonymous No.106227938 >>106227989 >>106228135
>>106227513
>so you agree that it is overkill in this scenario and reduces readability?
is the code in >>106210582 unreadable to you?
Anonymous No.106227989 >>106228250
>>106227938
proceduraltards will see
human.walk()
and
dog.bark()
and say it's too hard to understand and unnecessarily complicated
and then suggest you a code like this:
human.newStep = malloc(sizeof(human.newStep));
human_move_leg(&human);
free(human.newStep);
Anonymous No.106228021 >>106228101 >>106228181
>>106227755
>>applications being more complex bad
>making your applications more complex than they should be is bad
what about avoiding abstractions for no good reason?
Anonymous No.106228101
>>106228021
I'm at a loss
>for no good reason
it's hard to argue for or against with such qualifier
Anonymous No.106228135 >>106228308
>>106227938
>unreadable
every developer understands loops and conditionals. instead of representing the problem in the language everyone else on the team understands, the author decided to force their mental model on their colleagues. the author believes that their understanding is more important than that of everyone else. you can write the code like that, for yourself to understand the problem better, but once you do, don't push it into review. more code doesn't always mean worse, but as a rule of thumb, it does
Anonymous No.106228181 >>106228392
>>106228021
>no good reason?
the reason is better maintainability by people that are not the author. professional conference speakers tell you all about SOLID, but you know what makes programs easy to modify? when there is as little code as possible, separated into subsystems of related functionality
Anonymous No.106228250
>>106227989
but saar, less features is simpler, but i would never ever ever write my code in assembly
Anonymous No.106228308 >>106228372
>>106228135
>representing the problem in the language everyone else on the team understands
you're assuming "everyone else on the team" has the same lack of comprehension for abstraction as you
at the same time you ignore "the team" understanding plain English, which will be highly abstract compared to any source code

>force their mental model on their colleagues. the author believes that their understanding is more important than that of everyone else. you can write the code like that, for yourself to understand the problem better, but once you do, don't push it into review
that's some heavy mental gymnastics to avoid saying you're suffering from primitive obsession and can't do any abstract thinking
Anonymous No.106228323 >>106228416
>>106227714
>request implemented
that's not a requirement, that's an attempt to retroactively justify the janky lego set nobody asked you to build
>but what if one day all this unnecessary flexibilty is needed in just the right way so i don't have to reshuffle everything like the last three times?
don't anticipate the future, it never works, you are wasting the time of your employer and that of your colleagues. i guess the only therapy is to get a job and be on the receiving end of endless over-abstracted bullshit that's hiding a couple loops and if statements
Anonymous No.106228372 >>106228435
>>106228308
>can't do any abstract thinking
every half decent programmer can. the better ones don't force it onto others when it's not necessary
Anonymous No.106228392 >>106228437
>>106228181
>the reason is better maintainability by people that are not the author
your stance is contradictory to the point you're trying to make
a procedural approach requires significantly more re-reading and "mental mapping" of the implementation to understand it. in fact, the mental mapping of implementation details is so strong, reading abstract code without those details can become a huge challenge for a procedural-oriented developer (as seen earlier in this thread)

>but you know what makes programs easy to modify? when there is as little code as possible, separated into subsystems of related functionality
that's literally what OOP achieves
even if there's more code overall (a negligible difference in any practical case), for any problem you need to view and modify a much smaller scope of code than with a procedural implementation
Anonymous No.106228416 >>106228485
>>106228323
>don't anticipate the future
again, there was no anticipation of future involved
stop repeating your strawman arguments
Anonymous No.106228435 >>106228599
>>106228372
>don't force [abstract thinking] onto others when it's not necessary
absolutely nonsensical statement
Anonymous No.106228437
>>106228392
a class with one method is not a subsystem. it's ok if you are at that level where that's the amount of complexity you can hold in your head, but you'll never improve of you stop there
Anonymous No.106228485 >>106228724
>>106228416
you know it's true, that's why it hurts to hear it. you are not your code. if it's not flexible enough to support whatever the business is dreaming up next sprint, that's not a personal failire, that's a regular day at the office. when it happens, you change the code to fit the new requirements. and then do it again. and then somebody else changes it, and it doesn't meet your standards, but it's ok, it's just text
Anonymous No.106228527
tl;dr the last 10 posts
thank you for your attention
Anonymous No.106228599 >>106228724 >>106228789
>>106228435
the amount of mental work you get done in a day depends on how much focus any individual problem requires. i'd rather spend my time solving issues that bring in revenue than unraveling the oop goop my colleagues wrapped arounf the trivial task they had because nobody trusts them enough to do the hard stuff
Anonymous No.106228724
>>106228485
>>106228599
the crying and butthurt from being proven wrong are causing you to make progressively more typos in your posts
Anonymous No.106228762
following conclusions from this thread
>proceduralfags are incapable of abstract thinking and are actively fighting against it
>proceduralfags are incapable of comprehending code can require only small changes and not cause regressions on any modification, insisting it's "predicting/anticipating the future"
>proceduralfags will argue endlessly about imaginary scenarios but never post actual code demonstrating any changes to their code
>proceduralfags just ignore posts that prove them wrong and will repeat same invalidated points every next time the same discussion topics arise
Anonymous No.106228789
>>106228599
>trusts them
yet. if you keep at it, you'll get annoyed when a solution is more complicated than it needs to be as well and think "why is this so complicated, it's just a bit of logic". maybe you'll be kinder than i am then, because everyone starts small. oop seems like good training wheels because it allows you to solve tinier chunks of the problem that you can then, after a bit of rejiggering, make work to solve the problem. but after you've done that a couple times, you can just skip that step because you know what needs to happen in what order, and then you just write it down. if that's the reason why you prefer it, that's fine and i apologize. but if you really think it's easier to understand, i don't have much hope
Anonymous No.106228796 >>106228900
following conclusions from this thread (updated)
>ABLUBLUBLU OOGA BOOGA OOGA BOOGA
>WAAAH WAAAH WAHABI WAHABI UMMAH
>NYEAAAAAAAAAAAAARGHHHHHHH
Anonymous No.106228900 >>106228943
>>106228796
Anonymous No.106228943
>>106228900
Anonymous No.106229741
>>106220131
>What differentiates functional programming from just using .map(), .filter(), etc, or the std::views objects?

Lol

java developers' definition of "functional programming" never stops to make me cringe
Anonymous No.106229748
>>106223822
>never in your life have you tried Common Lisp
>like a child that refuses to try a new dish
>yet, here you are, complaining about the perceived flavors. I've never seen the need for spice!

based
Anonymous No.106229812
>>106198179
>Go solutions refuse to use modern features unkess explicitly pointed at
I've noticed that, why is that? It insists on using deprecated apis from the stdlib