*Posting screenshot about random stuff*
Typical comment: Why are you using light theme, oooh my eyes 😨

*Posting something related to Windows*
Typical comment: Why are you using Windows, use Linux like "pro", btw I am using Arch 🙄

*Posting something related to IDE*
Typical comments: use vim, why are you using that

*Posting something related to Java*
Typical comment: Java is slow ( 🤮 ), use Python it's cool.

*Posting something related to JavaScript*
Typical comment: js is cancer, get rid of it and use {some_other_language}

Just a normal day on devrant 🤷

(not mentioning of course non dev related sick comments)

to be continued

My graduation project partner was strange person

Favorite IDE is VIM

Forget how to use git

But somehow she could code most of the app

I asked what does she do when mistake happens, she answered "delete and write again"

I suggest github but she is "to embarrassed to show her code on internet"

She send .zip file of her code to me

Go to univ library to copy some code because she don't believe random code on internet

Of course verson of code on book in library is too old, but she prefer fix herself

But she is overall good person, so I can graduate next month

My typical development workflow:

$ ssh user@devserver
$ cd /appdir
$ git clone/pull
$ vim file
$ vim another file
$ tail -f /var/log/applog
$ vim file
$ git commit -am 'fixed the glitch'
$ git push origin dev
^D

I hate that trend of making things more lax in terms of implementation quality while writing it off with a simple but stupid "oh computers are faster now, users have the RAM, yadda yadda". Yeah but back in a day things were actually running pretty damn fast in comparison while doing it on hardware that is totally potato in comparison to what's used now. This trend eats away ANY gains we get in terms of performance with upgrades. It deprecated the whole notion of netbooks (and I kinda liked them for casual stuff), since now every goddamn one-page blog costs you from several megabytes and up to tens of megabytes of JS alone and lots of unnecessary computations. Like dude, you've brought in a whole Angular to render some text and three buttons, and now your crappy blog is chewing on 500 MB of my RAM for whatever reason.

Also, Electron apps. Hate them. Whoever invented the concept, deserves their own warm spot in Hell. You're doing the same you would've done more efficiently in Qt or whatever there is. Qt actually takes care of a lot of stuff for you, so it doesn't look like you'll be slowed down by choosing it over Electron. Like yeah, web version will share some code with your desktop solution but you're the whole reason I'm considering your competitor's lack of Electron a huge advantage over you even if they lack in features.

Same can be said pretty much about everything that tries to be more than it should, really. IDEs, for example, are cancerous. You can do 90%+ of what you intended to do in IDE using plain Vim with *zero* plugins, and it will also result in less strain on your hands.

People have just unlearned the concept of conscious consumption, it seems.

Every non Vim users ( or Emacs!)

I propose that the study of Rust and therefore the application of said programming language and all of the technology that compromises it should be made because the language is actually really fucking good. Reading and studying how it manages to manipulate and otherwise use memory without a garbage collector is something to be admired, illuminating in its own accord.

BUT going for it because it is a "beTter C++" should not constitute a basis for it's study.

Let me expand through anecdotal evidence, which is really not to be taken seriously, but at the same time what I am using for my reasoning behind this, please feel free to correct me if I am wrong, for I am a software engineer yes, I do have academic training through a B.S in Computer Science yes, BUT my professional life has been solely dedicated to web development, which admittedly I do not go on about technical details of it with you all because: I am not allowed to(1) and (2)it is better for me to bitch and shit over other petty development related details.

