[l__l]

> Today's developers didn't learn binary before learning Python, why should you learn how to code without the most modern tools?

This phrasing makes me wary. There's a difference between being self-taught, and not even bothering to teach yourself the absolute fundamentals of computing, like binary...

[joshmanders]

Learning binary and knowing what binary is are two separate things. I don't think you need to learn binary to learn to code. Been doing this for 25 years working at some big name companies, I don't know binary other than 1 is on, 0 is off.

I'm starting to feel like this whole notion that newbies can't come in and learn say React or modern JavaScript without having to go all the way back to that day in 1995 when they were hashing out the std lib for JavaScript and learn every thing about it before that "Hello World!" in React starts is becoming a gatekeeping method.

[WoodenChair]

> Learning binary and knowing what binary is are two separate things. I don't think you need to learn binary to learn to code. Been doing this for 25 years working at some big name companies, I don't know binary other than 1 is on, 0 is off.

You're wearing your lack of CS knowledge like some kind of badge of honor. Of course you don't need deep CS knowledge to be a competent programmer. But almost undoubtedly you'll be a better programmer if you do know CS (I'm using binary here as a proxy for CS since I can't imagine having a deep knowledge of CS without knowing something fundamental like binary). How many times over those 25 years could a problem have been more efficiently solved (in programmer time or CPU time) if you had known about problem solving techniques (perhaps those related to binary knowledge for example) that you don't know from the world of CS? You'll never know... You may guess, but you'll never know what you don't know.

It's not gatekeeping to say that to give someone a complete education to be a software developer we should provide them a knowledge of binary. We can teach programming in an approachable fashion AND teach binary in an approachable fashion. We do it every day at my college.

[Kalium]

You're absolutely right, it's definitely gatekeeping.

That said, there's also a point in here that's often underappreciated. There's a big difference between someone who learns today's modern tools from nothing and someone who has a good foundation learning today's modern tools. I think it's fundamentally one of approach. The former treats coding as a trade where you just need to learn a few tools. The latter treats it as a vocation where fundamentals allow you to learn whatever tools you need.

The one makes sense short-term - it gets people to paying work with modern tools in a minimum of time. The other makes sense long-term - it keeps people in paying work with modern tools for decades.

When you're just getting started and looking to get that first job with the life-changing six figure paycheck, all that farting around with fundamentals that the gatekeepers are talking about seems like an absolutely massive waste of time.

It is gatekeeping, but gatekeeping can and sometimes does serve a purpose that is not just the purely selfish.

[Fradow]

There is a difference between going all the way back to 1995 / reading old documentation vs learning the basics of CS.

This strawman is used in several comments. CS is not "some old knowledge you might never use". Knowing that it's way faster to search by key in a hashmap rather than iterating through a whole array is useful. Knowing why it's a bad practice not to have primary key (and other DB knowledge) is useful. Knowing the stages of a HTTP request is useful.

You can get a job and actually do some productive work without any of that, but that some point not knowing all those basics is going to harm your work.

[freedomben]

> I don't know binary other than 1 is on, 2 is off.

Either an epic troll or a great illustration :-D

[tensor]

I've literally had to use knowledge of binary and number representation just last month in order to implement a lower level protocol. You may not use it in your simple CRUD app jobs but it's absolutely not "some old thing people only had to use back in the day."

[Dylan16807]

> I don't think you need to learn binary to learn to code. Been doing this for 25 years working at some big name companies, I don't know binary other than 1 is on, 0 is off.

I... guess?

But the full explanation of binary is only a paragraph long. At a certain point that seems like something you'd have to avoid on purpose.

[denton-scratch]

> Learning binary and knowing what binary is are two separate things.

Really? Binary isn't a language like Python, it's a notation; either you understand it or you don't (you could say it's 'binary', I suppose). If you don't understand it, you don't know what it is.

[kazinator]

> Learning binary and knowing what binary is are two separate things.

Knowing what binary is lets you generate smooth sounding sentences about it, which someone else who also only knows what binary is accepts as true.

Learning binary lets you actually exploit its properties in a solution.

[foobarbecue]

So when you're reading code and you get to a bitmask... what do you do?

[robinduckett]

Let’s hope you never have to parse an archaic binary format then

[causi]

I didn't know there were computer nerds who can't at least count in binary.

