I'm not paying for an AI subscription to do my job in the same way I don't pay for the IDE I use. My employer does.

>Because they were trained for OTHER work!

Not by choice though.

Vast majority of people who get CS degrees don't want to be computer scientists. They want to do programming work, so they get a CS degree because that's the degree employers require. They don't even know that said degree won't focus on what they actually want to learn.

And it's not like they have better choices. There are no programming trade schools. Bootcamps seem to have the right idea in principle, but implementations are often questionable, and most employers won't consider bootcamp graduates.

>Not by choice though.

Yep, I agree with that.

But I think, that way to go is to make trade schools & relax employment requirements, not change CS curriculum.

Left craft to craftsmen, engineering to engineers and science to scientists.

BTW, Electrical Engineering always be "Engineering", not "Science" degree, even if it is studied in universities.

I'm using 4 monitors, two 33" and two vertical 22".

It has nothing to do with knowing how to do shortcuts, but having to do them at all. There are plenty of instances where you may only need to provide input to one window at a time, but see other things, like documentation, output, logs, or a browser window of the page you are editing. Having multiple monitors allows me to greatly reduce the need to switch between windows to reference something or see results of my inputs.

I personally find that if I'm forced to alt-tab between my IDE and documentation, like when I'm working on a laptop, it's incredibly distracting, breaks my flow, and slows down my work significantly.

I find git reasonably understandable as long as you are using a GUI. When you have a GUI, every action you take provides you visual feedback, so it's way easier to understand the purposes of merges, rebeases, stashes, and resets. My understanding of git workflow greatly improved thanks to it.

On the contrary, I've met plenty of people who struggle along with a GUI because they don't want to learn the CLI. They mash fetch and pull rhymthically hoping it will do what they want with no clue what it's really doing underneath. Eventually, they give up, nuke the repo and reclone it. Most CLI users I've met are at least competent at using git.

I have the opposite experience, the CLI users I see pretty much never use anything besides commit, push and pull, while GUI users tend to use more advanced commands since they can actually see what they do.

I completely agree. A GUI also lets you avoid the terrible CLI. Plus the commit graph is a visual thing. It makes sense to view it in a GUI.

Definitely the best way to learn.

It was counterproductive for me when recursion was taught with Fibonacci and factorials. They were literally the opposite of easy to understand for me, I had absolutely no idea why those examples actually worked, so I just gave up and treated them like magic.

I think recursion should be taught with examples that would be easier for a student to write with recursion than without it. For example, listing all files in a directory.

Why would you think enumerating a directory is not magic?

Walking a tree / BFS is quite easy to implement iteratively, using a search queue. It's a common example for teaching Lisp.

Recursion is most natural in problems like implementing evaluation of an abstract syntax trer:

    eval(tree) = 
      apply(node(tree), 
            map(eval, leaves(tree))
           )

And since a tree is a graph, you can just use adjacency matrix and two loops. :)

O(n^2) but very simple.

That would require OS specific APIs which are distracting.

You don't have to hunt for rare examples like this, most multiplayer FPS games use client-side hit detection nowadays.

Well that's mainly for latency I think, not just a complicated computing problem.

this sounds... unexpected. I thought client-side detection is only to make blood splashes more instantaneous

What I personally see in academic setting is that when recursion is taught, it's taught using examples where you would not want to use recursion.

It's easy to understand why recursion is useful when you are tasked with traversing a file system. It's not when the first example you are given is calculating Fibonacci sequence.

I like the way SICP handles this, actually. They state clearly (in the text, haven't watched the videos) that the naive recursive form for Fibonacci is only illustrative, then they proceed to provide the iterative form. Following that they have this paragraph:

> One should not conclude from this that tree-recursive processes are useless. When we consider processes that operate on hierarchically structured data rather than numbers, we will find that tree recursion is a natural and powerful tool. But even in numerical operations, tree-recursive processes can be useful in helping us to understand and design programs. For instance, although the first fib procedure is much less efficient than the second one, it is more straightforward, being little more than a translation into Lisp of the definition of the Fibonacci sequence. To formulate the iterative algorithm required noticing that the computation could be recast as an iteration with three state variables.

Hopefully a professor in a course would make similar statements (I know mine did, repeatedly). And, at least in my early programming courses, we quickly (within a week or two) went on to those other problems where recursion was a natural and useful solution. The professors [0] introduced problems where recursion was either necessary (using for/while loops would be a non-trivial transformation with no performance gain) or, like naive Fibonacci, natural expressions of the problem.

[0] I transferred universities, not all courses lined up so I got to see the second school's introduction to this topic even though I was past that point academically. I was an unpaid TA (technically I guess I was paying to be the TA).

This is like complaining that when piano teachers teach students how to hold their hands they teach it with scales where it doesn't really matter. The importance of hand position is obvious when you are tasked with playing chords in a real song.

The very first exercise should be as simple as possible. Explicitly because you're introducing a new concept and so want as little else in the way as you can arrange.

I disagree to an extent. Sure file system traversal is great motivating example (or any tree traversal example for that matter).

However, the Fibonacci sequence provides good end to end example of recursion, then tail recursion/dynamic programming.

Music, movies, tv, video games, books. Some trackers specialize in one type of content, some have everything.

Finding URLs of private trackers is trivial in google. Getting an invite usually requires knowing another user, unless they temporarily open signups for everyone.

Here's one of many lists of private trackers

https://hdvinnie.github.io/Private-Trackers-Spreadsheet/

>youll end working anyway just to have something to do

I'd never work if I didn't have to pay bills. Spending my limited time on earth doing something for someone else's benefit on someone else's schedule makes me miserable. No such thing as an "enjoyable job". If there was, there would be someone willing to do it for free.

I've had a year of NEET life during college, and it was the best time of my life by far.

There are. Google doesn't allow apps that block ads in other apps on play store (anymore, they were on play store some years ago), but you can always just download and install them manually on android.