Anecdotal and otherwise non statistically supported evidence: I have seen many motherfuckers doing shit in both C and C++ that ADMIT not covering their mistakes through the use of a debugger. Mostly because (A) using a debugger and proper IDE is for pendejos and debugging is for putos GDB is too hard and the VS IDE is waaaaaa "I onlLy NeeD Vim" and (B) "If an error would have registered then it would not have compiled no?", thus giving me the idea that the most common occurrences of issues through the use of the C father/son languages come from user error, non formal training in the language and a nice cusp of "fuck it it runs" while leaving all sorts of issues that come from manipulating the realm of the Gods "memory".
EVERY manual, book, coming all the way back to the K&C book talks about memory and the way in which developers of these 2 languages are able to manipulate and work on it. EVERY new standard of the ISO implementation of these languages deals, through community effort or standard documentation about the new items excised through features concerning MODERN (meaning, no, the shit you learned 20 years ago won't fucking cut it) will not cut it.

THUS if your ass is not constantly checking what the scalpel of electrical/circuitry/computational representation of algorithms CONDONES in what you are doing then YOU are the fucking problem.

Rust is thus no different from the original ideas of the developers behind Go when stating that their developers are not efficient enough to deal with X language, Rust protects you, because it knows that you are a fucking moron, so the compiler, advanced, and well made as it is, will give you warnings of your own idiotic tendencies, which would not have been required have you not been.....well....a fucking idiot.

Rust is a good language, but I feel one that came out from the necessity of people writing system level software as a bunch of fucking morons.
This speaks a lot more of our academic endeavors and current documentation than anything else. But to me DEALING with the idea of adapting Rust as a better C++ should come from a different point of view.

Do I agree with Linus's point of view of C++? fuck no, I do not, he is a kernel engineer, a damn good one at that regardless of what Dr. Tanenbaum believes(ed) but not everyone writes kernels, and sometimes that everyone requires OOP and additions to the language that they use. Else I would be a fucking moron for dabbling in the dictionary of languages that I use professionally.
BUT in terms of C++ being unsafe and unsecured and a horrible alternative to Rust I personaly do not believe so. I see it as a powerful white canvas, in which you are able to paint software to the best of your ability WHICH then requires thorough scrutiny from the entire team. NOT a quick replacement for something that protects your from your own stupidity BY impending the use of what are otherwise unknown "safe" features.

To be clear: I am not diminishing Rust as the powerhouse of a language that it is, myself I am quite invested in the language. But instead do not feel the reason/need before articles claiming it as the C++ killer.

I am currently heavily invested in C++ since I am trying a lot of different things for a lot of projects, and have been able to discern multiple pain points and unsafe features. Mainly the reason for this is documentation (your mother knows C++) and tooling, ide support, debugging operations, plethora of resources come from it and I have been able to push out to my secret project a lot of good dealings. WHICH I will eventually replicate with Rust to see the main differences.

Online articles stating that one will delimit or otherwise kill the other is well....wrong to me. And not the proper approach.

Anyways, I like big tits and small waists.

Primarily IntelliJ IDEs.

I'm using IDEA for Rust & Kotlin, PHPStorm, Datagrip (DB), and sometimes PyCharm CE.

IDEs can feel a bit dirty with how heavy they are, and the lack of customization/control. But at the end of the day there's just nothing that can measure up against IntelliJ's inspections, integrations and project indexing.

My ideal product would be one universal IntelliJ IDE, but combined with the openness of VSCode/Atom, having everything transparently configurable through stylesheets and scripts.

As an editor though.... I use Vim for LaTeX, Markdown, plain text and Haskell code... but not so much for other programming languages.

Vim was my first editor when I moved from C64 to PC development 25 years ago, and while you get used to balancing keybind vimgolfing with being actually productive, i've always found maintaining plugins and profiles too cumbersome -- the reality is that Vim is an awesome TEXT editor, but it's really awful as a CODE editor out of the box.

When you want to try out a new programming language, you don't want to have to mess around with your Vimrc and Vundle and YCM for half a day just so you can comfortably write "Hello World" in Rust or Elixir... you just want to click one install button, press F10 to compile and see if it flies.

Oh, and I use Xed a lot for quickly editing files... because it's the default GUI editor on Mint desktops, and it's quite good at being a basic notepad.

Employer uses IBM Software, which forces me to use Eclipse. I hate eclipse. Hate is a hard word. I'd never say, I really 'hate' a person. But eclipse, eclipse is what I hate. I can look at my smartwatch and see my heartrate rising, just thinking of how the fuck any developer on this crappy planet would ship that bullshit IDE. That saying, I'm totally fine with some bugs, using windows and so on, but eclipse... Is this a get-more-contributors strategy? Holy moly it really kills me. Hey, let's just open that maven Proj.. Oh, crash. Hey, let's install that "bug-free" version of the maven-integratio... Oh, crash. Let's do a global search over my worksp.. Oh, freezed. Fuck! Fuck! Fuck! How can this be legal? I mean, seriously, most junoir devs I know, just use Eclipse, because they don't know of any other "better" IDE (VIM would be better, even notepad). Is there anyone sucking professors cocks / vaginas to get them introduce that crap IDE to students?

Who are devranters?

I know many devs and very few of them run Linux as their primary OS. And I've never met a single one using Arch.

Also, hardly any use Vim as their primary IDE...or even editor.

Yet, if DevRant was my first introduction to devs I'd be down Best Buy looking for a laptop (why so many laptops here?) running Arch and Vim as my word processor.

Don't misunderstand me---I have nothing against Arch and Vim. I don't give a rat's arse about the OS on my machine as I'm mostly in apps. I'm sure Arch would be fine. And whatever floats anyone's boat is fine by me.

But where are all the devs maintaining VB6 apps using XP? Is the community inclusive enough to welcome them?

Where are the "dark matter" devs? Lurking? Speak up!

Now, it may be that, say, China and India run on Arch Linux and Vim and I have a limited perspective. If so, Wow! My eyes are opened.

I continue to internally read and study about Smalltalk in an effort to see where we might have FUCKED UP and went backwards in terms of software engineering since I do not believe that complex source code based languages are the solution.

So I have Pharo. Nothin to complex really, everything is an object, yet, you do have room for building DSL's inside of it over a simple object model with no issue, the system browser can be opened across multiple screens (morph windows inside of a smalltalk system) for which you can edit you code in composable blocks with no issues. Blocks being a particular part of the language (think Ruby in more modern features) give ample room for functional programming. Thus far we have FP and OO (the original mind you) styles out in the open for development.

Your main code can be executed and instantly ALTER the live environment of a program as it is running, if what you are trying to do is stupid it won't affect the live instance, live programming is ahead of its time, and impressive, considering how old Smalltalk is. GUI applications can be given headless (this is also old in terms of how this shit was first distributed) So I can go ahead and package the virtual machine with the entire application into a folder, and distribute it agains't an organization "but why!!!! that package is 80+ mbs!") yeah cuz it carries the entire virtual machine, but go ahead and give it to the Mac user, or the Linux user, it will run, natively once it is clicked.

