I think that you're confused between server-side and client-side development.

Have you heard of https://repl.it/ or https://jsfiddle.net/ ?

The reason command line is popular is because it’s easy to connect commands together. You could technically do the same with a GUI, but it would be a lot more work for someone to create the framework for doing that, and at the end of the day it would just be less flexible most likely. There’s a good reason command line interfaces are prolific: they are orders of magnitude easier to make.

It sounds like you want Electron or Flutter.

Strictly sticking to what's already bundled with a browser, the web developer tools (summoned with CTRL+SHIFT+I in at least both Firefox and Chrome) come with a REPL.

I don't have any big, revelatory thoughts or ideas here, but I wanted to say that I think these are some really interesting observations on the initial obstacles that beginners encounter. As someone who uses the command line for as much as I possibly can (I write all my code in vim, I manipulate my filesystem with Unix commands, I download images with wget, and I get genuinely angry when I can't navigate an app with my keyboard), I definitely don't have the context to pick up on things like this anymore, and I really appreciate the perspective.

Thanks for your thoughts!

FYI, you're getting the Hacker News 'bump'. Currently on the front page, so prepare for a ginormous spike in traffic, and overly opinionated developers 😝

I feel your pain, coding is really hard for beginners. And your main point is setting up a coding environment is spot on. I agree 100%. I learned to code at a 'bootcamp', and I can't imagine trying to learn how it all works, or even what I needed to learn without the guidance of some really amazing mentors.

The great thing is that the answer to your question is "Yes!". You can code in your browser today! There are many companies working hard in this space, but don't expect it to ever come from the browser makers. The browser is not given the types of capabilities NodeJS provides for very good security reasons.

Codepen (https://codepen.io/) and JSFiddle (https://jsfiddle.net/) are very popular for small demos or prototypes. For a more complex environment, you have already discovered Glitch. Glitch is not bad, but like Ronan already pointed out, I would recommend https://repl.it. I think their interface is much more intuitive, with superior design.

Even better, I think you might like Gitpod (https://gitpod.io/#https://github.com/eclipse-theia/theia). Behind the scenes it uses Theia (https://theia-ide.org/) which is essentially a clone of VS Code designed to run in the browser. And best of all? The latest version of NodeJS is preinstalled, ready to go! Pretty amazing right! I think your use case is a perfect fit for Gitpod. I would be interested in what you think.

To try it out, login with your Gihub account. Then, for example, take the full URL from the main page of your blog repo on Github, and paste it on the end of https://gitpod.io/#. Once it loads, you will see your whole project file tree on the left, and an open terminal at the bottom. Now you can confirm NodeJS is installed with node -v <enter> in the terminal. You should see the version number printed! Or simply type node<enter>, to enter a Node 'REPL' (enter .exit or cntrl-c twice to escape)!

Personally, I'm not sure why you wouldn't just want to use the standalone VS Code app (https://code.visualstudio.com/). It is an 'Electron' app (https://www.electronjs.org/), which is most simply described as a 'mini' browser, that allows us to write desktop apps with web technologies.

Nonetheless, I think Gitpod is a perfect fit for you and gives you a fully self contained environment, without having to install Node on your own machine.

If I may respectfully answer some of your points:

Can you imagine if Node.js was installed by default?

It's unlikely, but it's possible. Apple or Linux distros could decide to bundle it with the OS like they do with Python. The difference is certain parts of macOS/ linux depend on Python to work, so it cannot be left out. It's not really the OS vendor's job to assume everyone wants/ needs a Node environment by default.

Imagine if node.js shipped inside Chrome by default!

This I'm afraid will never happen, and it's a little confusing as to what you expect this would achieve?

As you already know, one of the jobs of browsers are to be GUI's and run-times for javascript. Traditionally, the browser (or client) was the only target of javascript. This of course changed with NodeJS, the beauty being we now have a access to the same runtime (called V8) to execute javascript outside of the browser.

This means NodeJS provides classes and functions developers can interact with (known as 'APIs'), to access the file system, run web servers, preform cryptography, or a multitude of other low level tasks. We can directly interact with the operating system, all in javascript!

This is why shipping NodeJS with browsers doesn't make sense. For security reasons, the browser by design, should never be able to do low level interactions on your computer. The APIs that Node provides have no use in the browser. They are designed for different jobs.

This post is probably too long, but I hope it helps clear up any confusion. I encourage you to try out Gitpod, to me it seems like a great solution for you. A amazing text editor and NodeJS in the browser, without all the technical setup!

Your main point is spot on, the fact there is a large hole in the space of user friendly 'on-ramps' to development environments. It is slowly getting better though. Best wishes, and good luck on your coding journey! 😄

The history of how programming got this way is really infuriating. It goes somewhat like this:

Once upon a time, someone designed a computer in which programming was close to the way you wish it was. The system was 100% graphical. An IDE was integrated with the operating system itself, so the entire OS was programmable like a spreadsheet is.

At any point, you could, with scarcely any effort, pull up the source code to the program you were running, modify it, and the changes would take effect immediately, just like they do in Excel. No need to recompile and restart the program.

This applied all the way down to the deepest, darkest corners of the operating system. You could easily pull up the source code to any system library function, and then go to the source code to the low-level internal functions they used. You could also get to the source code for the compiler.

But this computer had a flaw: It was extremely expensive. It was decades ahead of its time in terms of hardware specifications. Nobody could afford it.

So somebody else wrote this shitty operating system called UNIX. It was built with simple programming techniques not far removed from the punched-card readers that were still in use in many places. The only important difference was that the punched cards were replaced with these things called "files", which were like digital stacks of punched cards. It was easy to turn programs that were designed to work with punched cards into programs that worked with files instead.

And it felt like using punched cards, too. To write a program, you'd type it into a file, then you'd exit to a program called the "shell", where you'd type the name of the compiler program, which would read the file and then create another file with the same program translated into machine language. The shell could then execute this file by typing its name, but only if you put it in a directory that was in your $PATH.

The starkly inferior UNIX operating system ran on cheaper hardware, and was cheaply written, which meant that it was affordable. It therefore spread like wildfire. Eventually, PCs were invented, and their inventors copied the same simple programming techniques over (only they simplified things even more). Over the years, generations of programmers built on top of UNIX and DOS, each generation building on what the generation before had built. The company that built the expensive but nice to program for computer went out of business. Everything we have today evolved from either UNIX or DOS. That other computer, and what it was capable of, has been almost completely forgotten.