Programming

"Toxic" was the correct word choice. Thanks.

One of the best tutorials on really "grokking" git concepts, and it's online and interactive: https://learngitbranching.js.org

For programming, start with buildings things for yourself. Be practical, start small, and iterate, regardless if you consider the previous iteration was a success or failure. I've heard good things about https://automatetheboringstuff.com/ (in Python) in this regard.

Start with a git GUI application. I use git extensions on windows.

You'll be able to get a feel for how it all works and it actually shows you the commands it's running.

I also use bingai a lot when learning. The more specific your question the more likely you are to run into hallucinations and that. But for explaining basic concepts or query things that are well documented it's really good.

It also sources it's answers so you can follow the link for further reading if needed.

Just don't trust it to generate large amounts of code.

I'm trying to understand Git, but it's a giant conceptual leap.

To start with, start with just using git locally. Don't worry about GitHub or similar. Then git and SVN will work very similarly. The main difference is that you need to git add files with changes inside before you commit them.

Once you're comfortable with using it by yourself, then I suggest running something like forgejo locally to be your own code server. Then you can play and learn how the two parts work together.

Generally, you need to give yourself a little time. You need to do the work. Be efficient...sure, but don't try to force it to be quicker than the time you need to learn.

I guess, what I’d like to hear from you all is a way to jump back in as quickly as possible in such a way that it may be a career.

You might check job listings in your region/country to figure out what languages and technology stacks are in high demand, as where you are seems to matter a lot.

As for git, many basic concepts (e.g. staging area) clicked for me after reading some articles that Atlassian (people behind BitBucket) wrote. Other than that, I'd recommend adamj.eu 's book "Git DX" which is on gumroad. Haven't read it, tho. But I read his Django DX and like 90% of it was stuff I had to learn on my own, and thought: oh, how come I didn't find this book earlier...

Just remember: imposter syndrome is real. Everything you learn exposes you to ten things you don't yet know. Successful devs are comfortable with this reality - the job is one of constant learning. Best of luck!

Just use a good GUI tool for git and Google how to do stuff with command line when needed, you'll eventually pick it up. Chatgpt and it's ilk can also be helpful with figuring out things when Google fails.

Get a book on Spring Boot and jump back inro Java web development.

With git, you don't need to master it, just find some subversion to git howto and start using it. It's half a page of text. Once you learn the basics you can learn more as you go. There are many otherwise competent programmers who don't know git too well, I know because I support them from time to time.

I’m trying to understand Git, but it’s a giant conceptual leap.

In that case, I suggest learning Mercurial first. Its underlying design is very similar to Git, but the interface is more consistent and does a much better job of presenting the concepts to humans (especially those already familiar with traditional version control). Then, once you're comfortable with the concepts and commands in Mercurial, learn Git, since it's everywhere nowadays.

Consider learning at least one new language, if not immediately (since you're in a hurry) then in your free time. Java is only one of many (and not even a particularly nice one IMHO). Try to find a language that you enjoy using; your programming life will be better for it. If you want something flexible and productive, consider Python. For more structure than that, maybe Go. If mobile apps interest you, there are Kotlin (Android), Swift (iOS), and Dart (both). If web development appeals to you, along with lots of job openings and lots of competition for those jobs, JavaScript. If you fancy the esoteric (and well-paying), Elixir and Erlang are worth a look. Lower level languages are in demand as well (e.g. C++, Rust) but they come with various kinds of pain that I wouldn't recommend to someone in your situation.

Above all, please make sure you're reserving time for things that make you happy, sleep, and (if still possible) some kind of exercise. Your own physical and mental health are important. If you endure a bad working environment or wear yourself thin for too long, you will burn out, which won't help you provide for yourself or anyone else.

Take care, OP.

It sounds like you already have a foundation to build on. If suggest using chatgpt or something similar to explore concepts you struggle with. "explain git to me as if I knew SVN 10 years ago but have forgotten a bit"

Best of luck to you!

I’m trying to understand Git, but it’s a giant conceptual leap.

Git is not that different from svn (I mean, the biggest hurdle is going from a shared folder to any version control system)... I'd say the main difference is that branches live in a different namespace than files (ie. you don't have trunk/src/whatever but just src/whatever in the main branch). On top of that there's that commit and push are two different things (and the same with fetch and checkout) and that merges are way easier than in svn (where you had to merge stuff manually).