Server side applications run in similar fashion to php, in terms of lifecycles of request and how session storage is handled, this to me is interesting, no additional runtimes, drop it on a server, configure it properly and off you go, but this is common on other languages so really not that much of a point.

BUT if over a network a user is using your application and you change it and send that change over the network then the the change is damn near instant and fault tolerant due to the nature of the language.

Honestly, I don't know what went wrong or why we are not bringing this shit to the masses, the language was built for fucking kids, it was the first "y'all too stupid to get it, so here is simple" engine and we still said "nah fuck it, unlimited file system based programs, horrible build engines and {}; all over the place"

I am now writing a large budget managing application in Pharo Smalltalk which I want to go ahead and put to test soon at my institution. I do not have any issues thus far, other than my documentation help is literally "read the source code of the package system" which is easy as shit since it is already included inside. My scripts are small, my class hierarchies cover on themselves AND testing is part of the system. I honestly see no faults other than "well....fuck you I like opening vim and editing 300000000 files"

And honestly that is fine, my questions are: why is a paradigm that fits procedural, functional and OBVIOUSLY OO while including an all encompassing IDE NOT more famous, SELECTION is fine and other languages are a better fit, but why is such environment not more famous?

No Rant:

I guess I will start a religous discussion with it but I want your opinion on what tool I should learn.
Vim or Emacs (or stay with my IDE)?

For all of my programmer life I used IDEs... From Eclipse over CodeBlocks over VS to IntelliJ.
But now I realized that I want to be one of the cool kids. And using plain IntelliJ is uncool. No matter how much I love this tool.

So now I want to invest some time into learning. I never managed to do much in Vim since all code-completions sucked ass, feedback on syntax errors was bad and I never saw how I could be any faster with that shit compared to what IntelliJ does for me.
Will Emacs solve all those problems? Will Emacs make me code 1000 times faster and make having a mouse useless?
Or am I just too dumb for Vim? Can Vim itself do what my IDE does for me? Will it make me look as cool as I want to be?
Or should I stick to IntelliJ and just install Vim bindings?

What is your opinion on Vim vs Emacs vs any IDE?

I think I understand now why people who mastered vim recommend it.
It is so comfortable to not have to move your hands away from the writing position when you want to navigate through code.
I would really like to enable the vim keys plugin for my IDE but I think it would slow me down a lot because I'm so used to a lot of shortcuts in the IDE and not used to a lot of vim stuff -.-

I posted a !rant a couple of days ago saying I started to get the hang of vim to change from atom (which is a memory asshole)... So after trying to actually work using vim I noticed I am far more productive using atom, so I gave VS Code a chance... Wow, it's like having atom but only consuming 80mbs tops. I think I decided what will be my default ide.

Still glad I know understand vim, I will still use it but not as my default ide.