[Swizec]

> There's a difference between being self-taught, and not even bothering to teach yourself the absolute fundamentals of computing, like binary

Been doing this for almost 30 years now, about 15 of those professionally. I think the last time I used binary was in a microcontrollers class in high school.

Even in college, yeah we talked a lot about binary, we learned the single most useful thing in my career – truth tables – and we dived deep into how CPUs toss bits around. Did we ever use binary for anything practical? No of course not, that’s what the compiler is for.

I mean I guess the real question is: What does “learn binary” even mean? Knowing it exists? That’s easy. Knowing that your code is eventually all binary? Yeah great. Knowing how NAND gates and such work? Well that’s discrete mathematics, bool algebra, quantum physics, circuit design, and whatever field of math talks about translating problems from one to another, not “binary”. Being able to calculate, by hand, numbers from binary to octal and decimal? Meh you can have a computer do that or google the algorithm when you need it. Does “learning binary” mean memorizing the ASCII table so you can read hex dumps or whatever? Maybe, doubt a lot of modern engineers still do that tho.

[nmnmnmnmnm]

>Did we ever use binary for anything practical? No of course not, that’s what the compiler is for.

How to tell people you have never implemented anything performance sensitive in your life without spelling it out bluntly in a nutshell. The code of any popular image processing/decoder/encoder/compression/cryptographic libraries is littered with the use of bit operators because they operate at the fundamental building block level of computing, they are the most efficient and the "sufficiently smart compiler" that supposedly always produces the best interpretation is a lie. You merely need to skim through any implementation of jpeg, of h264 or anything that actually matters in this world to see the practical application of working on bits in the real world.

But sure, understanding computer architecture is meaningless. Trust the compiler. Thank gods I can still see stutters scrolling a web page on a 16 core CPU with 64gb of ram. I don't know how I could live my life if people actually knew how to make proper programs!

[tester756]

I'll argue - bitwise operations, they're fundamentals too, but

If you arent working close to hardware, then for example doing bitwise operations may be really rare.

I don't think I've met a problem that required them even once during my first few years as SE.

I've had CS degree and years of experience and I werent proficient with those, I needed to write it down in steps

and then I started working closer to hardware where those operations were common and I've learned it

I don't even remember whether we were doing them in school

[ivan_gammel]

Boolean logic is close to bitwise operations and it is the knowledge without which nobody should dare to call themselves a software engineer.

[johnnny]

I work in networking, not particularly close to the hardware. I have colleagues who manipulate IP addresses by looking at the string representation of the address, splitting on the `.`, casting each part back to an integer, etc. Their code breaks as soon as we use a netmask other that /24 or (shock, horror!) we run in an IPv6 environments.

[hahamrfunnyguy]

I don't really understand the hurdle to "learning binary". It's not necessary to understand how binary works to complete a hello world program, but I think it's something that you want to get a handle on pretty quickly.

If I recall correctly, we only spent a few minutes on it in a larger lesson about different schemes for representing numbers in Comp Sci I. I don't think I've performed binary arithmetic since that class, but it's good to know how it works and I could always look up/figure out how to do those calculations again if I needed to.

[Solvency]

It's good to know how to eat healthy, avoid processed foods, maintain healthy sleep patterns, avoid PUFAs, maintain strong mind-muscle connection in the body, communicate effectively and succinctly and empathetically with others, and many other life skills as well. And they'd all make you a heathier, happier, more robust, performant human. Which translates to better productivity. Better code.

So, should this new programmer start there, or start with binary?

[mynameisvlad]

By your own admission you have never used the knowledge you learned.

Why exactly is it “good to know how it works” if you literally have never used that knowledge? Why is it “something you want to get a handle on pretty quickly” if you don’t touch binary?

Are there places where it would come up? Most certainly. Is it required learning for every single dev out there? Highly debatable.

[plondon514]

I could see there being a future course about binary on codeamigo actually. I'm not saying people shouldn't learn the fundamentals of computing, rather, it's not knowledge that's a requirement to have before building most modern applications.

Before it was "learn C before learning Python" but some people didn't love that either...I guess my point is, we've been moving to higher and higher abstractions ever since computer programming was invented, the next abstraction is probably going to be talking to an AI to write some code that you need to vet, the above is just marketing speak for that.

[luuuzeta]