If you create a repo locally and clone it twice in two different directories, you can easily simulate what would happen when you and a coworker collaborate via a centralized repo (say, github) - do a few experiments and you'll see it's not as complicated as it seems (I'd recommend using the CLI instead of some GUI client: it's way easier to figure things out without the overhead of learning to differentiate between git concepts and how the GUI tries to help).

If it's a motivation issue, you will need to figure it out on your own. I could give you some advice but motivation depends on a specific use case. If you want I can share what motivates me but there's no guarantee it will work for you.

As for getting back on a tech horse, there's a trick I've been using every time I was learning a new thing and it worked every single time. I start with a project idea. I write down the major goals I want to achieve and start working on it. At first I do the "quick start" adjusted to fit my project. It usually ends up with a working proof of concept and a list of things I don't know/understand. Next, I learn about the those unknowns and update the project with what I have learned. This raises more unknowns which leads to more things to learn about. After few iterations, when I'm happy about the project, I start a new, more complex project. And so on.

First of all, you can totally do it! The field is massive, but also full of very bad programmers, and seeing how you were able to write a coherent text of three paragraphs, that already puts you ahead of the curve. Determination and perseverance is key.

I would suggest to play to your strengths. Java is still Java. Most of the progress since the 1990s was in the libraries and tooling, which only recently have become passable. The language itself also evolved somewhat, but there's nothing that you won't pick up in a couple of days of working with it.

Start with [1], work through all the boxes that are unfamiliar to you, practice a little on a pet project, or an open source project, and you'll land a job in no time.

[1] https://roadmap.sh/java

My personal recommendation:

• Pick up Python, it's easy to learn and highly productive. If you also learn fastAPI, you can benefit from highly validated, declarative models to build REST APIs in the backend, well fast. It will yield quick results, you won't become demotivated and you can pick up a paid project soon.

• Pick up Rust. It's "in" right now and I get requests from marketing people that know nothing about programming, asking if their project could be implemented in Rust

• Go with memorizing the shell commands first, try to understand git later. Get productive, try to get where you were with e. g. svn or cvs. If you are comfortable, look at something in depth if you have a problem that you can't solve with the knowledge you have.

• Fuck Java, seriously.

• You have commercial interests, so it is probably wise to look into becoming a fullstack dev to maximize the kind of projects you can do. Look into React, vue.js, svelte. React is probably still the most widely used framework, you'll quickly do a project with vue.js and svelte is a super interesting look into things to come.

When I stopped, subversion was what we used. I’m trying to understand Git, but it’s a giant conceptual leap.

It's probably not 'that much of a leap' as you imagine. If you're looking at Git tutorials, they're usually covering all kinda complex scenarios of how to 'properly use Git'. But a lot of people barely care about 'properly using Git' and they just kinda use it as a substitute for SVN... You create branches, you merge them back and forth, and that's about it.

Like if you want to contribute to an open source project, all you have to do is create a fork (your own branch in SVN terms) - commit some stuff to it, and create a pull request (request to have your changes merged) back to the original branch. git pull is just svn update - getting someone elses commits

Not saying there aren't more complex features in git, just saying, I don't think you have to see it as a 'giant conceptual leap' that's preventing you from jumping back into programming. Easiest approach would probably just be to download a GUI like Sourcetree or Fork, and just kinda pretend you're still using SVN - approach wise

So the big important part of git is that it's a collection of commits. A branch is just a labeled commit and each commit is a list of what changed from the parent. Rebasing (the most confusing one for people) is when you fiddle with a commit from underneath yourself. Or in even more simple terms editing a parent commit. Rebasing is extremely powerful but most useful for when you notice a bug you wrote a couple commits ago. Fixing such issues via rebase (or !fixup commits you auto squash at the end) keeps your history clean. It's as though you never wrote the bug. The other thing you do a lot with rebasing is moving your branch up in the history cause somebody updated the remote.

Someone will probably shoot me down for this but I actually find ChatGPT good for explaining concepts to me. Especially when I just want a high level understanding of a concept as I try to understand another one without getting too bogged down. A lot of Google results go into way too much detail.

Did you use Spring back then? It would be a useful thing to learn. Might as well see if you like to do frontend things such as React / Vue