Ok so some of you have probably seen my previous rants about my computer science teacher and our project but I'm just going to summarize all of them and share with you more of my pain.

1. He edits in the production environment. Its a laravel project and he is creating test database migrations IN THE PRODUCTION ENVIRONMENT AND SWITCHING BACK AND FORTH FROM MASTER AND DEV.

2. He edits in vim and doesn't follow codestyle even though I printed him off a piece of paper and emailed it to him.

3. He doesn't have any ethic when it comes to more complex things like laravel homestead.

4. He doesnt want me to release features even though he takes really long to do them.

While I love vim and it is my editor of choice, some things should be done in an ide. This is really annoying me and I'm really just considering handing him the project if he can't follow basic outline.

Is Vim viable for Java ecosystem?

Im using vim only for years for various languages and I never had a problem. I dont use IDE or any GUI software almost never for programming.

Im being reassigned to a Java Spring project at my company, and my colleges are telling me I should start using some IDE and what not, but none of them gave me any real reason.

So Im asking is it really that inconviniet to work without IDE in Java/Spring ecosystem? Some real reasons pls.

Im developing in linux, and I know my way in bash

So this is the story of myself getting from hating vim to find it pretty good.

When i started fiddling around with linux i was literally overrun by vim. I mean how the fuck should i remember all these stupid commands.
So there we go ... nano was my favourite (and only) editor i used.

Everything was fine in my little nano world. I saw some colleague editing every damn thing in vim. I asked him "man what the fuck are you damn crazy"? And thats where till that moment the deepest conversation about an editor in my life began. He told me he could do that much with vim, its almost everywhere nowadays and a must for any admin.

So after letting him tell me about every thing you can do he promised me he is going to help me getting started quicker. And i must say boi vim is really awesome. But for "real" development i still use a ide. Although i find myself programming go, python or bash scripts entirely in vim and its not that bad.

So if you find your way through the deep shit of that single damn command input down there you can get a pretty decent editor.

Dont get me wrong i am forced to use nano sometimes, when i help some of friends with their servers or so and they litterally uninstalled vim because they were to frustrated.

So as i am started to go into the devops area you get more and more towards you have to edit a file on a server, or just tweak around before automating the shit out of it.

And i must say vim has become a solid alternative for me to a full blown ide, or any other text editor.

So yeah i am gone from freaking hating vim to using it almost everyday. But why some people out their treat vim like a religion is not understandable to me in any way.

So whats your story why do you hate/love vim? Or are you just like me a "happy user" that would switch to another editor anytime it would be a better fit?

Ok bois it's IDE / Text Editor time again.

I have had my fair share of usage with VSCode and i have been using VIM for over a year now.

With Vim i miss intellisense, class lookups etc.

VSCode doesn't provide the macro abilities i like in VIM and also doesn't support every edge case of file (giant files for instance).

Now i am at a certain dilemma. Do i use VSCode? Vim?

I am seriously considering trying emacs, but i don't know much about it.

What is your take on this?
Please respect each others choice, i don't want another fucking IDE religion war

Random thoughts on more out of the box tools/environments.

Subject: Pharo

Some time ago I had shown one of my coworkers about Pharo and he quickly got the main idea behind it but mentioned how he didn't like the idea of leaving behind his text editor to deal with source code.

Some time last week I showed the dude some cool 3d animations you can do with Pharo while simultaneously manipulating the code to change them in real time. Now that caught his attention particularly and he decided he wanted to know more about the language but in particular the benefits of fucking around with an image based environment rather than a file based.

Both of us reached the conclusion that image based makes file based dev enviroments seem quaint in comparison, but estimated that it was nothing more than a sentiment rather than a fact.

We then considered what could be the advantage/disadvantages of such environments but I couldn't come up with anything other than the system not having something like Vim or VS Code or whatever which people love, but that it makes up for it with some of the craziest IDE tools I had ever seen. Plugins in this case act like source code repos that you can download and activate into your workflow in what feels something similar to VS Code being extended via plugins written in JS, and since the GUI is maleable as it is(because everything is basically just subsets of morp h windows) then extending functionality becomes so intuitive that its funny

Whereas with Emacs(for example) you have to really grind your gears with Elisp or Vimscript in Vim etc etc, with Pharo your plugin system is basicall you just adding classes that will convert your OS looking IDE into something else.

Because of how light the vm machine is, portability is a non issue, and passing pharo programs arround is not like installing Java in which you need the JVM.

Source code versioning, very important, already integrated into every live environment and can be extended to do pushes through simple key bindings with no hassle.