How are courses created? Who creates them?

>Made with in

How did all the haze treats you yesterday?

[i-use-nixos-btw]

It would be unsettling for a software engineer to have little knowledge of the fundamentals.

But software engineers aren't the only people using python. I work with data scientists - with degrees in data engineering from computer science departments in very good universities - and I am certain that they believe a computer to be a magical box. I know for sure they're terrified of binary. Honestly, I'm looking forward to the day that they actually use functions and classes properly.

I wish I was exaggerating, I really do. It'd make my life easier. And it is no surprise - I've seen the supplementary material attached to papers that come out of those departments. I won't go into too much detail, but I don't know how any codebase could more closely resemble a house of cards and still function.

They still have successful careers in what they're good at. After all, one of the main reasons that python is so successful is that it can be used by people who don't know much - or care much - about programming. It can obviously be used by far more capable hands to do many more things, but for applied tasks it takes the pain out of learning something that they consider tangential.

[haswell]

Realistically, one can achieve quite a lot without needing to ever think about binary, and today’s languages/frameworks explicitly enable this.

I’m not arguing that someone shouldn’t eventually teach themselves more fundamentals as they mature their skillset, but most modern languages are so many abstractions above binary that it’s more of a distraction while learning about the basics of code in the context of real world use cases.

Understanding assembly on some level is in a similar category.

I think of this more as an avenue for specialization. One need not learn these things to get started, but they may very well need these things if they want to continue their journey past a certain point.

[asow92]

Seconded. And I'd posit that learning CS theory and fundamentals like binary shouldn't be too difficult if the individual is savvy enough to grok the finer points of Python.

[echelon]

I dislike this perspective.

I taught myself programming at age 12, well before undergrad.

If I'd been forced to learn binary before I could make websites and games, I would have given up. I might have even avoided programming forever.

I think the very first thing someone should learn is the fastest path to build something that interests and delights them. Theory can come later, when they're ready to appreciate it.

[ChrisMarshallNY]

In my case, I started with the FET junction (electronics).

My first program was Machine Code, designed on a pad of lined paper, and punched directly into RAM, via a hex keypad.

These days, I write Swift. It's nice to not need to deal with the way Machine Code works, but I'm glad I learned it.

That said, everything we learn takes up NVR, so there's a strong argument to be had, against the need to learn below a certain fundamental floor.

[robomartin]

> My first program was Machine Code, designed on a pad of lined paper, and punched directly into RAM, via a hex keypad.

Yup. That's also where I started. In fact, I still own one of these in mint condition:

https://www.hewlettpackardhistory.com/item/making-a-case/

I truly believe the low level fundamentals are crucially important. Even today, in the days of Python and Javascript.

Not to go too far, about a year ago I was working on an embedded board we designed which used MicroPython. The communications protocol required IBM CRC-16 to be calculated. MicroPython could not run this calculation fast enough. Since MicroPython allows you to insert code in assembler, I just wrote the CRC routine (an many others) in ARM assembler. The performance boost was, as one would expect, massive. Writing the code wasn't a problem at all given my background.

Having this knowledge also allows you to reach for optimizations that someone who has only seen high level languages and (as posters elsewhere in the thread have revealed) don't understand low level code or even binary. A simple example of this is that comparing to zero is faster than comparing to a value. The simple explanation being that you have to juggle registers and perhaps even read and store that value from memory every time you go around a loop. All processors have the equivalent of a JZ and JNZ (jump if zero, jump if not zero) instruction, which does not require anything to be fetched from memory or register swapping. Of course, this is processor and task dependent.

And then I wonder about such things as DeMorgan, bit-wise operations, masking, etc. I was surprised to read some of the comments on this thread about people not being comfortable with binary beyond 1=true and 0=false. I don't understand how someone can develop non-trivial software without having a solid foundation. I mean, even for CSS you should understand what "FFC21A" or "3FE" means, where it comes from and how to work with these numbers.

[xbar]

The pathways formed by all those fundamental and low level operations create capabilities and reasoning strategies that are very valuable. Perhaps they are even unachievable in other ways.

[LoganDark]

> Today's developers didn't learn binary before learning Python

I didn't learn binary before Python. I learned Lua before Python. But now I'm messing around with low-level C++, and Rust.

Where you started doesn't necessarily have anything to do with where you are now.