Having finished a CS undergrad and followed the OSSU curriculum for some years I can confidently recommend https://teachyourselfcs.com/ instead. The courses chosen are more focused on capital-C capital-S Computer Science, and the resources are better suited for self-paced self-direction. One should start with https://teachyourselfcs.com/ and refer to OSSU if they find the former lacking in some measure.
Self-teaching computer science is a long and winding road. OSSU seems to favor a completionist approach that most people would do well to avoid. Grok on the fundamentals and quickly specialize, because life is too short to learn computer science in an encyclopedic way.
One course from OSSU I personally recommend to add onto Teach Yourself CS is “The Missing Semester of Your CS Education”[1]. For those unfamiliar with the tools needed to work through something like SICP, this course is a godsend.
I think expectation management is important and as you note:
> Self-teaching computer science is a long and winding road.
What does this mean in terms of years? My estimate for the not too persistent average person is, that working through (not only read once, forget) all of the books listed on that website could well take 10 years. For someone very focused maybe 5 and for one working "day and night" on it maybe shorter.
Just to give an idea: SICP, the PDF version, has already 800+ pages and many many challenging exercises to solve. That alone could take a year or more, depending on how easily it comes to a person.
That said, I often find the website to build up a huge wall against which anyone with not 100% motivation will crash. It might not be a realistic program for most people and I would rather recommend one item after another or smaller parts.
Years ago I saw someone who was starting out in a specialist forum lament that everyone else on the forum was so much further ahead than they were. A user pointed out that the type of people who spend a lot of time on specialist forums are going to be among those most dedicated to the field, and just by visiting the forum and trying to improve themselves in that domain the individual was probably better than the vast majority of the people working in that domain.
If you’re goal is to have the same amount of CS knowledge as the average person with a CS degree who’s a few years out of college, it probably wouldn’t take that much time. Extremely few - I’d say almost none - CS graduates have gone through the entirety of SICP. You can read the other comment where someone said they went through it after getting a degree in computer engineering, and a lot of the concepts in it being new to them.
How long will this take? If you’re focused on learning as much as you can, it’s a never ending journey. But you probably won’t find a use for most of the knowledge (more and more so as you go along), so it’s going to be a hobby for the most part. If you’re just trying to cover the topics that people say you need to know (IE, the site gives understanding recursion as a reason to go through SICP), I imagine you could learn most of them surprisingly quickly.
I expect the "not too persistent average person" would make zero progress, as my experience is that the average person learns very little unless forced to do so.
For SICP, I read through the year after finishing my undergraduate Computer Engineering degree. I had a decent background, but a lot of the concepts in SICP were new. I loved the book and got through it in a few months of train rides, doing most of the exercises in my head. I feel that was sufficient for me, but I also don't think I'm in any way the "average person" when it comes to this domain.
> What does this mean in terms of years? My estimate for the not too persistent average person is, that working through (not only read once, forget) all of the books listed on that website could well take 10 years. For someone very focused maybe 5 and for one working "day and night" on it maybe shorter.
College courses don't go through books from start to finish. The instructor determines what's appropriate and what's left to the reader (and these books can be picked up many years later when someone recognize a gap in knowledge that's covered).
However, what's missing from these books are group assignments and mentoring from a proper instructor.
> Just to give an idea: SICP, the PDF version, has already 800+ pages and many many challenging exercises to solve. That alone could take a year or more, depending on how easily it comes to a person.
You aren't supposed to go through the whole book, especially for an intro class using SICP.
As a long time self learner the single hardest part is where to draw the line between conpletionism/ just good enough. College has this built in because an instructor will teach and test the most important parts.
Alone you always worry if you skip something it will come back later. Math is the worst- trying to complete a textbook could easily take years.
I went through most of the books listed and did the exercises. This happened over the span of 6ish years but I was not always consistent.
Timing is really hard to nail down because your strength as a programmer and engineer really come into play. SICP, for example, took me about a month of putting in a few hours a day. As it turned out my professional experience had given me significant experience with many of the concepts involved.
Conversely, for Computer Networking: A Top-Down Approach it took me 6+ months because I'd never had meaningful experience with networks outside of browser dev tools and was not very good at systems level stuff.
When I was young, generating visual things was my gateway-drug to programming. With all the tooling, frameworks, workflows, concepts, etc. that you have to learn today in order to do even simple things, programming can become pretty overwhelming to someone who is just starting out. Processing is like a sandbox that is simple, but still keeps you close to the metal and provides a fun and liberating environment to grow your skills.
It may not be for everyone, which also depends on what your son is interested in building, but creative/artistic expression through code is something that I believe everyone should experience at some point.
There are many great learning resources for Processing that cover the whole spectrum from very easy stuff to more advanced projects that involve physics simulation, fractals, 3D graphics, etc. I especially recommend the video lectures by Daniel Shiffman, who teaches even advanced topics in a fun and engaging way: https://processing.org/tutorials
freeCodeCamp the website with its main curriculum is really good.
freeCodeCamp, the YT channel and republisher isn’t that good.
They hoarde all kinds of stuff from other people on YT, and not all of the courses have good quality. I have seen some awful explanation/teaching in some videos on the fCC YT channel.
100% possible to be a self-taught software engineer. I have hired many over the years. The hardest part is breaking into the industry, but once you have some experience and references the degree doesn’t matter for many high paying companies (although FAANG and academia might disagree).
When I interview ICs it is a very free flowing conversation. When there is a lull I will jump to a new subject. I will just start asking things and keep going deeper until I exhaust your knowledge.
“What is the command for listing directories in a terminal? Name a flag you can use - what does it do? How do flags actually work anyway? Do you know any libraries for CLI parameter processing? Ever heard of argc and argv? How do you think those variables are mapped into memory of the forked process?”
I go on and on and on. If you just become obsessed with computers and software engineering and put in some years of effort you can beat what school charges you for. Plenty of MIT and Brown and Harvard grads don’t know fuck all about software development. Credentials are a signal for sure but that is all they are.
In many European countries it isn't, as being Software Engineer is a proctected title, can only be used in legal contexts if the admission exam was taken, and the university was reckognised by the state as providing a proper Software Engineer degree.
The English name "Software Engineer" isn't protected in German speaking countries, but their German equivalents are:
- The German equivalent would be "Diplom-Informatiker" (which roughly translates to "certified computer scientist"), which you're awarded after completing a graduate degree/MSc in Computer Science.
- In Austria you'd be awared a "Diplom-Ingeneur" instead, so a "Diplom-Ingeneuer in Informatik/Software-Entwicklung" would be a "Certified Computer/SW Engineer".
In France (and Italy afaict), the "engineer" title is protected. You can have the function but won't have the title of you're not from a sanctioned engineering school.
That being said, nobody cares about it in CS expect for government and very large companies which will use it against you in salary negotiation.
> You can have the function but won't have the title of you're not from a sanctioned engineering school.
My understanding was that is was true throughout the French world (so French speaking Canada does this as well)? And that the curriculum for Engineers was more rigorous than other disciplines (there's a strong emphasis on math, you have to do some economics and so on)?
At least in French speaking Canada, the curriculum for software engineers is not really anymore rigorous than the curriculum for CS (of course, depending on your university). Even in math, some math classes are less rigorous or watered down for engineering, while some are taken by engineers but not necessary for CS students.
My understanding was the curriculum had more classes (a year longer) and less flexibility for course selection (you can't major in CS and get a minor in history for instance). Your electives are going to be engineering classes.
In the French Canadian system you generally don't do major/minor, you study only one field. It's relatively rare to do it another way. Electives are the same that way but you have 5-6 engineering-only societal classes (economics, ethics, etc...)
In Italy Software/Computer Engineer (Ingegnere informatico) is indeed protected, people usually refer to themselves as software developer or programmer unless they hold an engineering degree. The story is somewhat different when it comes to networking where it seems no one goes without the title. As long as you can prove you know your deal it isn't a deal breaker for private companies.
Just the term 'engineer' is protected in parts of Canada, and it's at a provincial level if I remember properly. The 'software' part has nothing to do with it. That said, the term is protected really weirdly. The standard is 'would a reasonable person think you can provide professional engineering services'. So seeing software engineers call themselves such is very common. I suspect the lax attitude here is because nobody would reasonably expect a software engineer to sign off on the structural integrity of a building.
In Ontario, the PEO (board that manages these things) hasn't gone after software engineers often. I don't think I've ever heard of a prosecution in general, and may people call themselves XYZ engineer without having the P. Eng designation. They tend to prosecute civil, and industrial engineers, and building related engineers more since civil engineering and a Civil Engineer have very different roles. Even then, you have to be pretty flagrantly disregarding the regulations to make yourself a target.
The only people who'd given me a hard time over the job title 'software engineer' were engineering students during my undergraduate degree.
To elaborate, the distinction is professional engineering. SO not just structural integrity of a building. Under the Professional Engineering Act is:
>“practice of professional engineering” means any act of planning, designing, composing, evaluating, advising, reporting, directing or supervising that requires the application of engineering principles and concerns the safeguarding of life, health, property, economic interests, the public welfare or the environment, or the managing of any such act; (“exercice de la profession d’ingénieur”)
In principle, there's certainly a good justification for the protection of the title, but the reality is much different. There's probably a case for regulators to actually figure out what meaningful licensure would mean for Software Engineers or companies but that'll never happen. There was a time where I thought 'Software Engineer' was a relatively uncommon title due to this case, but it appears Ontario employers have become much more lax about this.
If you say "software developer" there is no problem. If you say "software engineer" in many places that has an additional implication of being a professional engineer.
In Romania the term is protected too. That didn't stop me from having a career as a software engineer, just my title was not that. And the company lost the tax discount for employing a "real" swe. Guess my contribution was worth it.
It doesn't matter if it is a protected title, if a given company has the discretion of hiring whoever they see fit to perform the role, as - in most cases - there isn't a legal requirement of hiring an actual certified "engineer". They can hire a certified janitor to fulfill their software engineering vacancy - because the job title is actually a career path and not a recognized certified title.
Also, "software engineer" is an umbrella term within the industry; Very few "software engineers" are actually engineers (I don't recall meeting one software engineer that actually has the right to bear the title "engineer" - which, in my country -Portugal - requires being admitted in the Order of Engineers); The same goes for all "software engineers" that have actually graduated in mathematics, chemistry, electronics, telecommunications, biology and even design.
You may also find amusing that very, very few solution designers are actually designers, and even less software architects are legal architects. Also, often a cloud engineer or cloud architect has no idea on how to design proper rain.
In your country, that happens to be mine as well, the university degree can only legally have the name engineering on it if approved by the Order, regardless if one ends up joining it or not.
One cannot just go around doing a six months bootcamp and then call yourself engineer without having studied at such university.
And those that sign legal contracts for project deliveries specially with government agencies, better have done the Order exam, if they want the Eng. on the signature.
Then again, if they happen to turn out to politics and even reach prime minister status, it doesn't really matter how they managed to get hold of the "engineer" title.
Again, as the parent commenter, you're confusing academic degree with job title. You cannot call yourself an engineer if not enrolled in the Order (regardless if you have an engineering degree or not), but you can assume a software engineering role without any issue.
Tell that to HR, profiling CVs from enginering degrees taken at universities validated by the Order.
Naturally if one is at their own company, they can call themselves whatever they want, until they become invited to government and background checked on some TV channels.
Have you ever steered a HR hiring process for "software engineers" in the private sector? More often than not, HR doesn't give a rat's ass about which university or degree the candidate has, nor if he is a "proper engineer" or a janitor. What they care about is experience, reliability and how well the candidate will fit the team.
You are still confusing job titles with credentials. In a private company, you can use whatever title you want for a given role, and you can hire whoever you want for said role, barring some legal limitations of scope (eg.some documents need to be signed by certified accountants - even if the job title is "Scrooge McDuck in Chief", some documents will require a lawyer signature, even if the job title is "Major Wolf", etc). You can name the CEO role "master dictator" and no one can do anything about it. And as you already know, no one but pompous self-entitled code monkeys calls themselves the Portuguese version of "software engineer" when they describe their job.
Also, Government isn't private companies. The Government itself hires very few "software engineers", as most implementations are done by private companies. The most obvious exception is, of course, teaching - and even those rules may be easily tweaked if you are outstanding in your field, or have done outstanding work on a specific area - something that frequently requires bright minds and middle-school level skills. On a fun note, there are even some fringe cases where you can actually legally teach recognized courses (upto level 4) without any formal education in that specific field. This is often an exception - not a rule - and needs to be thoroughly documented, but perfectly legal.
I only see this kind of nitpicking and fencing on guys that come out of the academia and think that the "real world" (translation: most, but not all vacancies) cares about titles, grades and (often bad quality or irrelevant) published thesis. I'm not saying a degree isn't important - or even obligatory requirement in some cases - but those are often the exception and not the rule.
Yes, hence why when one doesn't want to pay for the final exam or monthly payments, or has the resposabilitie to sign legal documents with liability, gets to be called Software Developer, Programmer or similar.
Still doesn't go around the fact that universities need the approval for teaching the said degrees.
I concur - I'm completely self taught (my special interest has been computing and software development my whole life) and the first job was the hardest. Now that I have work experience on my resume, nobody asks anything about my education background (or lack thereof), and I've gone from getting an occasional response to applications to consistently getting responses to most of my job applications.
FAANG doesn't disagree, or at least some of them don't. And to my mind that makes sense, because their rigorous interviewing process should give them confidence in their hires, regardless of credentials.
That's the flip side of the interviews that everyone here complains about. Lots of people working there couldn't get a tech job elsewhere, but these places don't care much at all about resume (for lower levels) once you start the interview process.
> The hardest part is breaking into the industry, but once you have some experience and references the degree doesn’t matter for many high paying companies
I thought teaching might be a good laid back alternative income. Now schools consider you without a degree.
My path into tech has been really hard without a proper cs degree. Even after my first and second jobs I had a real hard time. I found my way through ops/DevOps/sre
Did anyone else cruise through college with their programming experience developed as a kid, only to come out with an excellent knowledge of practical computer programming (i.e., learned several languages, touched most of the frameworks, able to deploy full-stack apps alone) but a complete lack of mathematical and computer science knowledge? And if so, did you ever go back and re-learn some of these fundamentals and find use in it? I'm in this situation now, and while I feel confident in my ability to do my job, I feel jealous of peers who are able to solve complex algorithmic problems, or understand mathematical problem domains with ease (e.g., machine learning)
I kinda did. I graduated with a degree that covered a lot of maths that I, a callow youth, thought was bullshit. A few years later I discovered it was useful for machine learning, and given machine learning was something I was interested in the maths suddenly became interesting. I don't think my maths or theoretical CS knowledge is amazing but I quite like those topics now, and don't seem to struggle to learn them.
You'll find a bunch of tech recruiters asking you about Big O notation for the algorithm you propose. They want to look smart. Most of the times you'll smell shitty code, inefficient loops, slow I/O, waste of memory without formal methods.
An old example from the beginning of the century: if you did matrix algebra you could have understood how to rotate an object position in 3D for a game using math but find it very hard to code. Or you could take Michael Abrash's Graphics Programming Black Book [1] and learn it anyway.
You'll do fine.
Yes. I didn't even study math or comp-sci in college. Learned to program BASIC for build BBS systems when I was 12 (in 1982). Took two Pascal classes (1 in high school, one in college while I studied psychology). Discovered I could apparently program professionally while an intern for a startup. Turns out, computer languages of all sorts come to me pretty easily, probably because of that early exposure.
I've ended as one of the better programmers most places I've worked, and my current role is as a director and software architect at a mid-size biotech company (building tools to facilitate genetic engineering; if only my teenage nerd self could see me now!).
I still have no real advanced math or computer science training. My approach and experience is entirely practical/pragmatic, and for user facing applications development, I've almost never felt the lack of comp sci training impacted my work. I think of myself as a bit of a hedge witch :).
That said, I sometimes have pretty extreme imposter syndrome, and find myself bowing out of of roles that would otherwise be exciting but math heavy, especially ML heavy stuff that's all the rage these days.
I still think I'd like to study computer science, fwiw, but there are only so many hours in the day and I am a person with a whole lot of competing interests.
I am exactly in the situation you are describing. I've always enjoyed math but never took it seriously, and now I regret it. Just cruised through college because no advanced math was ever required.
So I'm taking a math course in the evenings and going to try university this year!
I had the opposite experience, but I did an undergrad in CS in university, not college. Learned lots of theory and algorithms, and low-level programming, but hardly did any practical stuff like app deployment.
In the US, there is no distinction between "college" and "university" like some places have. Here the difference is solely that a university is collection of colleges that share admittance and funding to some extent. I attended the college of arts and sciences at my university, but I easily could have taken (some) courses offered by the college of architecture and allied arts, had I been so inclined.
I wouldn't put much stock in word choices like that. Connotations vary so immensely around the world, it's best to presume they're synonyms unless context says otherwise.
A university offers graduate degrees. Colleges offer only up to bachelor degrees. There may not be a distinction in how people use the words, there is a difference in actual fact.
There are also plenty of 4 year institutions called "Colleges" here that are smaller too. Bowdoin College is a random example which even has a CS degree.
I did the opposite. I received what I believed to basically be a bachelors in math with very little real-life coding skills. Yeah, I programmed a ton in my classes, but looking back it was "spaghetti code." I've had to read about principles and patterns of software engineering almost unrelentingly to feel up-to-speed. Thank heavens for "Clean Code."
Boy, I can't wait until that magical day where I can bust out my knowledge of that Pumping Lemma, though, for those proofs I need to... always be writing...?
This describes me pretty well. I started programming when I was very young. I did programming classes in high school. Then in college I started with another major and switched, but quickly got through as many classes as possible to graduate and get a job without really thinking about any of the stuff I had the opportunity to learn. Now I feel a bit locked out of certain companies because I'm not good at HackerRank, but I make really good money as a Software Engineer at a non-tech firm.
I went through the opposite where I learned programming through college but I still don't understand ML math nor complex algorithm problems. I mean I tried taking those courses but I only got through regular DSA class and the first week of ML but dropped out cuz I was not good at the linear algebra required to understand. Maybe I'll try again someday on my own. I admit I wasn't the greatest student though. Graduated with a 2.7
I was educated as a biologist but I am now a full time software dev (perhaps a light version, I just do Python/bash) with some science elements. I was able to make this switch because I have always (since the 2.4 kernel days) enjoyed Linux and self-hosting as much as possible, including email, which I, as 99% gave up on later again).
It basically made me a sys-admin, many people around me do docker these days, few can diagnose issues with Docker itself, route traffic around with valid certs, open a shell inside a container to really see what's happening. But I just feel at home inside Linux. I know my way around /etc, I know how I would do things and that is how things often are. It helps me a lot in my daily job. I feel like the whole stack is an open book to me. I still listen to a lot of Linux podcasts (like most Jupiter broadcasting shows), that also helped me a lot, also keeps me informed on recent tech.
A bit like me. Got started setting up a webshop for my first startup and had to learn Apache and PHP.
If anyone with similar skills (Python, Docker, Shell) reads this and looks do get started, do check out our Google Summer of Code projects for this year. You'll get paid and can pick any task in this field: https://github.com/borgbase/vorta/wiki/Google-Summer-of-Code...
I can confidently say that my whole career in software development has basically been the result of riding the wave of a Linux hobby I had. I didn't actually mean to write code for a living but I accidentally walked into the wrong interview and knew the solutions to some common puzzles off the top of my head. It eventually led me to being an early adopter of Docker which dazzled a lot of folks at the time and I guess still sorta does.
I ended up doing this for a tiny team of biologists a few years ago. Worked on their open data portal, writing python plugins for a flask/pylons based framework, managing Postgres a bit and the vm it was running on. Fun job, meh pay, total autonomy, good place to be.
Me too, I just started a company (wouldn't call it a startup), I manage their data, add some Synology Nas's, a Nuc for data processing, a Wordpress website, rsync some (NGS) data around, process it. Tied it all together with Tailscale.
It's a lot of fun, I get to choose my own preferred tech which is really nice (I have strong opinions).
These types of sites are great. BUT. The concept hasn't properly evolved since the 1970s-80s when I assume it started to become pretty big.
I think the reason 99% of people study computer science is to get a computer programming job. Almost all programming jobs are actually software engineering jobs these days.
So I believe that at least one third of a degree program like this should actually be software engineering.
And the most important part of software engineering is the outer loop with clients or end users (or some stakeholders). So they should train on multiple project iterations with some external group as customers.
So the interaction with customers, defining requirements, the basic looping of iterations and maintaining software and evolving designs and technical debt, somewhat larger codebases that make modules/components/classes etc. more important. A lot of that should be integrated and probably even replace some of the lower-level stuff that would have been much more relevant in the 1980s for most application programmers.
It should be multiple projects that get evolved over the entire course.
Also another thing, a key tool to add to an education like this would have been active Google searching and learning how to do that, which should be at least a small part of the curriculum. Since the last few months, another key tool at least as important is ChatGPT.
The technology landscape changes rapidly. Education should keep up. Especially if its self-education, no reason to be stuck in the late 80s or early 90s.
> Since the last few months, another key tool at least as important is ChatGPT.
Could you elaborate on this? Why do you think it's such an important tool for software developers, and how would one go about learning or teaching it?
Also, what should be an appropriate interval between the appearance of a technology and its inclusion in a curriculum? Curricula, by their nature, tend to be fundamental and conservative.
Because it can literally write the code for you in many cases. It can help you find bugs in your code or refactor it. Do a code review for you instantly. So even if you believe for some reason that you should never use a tool like this to actually write code, it can make suggestions for improving it, in seconds.
Curricula should not be so conservative in this age of high technology. Especially in a highly technical field.
> Because it can literally write the code for you in many cases. It can help you find bugs in your code or refactor it. Do a code review for you instantly. So even if you believe for some reason that you should never use a tool like this to actually write code, it can make suggestions for improving it, in seconds.
In that case, wouldn't it be more useful to teach students regular software engineering skills that will allow them to check whether the code generated by something like ChatGPT is correct / appropriate / fit for purpose?
I guess I'm wondering what is it that a CS course would need to teach specifically about ChatGPT.
Agreed, theoretical computer science education can be considered a luxury, as it is not typically required for the average programming job. Even if it is needed, you will still need to invest time in revisiting it. It might be more efficient to learn the theory from scratch as needed, as that time could be better spent learning practical skills if your goal is to find employment.
>I think the reason 99% of people study computer science is to get a computer programming job. Almost all programming jobs are actually software engineering jobs these days.
With my recent encounters with new-comers and juniors employees, this has become a big commonality
> And the most important part of software engineering is the outer loop with clients or end users (or some stakeholders). So they should train on multiple project iterations with some external group as customers.
100%, I've become an advocate for this in my recent roles. Something as fundamental as applied communication between different contexts is underrated in a lot of curriculums I've heard of from.
>So they should train on multiple project iterations with some external group as customers.
That would almost be a Psychology course. Include stakeholders who don't really know what they want, who think they know what they want but constantly "rearrange the furniture," and who try to give you the solution rather than the problem. This would be a great idea. For this to be effective, it would probably have to be 2 semesters, 1 for theory and 1 for practice. It's a great idea though. Get rid of some of those Calc/Physics classes.
I had a professor tell me one time that the "meeting of the minds," between stakeholders and the developer was the hardest part of building software and that getting specs was like "pulling teeth." He wasn't wrong.
> So I believe that at least one third of a degree program like this should actually be software engineering.
How about an actual software engineering degree instead?
As others have said, it should teach interfacing with non-tech people, extracting requirements, reacting to changing requirements, and so on. But it should also teach things like source code control systems, bug databases, dealing with large long-lived code bases (go find this bug in this 1,000,000 line code base, say), what languages work best for which kinds of problems, and so on.
Maybe one third of that degree could be classical CS.
>Almost all programming jobs are actually software engineering jobs these days.
Not quite. Most all programming jobs are translation jobs, where you take some business requirement and put it into code. Which is why GPT models are going to render most of those jobs obsolete.
That depends on how trivial and stereotypical the tasks fulfilled by that role are. Sure, writing simple functions or accessing databases and loading or unloading form-based user interfaces should be easy enough tasks to specify easily. These will be automated first.
But designing a user interface that's intuitive or chooses sensible default values, especially one that isn't "typical" (where a business model or user use case already exists), or one that's not trivial to specify, or complex to integrate into a workflow -- these use cases will require iteration in order to specify useably. And revision of a specification is an ability where language-based specification tools like GPT have yet to prove themselves -- like activities such as interactive debugging or the performance tuning of an implementation.
How do you describe a task to ChatGPT that isn't yet well defined and still requires iterative refinement with the user to nail down? Until ChatGPT can perform Q&A to "fill in the blanks" and resolve the requirements in a custom task, a human in the loop will still be still needed.
Think of ChatGPT as a way to code using templates bigger than the ones used today. Initially it's templates will be smaller than the average function. It's hard to know how long before its templates will grow in size and complexity sufficient to build a full blown app, unless that app is pretty trivial and requires no customization. I'm guessing it'll be years before it creates apps.
I think of ChatGPT as a way to dynamically generate grails scaffolds.
A scaffold is basically a code template that gets you started with writing a particular class so you don't have to start from zero.
ChatGPT is an amazing scaffold generator, which isn't suprising because that is one of the defining features of an LLM but people extrapolate this and say absurd things that simply trigger my bullshit detector.
But ChatGPT hardly listens to my instructions and the severe case of Alzheimer's is quite annoying and even then, who is going to write the prompts? It's not like your project manager/customers actually write clear requirements or have any actual knowledge about how their infrastructure works.
Prompting an AI to write text is also quite a slow back and forth process that took me two hours for a basic class I could have written in 5 minutes but since the AI can answer with bullshit in five seconds I am now obsolete even though it needs multiple iterations and reading the code is the bottleneck and I practically did all the work. (Integrating the code into my project and doubling the lines of code because asking it to make the modifications and additions is just way too slow. Typing is just too damn fast to bother. Maybe teach your developers touch typing so they don't suck versus AI?)
Translation where context is whole apps, spread over dozens or hundreds of files, with complex interdependencies is also a form of integration. And chatGPT doesn't have the context size to do it, maybe the next GPT. But 4000 tokens is not enough, 50-100K tokens would be more like it.
Well.. yes, it is a stretch to use it for a large code base, but especially if they are all relatively small/medium sized files, a directory listing can get you pretty far to select the relevant files. You can also do a vector (embedding) search to find relevant functions/files and feed that into the prompt.
Also the OpenAI coding model code-davinci-002 has an 8000 token max not 4000 like text-davinci-003.
You can ask chat GPT now the following question "Given this Json as input, and this json as output, write code that transforms the input to output", and it will get it right. Try it out sometime, and then realize that like 80% of backend processing.
There just needs to be more targeted training, and some system built around it to write a complete service code, and you can replace a good number of jobs solely through that.
20 yoe. Never had to write code to transform json into json in a pure way. Maybe XML to XML … once. Good ol XSLT!
By pure I mean with no other requirements such as accessing another data store and running a bunch of rules decided by having several meetings with various people to find out what is actually required… a bit like what chatGPT doesn’t do.
Ya, it's tricky to map that comment to a useful scenario, but maybe getting a json document from an external service and saying "write a function that parses this json and returns this TS structure, but I think that would be a rare efficiency killer for me
Generally transforming the data is not the hard bit, it's specifying the shape. You're not replacing any meaningful jobs by getting GPT to automatically translate one schema to another, you're improving the productivity of existing devs.
Not always, a well written software contract will generate additional fees/income when analysts or businesses fail to stipulate all requirements.
On the point of >Almost all programming jobs are actually software engineering jobs these days.
Thats a very narrow view of Computer Science, ignoring how software and hardware can be exploited in air gapped scenarios, exploiting what the military have traditionally called Signal Intelligence, not something taught in any university or online as far as I'm aware of.
The undetectable metadata by human senses because of restrictions like our range of audible sounds, ability to detect tiny fluctuations of electromagnetic radiation, lack of knowledge of a devices ability, makes most computer science graduates somewhat blinkered and restricted in perspective and highly exploitable, with hubris being the number one attribute for most.
IMO Computer Science should be viewed more as a natural science, incorporating things like physics, biology, psychology, chemistry along with what's currently taught in a stereotypical CS course. I'm reminded of the fact that my language debugger is an excellent colour blind test operating in plain sight and when you become wise to these additional points of interest, you start to see the chaff from the wheat, whose good, whose not because Only the Paranoid Survive!
Central heating and hotwater systems, some home security lighting systems, some vehicles, many electronic devices with a cpu of sorts inside. I think its really quite common when you think about it.
Are you a bot trying to resource burn me? If a bot, would you even know you are a bot?
>basic looping of iterations and maintaining software and evolving designs and technical debt, somewhat larger codebases that make modules/components/classes etc. more important.
Can anyone recommend a good book for this? I'm getting the hang of lots of other 'TYCS' topics, but I'm mostly building little toys for myself to try out cool algorithms I see in my books/resources. But mention CI/CD, large module & class design, or other 'big software' stuff I get very intimidated.
Can someone point out where the science in all this is? At best, there are some courses in algorithms in the 'Core Theory' and others in the 'Advanced Theory' section, with a random spattering of in other sections.
Computer Science would be computational theory, complexity theory, a proof based cryptography course, the mathematics of computer geometry/machine learning type stuff.
About 80% of the courses here are software engineering courses - about using computers to build things. The quote 'computer science is as much about computers as astronomy is about telescopes', comes to mind.
Just call it 'a self-taught education in Software Engineering'.
That ship has sailed a long time ago. "Computer Science" today means basically any topic vaguely related to computers. You can get a "Computer Science" degree by focusing on design theoretical type systems, designing CPUs, designing business processes or designing user interfaces. I think it's fair to say that we've lost this battle.
Ironically, pretty much the only subfield of computer science using the scientific method in any significant capacity is software engineering.
Historically and foundationally CS is a child of mathematics and electrical engineering, neither of which really fit the narrow English term of science.
CS is mostly preoccupied with a) making (useful) deductions in closed logical systems, and b) building cool shit. Empirical knowledge generation is usually only relevant as a tool to help us with the first two goals.
Yes, a lot of CS is mathematics (and EE), but it is not just that.
There is a notion of experimentation in pure CS, because CS asks the question, what can be computed on physical machines. And to check that, you actually need to build and check.
Nothing illustrates this better than Quantum Computing. Computer Science (and Physics) theories predict the existence of quantum computing, and suggest a computational advantage, but we will never know unless we build QCs and experiment.
The situation isn't any better at universities. Even at the top-10 universities you can get a "computer science" degree taking at most the standard discrete math + algorithms courses. (And not to mention, there's apparently even one university where you get to call yourself an "electrical engineer" without even touching signal processing or anything more advanced than RLC circuits.)
Correct, and I criticize them too. But universities do it because they presumably want to cash in on the prestige of associating the degree with 'science'.
A standalone course, which presumably comes from the ethos of rejecting degree-based education, is completely free to call a spade a spade.
I forget what lecture it was but Feynman thought the idea of "computer science" as a bit bogus and that it is really all computer engineering.
To me, it is that at our core we are a society of marketing bullshitters. The vast majority of daily activity is marketing falsity as truth to each other in basically all context.
Who bets against mathematics loses, almost always. While that is true, CS people also snicker at mathematicians, because they usually are not able to write good and readable code, unless they also have significant outside of math coding background, which they usually do not.
A large part of me feels like this is an oxymoron. Someone who is capable of self-teaching this content is probably not going to need such a structured program. At best, this would function as an aspirational index for them to refer to.
This also covers a lot of things you should probably not be studying as self-taught dev, since there is a much larger opportunity cost because you are not at university. I like calculus and maths, but that knowledge is low value for a developer.
Once you've bootstrapped a basic understanding of programming and CS, I think you should be building stuff 80% and reading up on new things that catch your eye 20% until you hit diminishing returns. Reading about things like SOLID, DRY, algorithms, OOP, etc is just not going to stick. You need to build stuff and start getting an intuition for the concepts.
Immersing yourself in community discourse is also very underrated. You will pick up so much jargon and be exposed to lots of different concepts and tools just by hanging out where other programmers talk, like on HN, Twitter and Reddit.
I think this depends on your ambitions. As someone who made the transition from math education to CS I knew that I wanted to be a seriously good engineer making top of market. One of the first things I did was build myself a curriculum similar to https://teachyourselfcs.com/ (not sure it existed back then). I'm pretty confident this is a big part of what's made my career both because it's trivialized most interviews and because being competent up and down the stack is rare enough that I can often generate outsized impact with relatively small changes.
Obviously this is not what everyone wants in life, but it's a fairly straightforward path to career success and financial independence.
Aside: any good curriculum definitely needs to include building, learning is not a spectator sport.
If you can afford to spend the time learning the full CS curriculum before you get your first job then sure, it's a good strategy. But most people don't have that luxury. I don't think it's at all related to ambition, it's about the quickest path to getting a job.
If you want to be a top engineer you will need to learn CS stuff at some point, but you don't need to do it all at once right at the start.
Often unnoticed but very important part of the traditional education is having the peer group to compare yourself too. The desire to copy and compare each other kicks in and now it's no longer just about getting grades but rather how do you relate to each other in your common path. It would be cool if this was somehow replicated in MOOCs.
Absolutely. One of the things that helped me grow as a software engineer was to talk to and hang out with my peers that you could tell were great at it. We generally had a lot in common since we all loved programming and the related things around it which helped become friends.
Sometimes you'd meet someone who is just leagues beyond the average CS student, and they were often great and humble people. Spending time with those people, talking, studying, and just hanging out with them led to a lot of learning (and not to mention good times).
I don't think the point of universities and degrees these days is to learn anything. It's just something you have to do in order to get a good job. That was certainly my experience. I went to a so-called top university, and I didn't feel like I learnt anything remotely relevant to what I do today. All I got at the end of it was some letters after my name.
According to one model, students have three primary motivations: 1) passing the classes and getting the degree; 2) getting good grades and otherwise being good on whatever is being measured; and 3) learning things. Teaching is most rewarding when the third motivation dominates, but the other two are often the necessary evil that pays the bills.
A BSc or MSc in STEM is all 99.997% of immigration and Human Resources people care about. Thus, if your goal is to augment your existing degree, than a self-directed or short certificate program is fine. However, if you want a commercial career in CS without a upper-level degree, than you may as well waste your time doing something you enjoy instead.
There is a huge gap between the theoretical and practical aspects of CS in both the academic and professional fields. Generally, most college programs have lab driven smaller classes, and produce better coders (ready to go in a few months). However, university level programs tend to produce primarily theorists from thousands of students (an additional 1 to 2 years of training is usually needed for a commercial setting).
I often recommend plumbing, as it allows folks to afford to do a postdoc. =)
> A BSc or MSc in STEM is all 99.997% of immigration
Funny enough, I hold a 'general science' BSc. When I was applying for a work permit, the country's immigration office didn't believe my degree existed for a short while.
It worked out, just sent them a copy of the program outline from my university. The whole process was a mess for other reasons, but at least this one got sorted out after a few back-and forth with the department by Email.
As a former CS professor with some experience of curriculum design: looks quite reasonable. Personally I would have moved some of the material on compilers and architecture into the earlier part of the course (instead of putting them in the advanced section) but balancing content distribution against time is tricky.
The selection of areas and materials is broad enough to teach a reasonable chunk of CS. The individual course quality looks good from a quick skim.
Looking through the links, I noticed most of the course was video, so I immediately turned it off. Compared to text, videos are an inefficient learning tool, and I think a lot of people aren't aware of that. Honestly, I hate video learning materials. Though it's better than going to a classroom.
Given the trajectory that AI is taking in terms of being a very helpful code assistant, what type of CS education would be ideal for current elementary school kids? Sure, some will want to go all the way and be programming the AI; but for the rest, it would probably make sense to be able to use the tools in the same way that today's "tech savvy" can accomplish 10x as much as someone who isn't familiar with computers. What parts of computer programming will be necessary, and which parts can be summarized or jettisoned?
I ask this question as a mostly non-technical person, wondering what skills it makes sense to develop in my children, so they can "skate to where the puck is going", so to speak.
Scratch seems to be a very popular no-code way of getting kids into programming (games). Prior to that, encouraging your kids to solve new problems and constantly pursue their curiosities is a good way to build the skills / mentality. Divergent thinking (what are the different uses for this thing / what are the different ways to solve this problem) and convergent thinking (what characteristic makes all of these different things alike) are ways to make them comfortable being uncomfortable (refactoring and extricating). Pattern recognition via IQ tests, which are heavy on programming-related patterns (visual XOR, AND, etc.)... and also asking them why the IQ test might be wrong / which other "tile" could be next other than the provided answer.
If they are in the sixth grade then it may be 2030 by the time they graduate from high school.
I am working on a website right now that uses OpenAI's models and at the moment it can definitely write and (immediately) deploy simple web pages with interactions and calculations exactly customized by my customers. I am working on the dialogue interface and the text-to-speech and some other things to make it work better. Planning to have a new release at the end of the week. The current version that is up is hard to use since it requires special commands and has some rough edges and uses the non-coding ML model (which can code, but not as well as the code-specific model I am switching to).
Within 3 years I believe that these types of systems will be doing a very significant percentage of programming tasks, both for programmers (as "assistants") and end-users.
Within 7 years I think that programming will have evolved mostly to be directing these types of coding assistants for most use-cases.
The challenging thing though is that kids still need to learn how to read, write, think and problem solve. Despite the fact that AI is starting to be able to do quite a lot of it for us.
They need to learn solid problem solving skills like problem decomposition, how to search/find answers to roadblocks (such as using ChatGPT etc. or other tools like Google and other tools that arise) or just plain persistence, logic, abstraction. The struggle will be getting them to do some of this stuff for themselves rather than cheating like most of their classmates.
But at the same time they absolutely have to learn how to use the new AI tools. It will be critical to stay competitively productive as an adult or just to be able to fit in. There will be important new tools every few months or years.
Where this is really headed in my opinion is by the 2040s high bandwidth brain computer interfaces that tightly integrate cognition with advanced AI systems (2-10 X smarter than humans) start to become commonplace. These will enable different paradigms for communication and society. Before we get to that, AR glasses/goggles will integrate AI deeply into most people's lives.
What is your justification for these estimates? I've been trying to pay attention to what various experts think (I'm not one) and it seems like far from a foregone conclusion that this will be the case, and it might not even be the case that scaling up produces the same outsized benefits we've seen so far.
François Chollet for example seems like someone who is pretty in the know about current SOTA and is not nearly as optimistic best I can tell.
> But at the same time they absolutely have to learn how to use the new AI tools. It will be critical to stay competitively productive as an adult or just to be able to fit in. There will be important new tools every few months or years.
Definitely agree here.
> Where this is really headed in my opinion is by the 2040s high bandwidth brain computer interfaces that tightly integrate cognition with advanced AI systems (2-10 X smarter than humans) start to become commonplace.
My gut feeling is this is pretty insane and unlikely to be the case but I suppose insane things have happened before.
Like I said, my website can already do it to some degree for end users. GitHub CoPilot etc. is very popular for programmers. I am just assuming the models will continue to improve and be deployed.
The only reason to be un-optimistic like that person is if you assume that the model capability will remain essentially static over several years. But even with current models (which new ones are released every few months at this point) there is huge potential for replacing quite a lot of real software engineering work especially when you start putting them in loops and specializing/priming them for particular types of programming.
The sense I'm getting is that the output will look authoritative, but may not work. When it doesn't work, it may be obvious, or it may be latent. What does someone need to know in order to be able to detect latent flaws (and to be able to ask the right questions in the first place)?
I imagine it helps to know a lot of the same basics, but as AI gets better at reliably performing certain types of functions, it becomes OK to view more and more stuff as 'black boxes'. I'm trying to figure out what those black boxes are, and what they will be in the future. Because the more time you spend learning something that becomes irrelevant, the less time you can spend learning other stuff that remains relevant (coding or otherwise).
You try to run the code, or your kid tries to run it. I do plan to build an auto-debugging mode in eventually to the extent it is possible. Say about half the time, feeding an error or bug description in to the coding model from AI, it is able to fix the bug just from that.
It's a missed opportunity to push "Projects" at the end of all kinds of course. Let's turn table around. Let's teach on how to build complex projects with its companion theory, instead of just trying your best to explain the theory first.
It's not exactly what you're asking for, but the U.S. Navy's Electricity and Electronics Training Series (NEETS) is available free and well regarded. Part of the reason is that the Navy's materials are well done is that they have fewer sub-specialty jobs in electronics than the other US military services, maybe because you have limited space on a ship for people, so techs need to have more broad experience and be able to work on wider range of equipment.
Note there is a very observable difference between computer science and software engineering. In Advanced Programming they offer Haskel, Scala and Prolog. While those languages are fun to learn and use for personal purposes, there's effectively zero commercial space application for them.
Eh what? My last job was at a bank, not exactly known for having the most interesting tech. They had several teams that used Scala and I've seen a lot of job listings for roles using Scala.
Haskell and Prolog slightly less so but at my current job (mostly Clojure, which is even less popular than Scala and Haskell according to the stackoverflow dev survey) we do have one guy who prototypes stuff in Prolog sometimes.
In fact according to the SO dev survey Scala and Haskell are used by almost 5% of professional developers, almost as much as Swift which is hardly seen as a language with "effectively zero" commercial use. They also rank a lot higher in the salaries section than many more popular languages. And I don't know how recruiters think but if somebody lists that they know Haskell on their resume and are applying for a JS job I'd assume they can learn JS pretty quick.
According to that, Haskell and Scala are used by (a bit less) than 5% together. Something seems a bit off about that though. I find it hard to believe that Python is used only 20x as much as Haskell, and I say that as a massive Haskell fanboy.
We use Erlog - a port prolog for the Erlang VM at my current gig, we also have some legacy app front ends written in PureScript (which is is basically Haskell that transpiles to JS.)
My wife works in Scala/Spark as a Data Engineer, at a very large Tech company.
I used Haskell in gradschool, the course was called "advanced programming". We leveraged Haskell to learn about hypothesis testing and generated tests, model based testing, parsers, interpreters, query engines, interpreters, monads etc.
I've seen this before and there are great courses, but most of them cover the basics.
What I tried to find for myself is a bunch of in-depth courses that cover the areas where I'm not as comfortable. I've started collecting some courses (there were especially many in the COVID era simply because the universities recorded the courses anyway and only needed to upload them), books and papers. I didn't aim to get a comprehensive set of resources covering everything or having some specific features, I simply gathered what I thought is interesting for myself:
If you just want a career in making computer software. Build something. Then do it again. Google all the stuff you need to build your current thing. After a few month it will be obvious to you that you can build software. Then talk to companies about junior positions. Tell them you are self-taught and show them the stuff you have built already.
Best to talk to a company (usually small companies are easier), where you are allowed to talk to a programmer early on. The fact that you learned everything by yourself means they do not have to hold your hand all the time. Hand-holding time is the most important consideration for me, when taking on junior devs.
I feel that CMU's 15-213 Introduction to Computer Systems [1] should absolutely be on the list. It's a mandatory class at CMU that everyone, who gets remotely near CS curriculum, must take. I feel it's completely justified. The lucky CMU students were able to take a version of this class since 1998.
I am doing the Math version of this currently to catch up on the gaps that my CS education missed out on. If you do plan on doing this, I cannot stress how important it is to manage expectations and be consistent with the workload. There is no pressure here and you might not even need like, 80% of what's being taught on your course but you are essentially keeping yourself active. It's like a gym except for your brain.
The problem I've faced with self-learning CS have never been a lack of resource. Skills plateauing for almost a year. I just have troubles keeping on track. Mentorship or some kind of support will be more helpful ...
Study groups with a team of interested and motivated peers work wonders on self-education.
Either organize locally with a smaller group of sub-20. Even 2 or 3 or 7 people groups are great if you can hold yourself accountable.
Or you can organize over the net. Had some great groups during Covid, and formed 2-3 lifelong relationships from these groups. Get started with 50 random people from the discord server, and after 8 weeks, ~7 will still be there. That's enough and that's great.
This REALLY works. Trust me on this and get started.
this is a good resource but also don't forget to apply these by thinking and building out projects. If you don't use the knowledge, there's a high chance you'll lose the knowledge.
Nice, I'm drafting my similar syllabus for publication on my github. I love the fact that there are more open pathways to achieving a education like this. Thanks for the share!
This looks really good, though the Software Engineering course part seems a bit lacking. I think there should be a more comprehensive one on patterns and software design.
This is great. I am have hired many many engineers over many years, and I have not seen a significant difference in the quality of engineers who had a formal CS degree vs. another quantitative degree (physics, math etc.). I have noticed some differences in engineers who have gone through bootcamps, but they are usually great at getting things done, so it has never mattered.
Also curious if there is a list somewhere out there for similar self-taught path for other subjects?
It probably depends very much on if you ever do advanced stuff and if you are able to discern a bad solution from a good one.
For example reading a file with a loop of read(1) works fine, but it's extremely slow. A CSE graduate should in theory know that, and also know why that is.
I have devised a plan for a specific group of people (like me):
Group Characteristics:
- Has a full-time job and a family with kid(s): Basically means only 1-2 hours everyday, maybe a little more when workload is light
- Not super smart (probably can identify myself as median IQ at best)
- Did not go through a solid CS education (I came from MATH in a mediocre school)
- Managed to grab a developer gig by luck and self-development (for me it's mostly luck)
- Want to have the deepest understanding of computers and computing as possible (I just realized that computers and computing are two things, one is more about hardware and the other is more about MATH)
Issues identified:
So we probably still want to get the best education from MIT/Berkeley/etc. but the problem is:
- The courses are too tough for us
- We don't really have the mental reservoir to consume difficult topics everyday, so that means maybe a few hours of study may push me away from studying for the next day
- Contrary to the second point, we do need to study the material as often as possible to retain knowledge learned
My plan:
- Browse through the list of MIT/Berkeley/CMU/etc. classes and figure out a list of courses. I want to study reverse engineering so my list:
- Introductory to programming (I want to skip this one but local university doesn't allow me, see below)
- Computer Architecture
- Data Structure and Algorithms
- Theory of Computing (basically pre-requisite for compiler theory)
- Operating System
- Compiler Theory
- I then registered in local university. It's a mediocre one but it fits in the bill of giving me a general understanding of the topics
- The lab/assignment is really easy, like in OS class it doesn't even touch anything about writing functionalities for a student OS
- The exams are annoying, mostly about memorizing things, but since I don't care about score I just get by
- I have to take a few extra pre-requisite courses such as Introductory to Programming and Discrete Math but I'm fine, good to pump to GPA in case I fuck up something in the future. I want to have an average of B
- I'm going to take one course per semester and study the corresponding MIT/Berkerly/CMU course in the NEXT semester, so basically I always have two classes going on from the second semester. The workload is more manageable and more importantly I already know something before taking the courses of tougher tier schools.
I'm now on Data Structure and Algorithm so next semester I'm going to take Theory of Computing in local school + Algorithm in tougher tier school. I hope it can ease my way into the topics so that I don't burnout quickly.
Self-teaching computer science is a long and winding road. OSSU seems to favor a completionist approach that most people would do well to avoid. Grok on the fundamentals and quickly specialize, because life is too short to learn computer science in an encyclopedic way.