I dunno, I just feel that the tool is too good to be true. I keep trying to push limits into it but thus far I have found: data visualization and image modeling to work fine, web development with Teapot to be a cakewalk and work fine, therr are even packages for Arduino development.

I think its biggest con would be the image based system, but would really need to look into how this is bad by any reason other than "aww man I want vim!" since apparently some psychos already made Emacs and VS code packages for interfacing with Pharo source trees.

Embedded is certainly out of the question for any real project since its garbage collected and not the most performant cookie in the jar.

For Data science I can see some future, seems just as intuitive and interesting as a Jupyter Notebook actually, but the process can't and will not be the same since I still don't know of a way to save playground snippets unless you literally create classes for it, in which case every model you build gets saved inside of an object, sounds possible but, strange since it is not a the most common workflow in jupyter.

Some of the environment is sometimes glitchy, but it does have continuos development and have not found many hassles.

There is a biased factor from my side: I seem to be wired to understand the syntax and simple object model better than in other languages. To me this feels natural as if I was just writing ideas rather than code, mostly because I feel that there really ain't much in terms of syntax, the language gets out of my way and the IDE feels like the most intuitive environment in the world to me. I can see why some people would find it REALLY weird of counterintuitive tho.

Guess I really am a simple dude.

For me Jetbrains idea based IDE/editor in part does just about everything right. Only need to really change the redo shortcut. They provide a warning now so you don't lose your undo history on ctrl+y.

On console both Emacs and vim work for me. These days I prefer vim. Nano will work when I'm a pinch but the lack of undo is really annoying. Especially when the cat walks over the keyboard. You just need start all over unless you can see what he did.
Vim has vertical block so you comment/uncommented stuff real fast. The cange word and change till are also real time savers. Vi is to basic and annoying for me, rather use nano than.

Gedit works great for me when viewing or editting a file real quick.

So yeah the situation dictates what tool suites the best.

Idea is where I can spend my time the entire day so if I had to choice one that would be it.

Well today i went to grab a coffee at starbucks saw my best friend working decided to buy him one too i sit down we start talking and i saw him using visual studio code and asked him why don't you use vim and answered "vim is for programmers that don't know what to do with their life and cant decide what ide they like" i didn't think twice and slapped the shit out of him fuck him. I think i might need a new best friend.

So I fell for the vim meme some weeks ago and am now very used to it, but I think I'm still less productive than I was before. The problem is that I can't just go back to a bloated IDE.
So now I'm sitting here, unsatisfied with every editor, bothering so much I don't do my work.
I guess I'll just have to configure it more to my needs and learn some more features but still do I kinda regret switching.

Any recommendations for a C/C++ IDE for Linux.

I really like PyCharm and IntelliJ for python and java but can't afford to splash out on CLion for C++.

Eclipse is completely out, I have too much of that at work and it is a total pain.

My current solution would be vim and clang but I'd like something more IDE like.

It's always a matter of much is there to do and in what language...
There is the IDE-Zone, which is dominated by IntelliJ (CLion be praised when you do Rust or C++) for large stuff and heavy refactorings.

Always disputted by VS Code with synced settings. It's nice and comfy and has every imaginable language supported good enough, especially when its smaller change in native code or web/scripting stuff.

Then there is the "small changes" space, where Vim and VS Code struggle whos faster or which way sticks better in my brain...

might be you SCP stuff down from a box and edit it to re-upload, or you use the ever-present vi (no "m" unfortunately)

sometimes things are more easy for multi-caret editing (Ctrl-D or Alt-J), and sometimes you just want to ":%s/foo/bar/g" in vim.
I am sure that each of these things are perfectly possible in each of the editors, but there is just reflexes in my editor choices.

I try to stay flexible and discover strenghts of each one of my weapon of choice and did change the favorites. (Atom, Brackets, Eclipse, Netbeans, ...)

However there are some things I tried often and they are simply not working for me...

might for you. I don't care. and I'll just use some space to piss people off, because this is supposed to be a rant:

nano just feels wrong, emacs is pestilence from satan that was meant for tentacles instead of fingers, sublime does cost money but should not, gives me a constant guilty feeling (and I don't like that) that, and all the editors from various desktop environments are wasted developer ressources.

I'm moving my React development to Linux VM as something is messed up in Windows npm...

I would like an IDE somewhat similar in features to Webstorm.

What's a good one? Needs to be GUI, not vim, don't feel like going thru the learning curve.