I didn't want to comment in the article as I haven't been able to get one myself, but I have some time off coming up and I'm hoping to check it out then.

In any case I think it's great that we again have access to inexpensive [coding/tinkering/making]-first devices.

Oh, I just found a issue for that: https://github.com/Microsoft/vscode/issues/1031

More details here: https://code.headmelted.com

2.Use croutin to install complete stack to run Linux GUI apps too.( Honestly I don't understand rational behind this, since you don't have for example Win key in Chromebook and many other issues.)

Hacks like this which devs seem to be happy to endure are not a solution for helping these kids to code.

There are a few options I've been looking at that could yield improvements in this area.

1) Install the play store, if your chromebook supports it. Then something akin to Gnuroot Debian, and set up the environment that way. Install the package, and then forward the X11 window to something like "XServer XSDL". Tricky to explain to people, and I couldn't get it working when I tried for a few different reasons.

2) Add a side-by-side node.js server inside VS Code. This would effectively serve up the HTML/CSS/Javascript inside the window and the user could just use the web browser. By launching on boot this would have the neatest integration with Chrome OS, as you could pin to shelf and then it's just a http://localhost:XXXX URL. Even if the web content could be forwarded in this way I think re-implementing the Electron calls for the web could be a lot of work, and it probably belongs as an alternative Electron implementation I would think. The upside is that you wouldn't need dev mode as this could also run under e.g. GNURoot.

These are a couple of ideas I've had. Would be eager to get someone from Microsoft's take on it though. :-)

It shows my own homebrewed Desktop environment running in a browser window with a Monaco based editor open. So it's doable, but it would need quite a bit of work to beef it up to VS code abilities.

Things are a bit broken right now(like file requesters don't return the file selected)

I work on it sporadically. Now that native promises are a thing I want to go through and tidy up some of the callback structure. The App API should ideally be all promise based.

It's an intimidating task though. Next big update I'll probably get it to a point where I ask assistance.

I use it on my Chromebook quite a bit. It makes for a reasonable on-the-go environment running Node on the Linux crouton side and editor, output on the ChromeOS side

I am not affiliated, just a happy user with 8GB RAM thinkpad!

Also, CTRL-D short-circuits the scary splash screen.

ChromeOS is first and foremost a web terminal. That Google recently started introducing Android apps on there do not really change this, as most Android apps are just frontends for web services.

The whole reason why the BBC funded the original micro was to end the distinction between developer and standard user – everyone should at least understand it.

Giving users full control like that will only result in a greater need for customer support. We've all seen the stupidity of some of these "tales from tech support" customers. While I agree with you that everyone should at least understand the computer and OS that they're using, I also understand Google's move in creating a separation of users, especially during Chrome OS's infancy.

Yes, I can keep the machine put away out of reach, etc, but that's not necessary with any other laptop I have. The user login on my Windows 10 machine is enough to prevent my 3-year-old from button-mashing her way to a wiped drive. Not so on a chromebook.

She opened it, saw a screen saying "press spacebar" and she complied.

Was I angry at her? Yes. Very. But when I realized that even I could have easily made that mistake I stopped using the chrome book with crouton. Too high risk.

https://johnlewis.ie/neutering-the-developer-mode-screen-on-...

Not for the faint of heart, but at least you only need to do it once...

http://blog.codestarter.org/content/images/2014/12/tumblr_in...

That developers mode thingy is starting to look more and more like some kind of fig leaf towards the FOSS world.

It's a very common (and safe) procedure. There's a good write up at https://wiki.galliumos.org/Firmware

Basically, an official container support in user space that once you enter developer mode allows you to keep the security features you have currently (signed boot-code checking, encryption), but also a restricted container that allows for native apps like this.

Then we could get rid of the Developer Mode splash screen, or at least allow it to be disabled by choice.

I've been think about how this would work. Something like the Samsung ultra powersaving mode. A basic lock screen and dialer with 911 support, then the running environment could be swapped between full Android, Ubuntu or anything else.

Google could replace the kernel with something else and only OEMs would notice.

AFAIK there isn't any way to get VCS integration (but I have a faint memory that DevTools extensions are possible?), but it's a great deal better than nothing.

...and, of course, if you dev unlock the device, you can install Crotoun and get a full Debian system side-by-side with ChromeOS. Then you can do what you like.

https://github.com/clojure-emacs/cider

The only performance drawback I've encountered really comes from XIWI and the X11 forwarding introducing a slight lag sometimes, which is to be expected.

In honesty though, this isn't really an issue as the underlying performance isn't hurt (it's still running natively at full speed, it's just the forwarding that would lag in that scenario).

If you were in a drawing app, a game or in something like Blender, it could be more of an issue I guess!

On Raspberry Pi:

Solid. (At least I find it to be so.) :-)

I know he's talking about the cost and not necessarily being able to afford a full fledged PC, but this could work for some.

At that point you might also look into connecting over a remote desktop/vnc/ssh session, which has surprisingly solid support on Chrome OS these days. I've heard from a lot of friends that this makes their Chromebook their road warrior of choice (connectivity allowing obviously).

Finding the time is always tough so having schools that support it is important

I realize it's a small contribution, that leverages the work of others, but I hope people find it useful. :-)

I really wasn't expecting to make the front page. It's really good to know that there are other people that can relate to the goal here.

Edited, thanks. :-)

On a Raspberry PI, one would typically use the command line, right? So does this VS Code install with a kind of GUI? Of do you need to install a window-manager-type-thing first?

Also, there's an "Error: ENOENT: no such file or directory, open '/home/ivoras/.config/Code - OSS (headmelted)/storage.json" , don't know if it's important.

The main version of NOOBS has X starting by default these days. Even the standard Raspbian image has a GUI, but you can use the lite version for headless servers (https://www.raspberrypi.org/downloads/raspbian/). This is similar to Ubuntu Server but different to NOOBS lite, which is just a small network installer.

Raspbian now ships with PIXEL, for example, but I tend to have a preference towards XFCE for my own use (very lightweight).

In any case it should "just run" after installing, but if anyone has any trouble please let me know!

i will always say that the next pc revolution will come in the form of the first open smartphone.

What he's doing is great. But the premise that it'll help kids learn is flawed. People starting off don't need the best tools. Like the author, I started with BASIC. Nowadays, it'd be Python. It needs to be easy, not perfect (god knows BASIC, Pascal, etc have huge flaws). Visual Studio is complete overkill.

In today's computer, I can't see any environment that would do that.

If my kids are presented with Visual Studio, I think they would spend the majority of their time clicking on the thousands of buttons on the ribbon, perhaps.

I'm also not necessarily suggesting that VS Code is the best tool there is. It's just a tool that I know a lot of the community has rallied behind (and which I'm personally a big fan of).

The article is more to suggest that I'd love to see more vendors provide their best work to these devices even if there isn't necessarily a large profit incentive to do so.

I don't really understand why a good editor is necessary in the sense of my old nostalgia or how I would try to streamline the learning/tinkering process today. While I see no specific value in anything in the gap between using whatever debugger/interaction the system offers to futz with the most visible levels and jumping to an online Python/processing/whatever notebook, I suppose starting anywhere that stokes one's curiosity is just as good as anywhere else.

UNIX - any variant - is an absolutely terrible environment for beginner computing. It's inconsistent and incoherent, the security model makes no sense on a single-user machine, there are all kinds of unnecessary gotchas and "No, that doesn't work", the basic editing tools are unfamiliar ("Why doesn't the mouse work in nano?") and the pay off is relatively small. Programming sound, graphics, and animation can be a nightmare, even for professionals.

How about Windows? Worse than UNIX. MacOS? Arguably a better OS, but Xcode is about as friendly as an ill-tempered shark with a hangover.

Which is why I think these "Pi = BBC Micro" projects completely miss the point. The Pi is nothing like a BBC Micro, or a Spectrum, or any other popular 8-bit machine. It's more like a cheap/slow PC clone, and it has none of the immediacy and instant gratification of the original 8-bit scene.

It's the difference between being given a tiny universe you can totally own, and a much bigger universe that's confusing and doesn't seem to have edges.

The latter can be hugely demotivating to many kids who would thrive in the former.

Nowadays, the closest I can think of is the interactive interpreter of python...but it's still not the same. Perhaps because python has orders of magnitude more libraries/functionality/gotchas out of the box. I think I would have been overwhelmed as a young teenager with all of that. Simple(and constrained maybe?) isn't such a bad thing for getting people their first taste.

I have some time free next week, I'll definitely try to make this happen.

My ultimate goal here would be to convince Microsoft to add ARM support to their official version, although I realize after sending some DM's on twitter back-and-forth why (at least on Chromebooks) it's a road that would be tricky for them to go down.

I'd be pretty confident of getting Raspberry Pi support into the official channels at least though. Certainly this has made a bigger splash this morning than I expected, so they'll have seen it.

And really what we need are the best tools that can run on the lowest end mobile phone. That way a lot more people could code: https://www.cta.tech/News/Blog/Articles/2015/July/How-Mobile... You could just give away free android phones- that'd be easier than trying to get everyone's clamshell phone to allow coding, and typing on a numeric keypad would be difficult. Also, even using Android- how will those people type? Hmm, maybe we just need to give them all computers or Facebook could set up computing centers. Actually, those luckily enough to get a ride into town and some money might afford 15 minutes in an internet cafe, so maybe if you wrote an app that could multifunction as a coding tutorial and universal web email client application at the same time maybe someone might use it. But definitely a low-end computer, so we're back again to serving some additional people realistically if we just have a webbased IDE that runs on a low-end computer. Should it support IE6 or IE7? Also, internet in many places is dog slow.

Still beyond that what is desperately needed is food, clean water, shelter, clothes, blankets, feminine hygiene products, medical assistance, infrastructure, the ability to grow food, doctors that live nearby with a constant supply of resources, and electricity. There are many parts of the world that don't have these things. Don't give them computers first. It would be intercepted before it gets to them or taken away from them or sold for necessary items. Many can't code, as they're struggling to survive.

I think this gets too expensive. Instead, I think you need to just serve the lowest denominator and help those that don't even have that with other resources.

I posted more detail on another comment, but it should be possible to write a nodejs server app inside the package that will serve up the electron HTML to the web app (i.e. with command flags like [--server --port $port]). You'd probably have to implement the keystroke handler and a renderer for the menus, but otherwise it _should_ work.

Of course, I have no idea how much work would really be involved (although I imagine quite a bit), and you'd end up with something that resembles Cloud 9 or Mozilla Che, albeit with VS Code's extension library.

It just feels like something that would be better built directly into Electron though, so it could work for e.g. Atom as well.

Either the JS needs to be fast and compliant with much older browsers, or you just do a webform with old HTML tables as structure and so everything server-side.

Then you have the opposite problem in that those with newer computers wouldn't want to use it. So you might have to provide multiple levels of support, similar to how Gmail and OWA have a light client and a heavy client.

I agree with the sentiment of that so much but it's not an either or thing in some situations.

Also, computers, in the form of feature phones mainly AFAIK, have helped some of the poorest people by enabling communications and information acquisition that can help with water, food, shelter, medical aid, etc..

If you RTF though you'll see it only addresses the disadvantaged in developed countries where the above are not widespread issues.

I suppose no matter how bad it is for the environment, filling the worlds landfills with e-waste is at least good for the economy.

As for web-based vs native, I can see it going either way. If connectivity is too unreliable and/or expensive then native will win. Many people in the developing world spend a lot of time with no credit on their phones.

The biggest problem I see with teaching people computing these days, which is only partly addressed by cheaper computing devices and IDEs, is the sheer number of tools and abstractions to learn. What order do you teach in? What if there's no teacher? Version control, testing, frameworks etc. are all great things, and a certain proportion of people will need to learn them at some point. For others it's overwhelming, and for most it at least hinders the teaching process. Too much "ignore this for now" can be demotivating and confusing. Yet, it's also not enough to start with just a BASIC prompt any more. People have now seen all the cool modern things you can do and want to do it themselves, so moving an X across the screen is not motivating either. I have found completely dedicated environments like https://scratch.mit.edu to be great for younger kids, but not sure how the rest of the learning curve should be shaped.

Not the same for everyone... here's a weak attempt at answering:

Kids:

1. Visual 2D: https://scratch.mit.edu/

2. Visual 3D: https://minecraft.net/en/

3. Interacting with real world: https://www.lego.com/en-us/mindstorms

4. Machine learning (why? it's the future!): http://stats.stackexchange.com/questions/22504/what-can-one-...

Adults:

1. Take class(es) on using a computer or phone. Many don't have confidence for things we take for granted.

2. Online tutorials: http://javascript.info/ http://iwanttolearnruby.com/ https://wiki.python.org/moin/BeginnersGuide/Programmers https://netbeans.org/kb/articles/learn-java.html https://msdn.microsoft.com/en-us/library/aa288436(v=vs.71).a... or go to school.

3. Learn enough to contribute to an open source project.

4. Get a job coding or code at your existing job, if allowed. On the job experience is essential.

I don't doubt there are long lists of links to starting programming, as there are for every conceivable subject (also "go to school" doesn't work for the disadvantaged/developing countries).

The point is keeping someone's enthusiasm alive and making good use of their time. In the "golden age" you would see, say, Space Invaders, and it would be within your ability (even as a teenager) to reproduce it, starting from the BASIC prompt and short manual that came with your computer. If you want someone to work efficiently now, on the things they want to work on (fun/visual/relevant to their life), they need to learn a lot more to get started. That's an improvement over the past in many ways, because it was simply not possible to work as efficiently then (e.g. no high-quality libraries, only basic line editing). In a way, people want more and can do more. But planning how to get there is harder.

Of course I'm biased, because I make one (https://anvil.works) - but there are loads of great platforms out there. You can learn and practice basic Python with Trinket (https://trinket.io), or command the full complexity of a Linux workstation system with Cloud 9 (https://c9.io). (With Anvil, we aim somewhere in the middle - useful, deployable, earn-or-save-money-with-them apps, without the full horror of the Web. But my point is that there are many good choices available.)

This would further the centralization of the internet, which is a disaster waiting to happen. It's easier, it's cheaper, but it's also wrong.

We must teach people to take control of their computing power. This means giving them a personal computer they can control. They need enough computing power (low-end phones and the R-pi are more than enough), a decent I/O setup (screen and keyboard, mostly).

You also want to avoid proprietary software. I won't object too loudly about adults and companies using proprietary products, but when it comes to children, I have to go full RMS: proprietary software is wrong, teaching it is evil. In some cases (MS-Word vs LibreOffice), we really have no excuse.

(An ubiquitous counter-argument is, not knowing MS-Word makes it harder to find a job. This ultimately does not matter, because "proper" training will cause other* people to be unemployed. To reduce unemployment, we have to either create more jobs or share what we have (4 days work-weeks come to mind). Of course, since computing is mainly about destroying menial work, don't get your hopes up about job creation.)

> This would further the centralization of the internet, which is a disaster waiting to happen. It's easier, it's cheaper, but it's also wrong.

Sorry, honest question - I don't understand what you're saying here. Could you please explain?

At its core, the internet has no centre. It's just a network of computers, peers in the network, who can talk to any other computer in the network without restriction (besides bandwidth). There are complications, such as the distinction between an internet user and a full fledged operator, but as long as the operators give us a set of basic guarantees (no filtering, no snooping…) we mostly don't care.

Such a structure have far reaching consequences. The most obvious is the freedom of expression just got real. Anybody can publish most anything in the internet. This was not true before. Journals, TV, radio, all were controlled by a relatively low number of people. Just count how many people have ever published anything on paper, including research papers and letters to the editors. Compare that to the number of people who posted articles or comments on the web.

Basically, an a-centered internet fundamentally change the way we communicate. This necessarily changes the power structures. Historically, whoever had the power before such a change tended to resist, leading to lots of spilled blood. Just think how the printing press enabled the enlightenment, religious schisms, and revolution. Mostly for the better, but quite bloody still.

The first centre of the internet is the DNS system. To contact a computer, you need its IP address. It's like a phone number, only worse: it's longer, and you're going to talk to a lot of computers in practice. Hence DNS, to have memorable names. Thankfully, the DNS system is distributed into domain and sub-domains, so it's not so bad.

There are however other problems. See, to be a actual peer in the network, you need to be a client and a server. Publishing something on the internet mostly means giving it upon request, the way web servers do. You need a public IP address, and you need to be up all the time (modulo unavoidable downtimes). This was totally the case for university servers, but not home computers.

When the internet began to popularise in the 90's, home computers used to connect to the internet by making a phone call to the ISP. An actual phone call, that hold on the line and cost money (most phone companies charged by the minute and mileage). You couldn't be connected 24/7, it cost way too much. So, no web server for you, and no mail server either. You had to borrow someone else's.

To remedy this problem, internet providers also provided an e-mail address and a way of publishing stuff on the web. That was the first serious step towards centralization.

Later, the ADSL came up. A stands for "Asymmetric". This one doesn't monopolizes your phone line, because it uses higher frequencies. You can also connect all the time for a reasonable price. Alas, you still couldn't have your own server, because the upload rates were just not build for that.

They could have made it symmetric. They chose not to, I think for commercial reasons: they assumed (mostly rightly) that people are mostly consumers. They don't upload much, they mostly download. So let's sacrifice the upload for a better download. Makes total sense, right?

Not quite. One big application was significantly hurt by this choice: peer-to-peer file sharing, which needs both upload and download to work smoothly. Also, while people didn't in fact upload much, many did have an email address and their personal blog. They could easily be hosted at home, if the provider had their router host those instead of centralised servers.

In any case, it all went downhill from there. Gmail was such a big hit that now Google actively reads a scarily high proportion of all email worldwide. (They use algorithms instead of humans, which is worse, because it scales.) You distribute your videos with a handful of services such as YouTube, you talk to your friends through Facebook… And of course the ubiquitous search box, but that one has an excuse: we don't quite know how to decentralise that one yet.

This centralization is not neutral: there are terms of service you need to abide, DCMA takedowns, policies. This is a rather pervasive and direct attack on free speech. Privacy is hurt big time too: it's not exactly easy to secure a private chat connection these days. At the very least, you tend to make a request to some central server just to connect with your friend, such that even if the server doesn't log or record your conversation, it knows you attempted to connect.

This doesn't have to be. The truth is, if everyone had a private server (no bigger than an R-pi) at home, and a reasonably broad symmetric bandwidth, there would be no need for Gmail, YouTube, Facebook, or Medium. There's also a good chance there would be little need for centralised forums such as right here (moderation might be a problem, though). This would mean much harder mass surveillance, which we now know is not exactly a conspiracy theory, thank Snowden.

---

Programs decide what we can do, and how we can do it, all the time. Programmers write those programs, hereby influencing our lives. You really want control over the programs that affect you. This means Free Software, but this also means understanding the damn thing, and executing it on your own hardware whenever possible, not on some remote server. So, when teaching children the basics of computing, we must also demonstrate some good habits. The centralization of a web app is not a good habit.

And I too have been through the same dilemma with my kids. I haven't got far trying to enthuse them with the RPi - even when I got Minecraft running on it, they complained it was too slow...

There was also the huge problem of choice. We had no choice - you learned the language of the system you had. For a couple of years I struggled to choose a language to introduce my son to. A friend of mine even bought an old BBC Micro so he could teach his kids the Old Ways!

But perhaps I over-thought it. A year or so ago I made an arbitrary decision and showed my son how to run Python from the command line, and he picked it up pretty fast. But then he started complaining that he couldn't work on it when he was at school (such is their expectation of cloud ubiquity). Now he's just turned 14, and I've discovered he's developing a pretty ambitious text-based adventure game, still in Python, but using a cloud-based IDE (cannot recall the name).

So whilst I admire the project - the more the better - I think to a certain degree the tools are already there and as long as they're given the seed of interest the kids will go out and find them for themselves.

Because much stuff is already there and back in the 90's, when I was in my teens, things looked a bit different.

But funny thing is, even in 2000 people in my school laughed at me for wanting to be a software developer.

"Why do you want to create new software? Everything is already created! I can play games, I can download videos/music and watch it, I can talk to other people online, what else do would you create that isn't already there?!"

What did we have since 2000? Facebook, Twitter, Smartphones, etc.

I suppose it's a lack of imagination, combined with laziness, which has been reinforced by decades of "Make learning fun!" and "Science is easy!" slogans that the government education tzars love to produce.

but there are more who make good money with coding

You should emphasize orders of magnitude more.

Of course, the other problem is that people who make "good money with gaming" aren't actually gaming - they're following a practice regimen that the average gamer wouldn't stick with for more than an hour - refining repetitive mechanical motions, analyzing gameplay to identify faults, fixing those faults through repetitive practice.

An amateur will ask "how do I get better at this game?" and, when you tell them, say "no thanks, I'd rather just play the game."

Could/does he use github and an online REPL from school?

Interested as I've been learning Python to use with my slightly younger kids.

Also, in school they have some pretty serious restrictions on what they can access. And git might be a bit hard for a kid to learn.

All their IDEs are free for students who "have access to their student email address or a valid ISIC card" by the way: https://www.jetbrains.com/student/

Edit: link added

https://repl.it/languages/Python/ helped me out, as did http://www.pythontutor.com/visualize.html.

What do you propose will replace the tool a decent chunk of people use to work on large software projects together?

Though in 10 years I suspect the porcelain and workflows will have collected several new features.

* Git in fact rose in popularity unusually fast. But this was probably because it was born at the intersection of two major events - DVCS were the hot new field and wide open for new players, and the kernel's VCS crisis. I imagine that hosting the kernel on day one would provide as much experience as a decade of being a small experimental VCS. This is not a routine combination of events.

So yeah, things move on, but they will continue to move and although git is pretty elegant, it has rough edges and a fiendish CLI interface that very few people fully understand, so I think there is plenty of room for improvement.

http://weblambdazero.blogspot.ch/2015/11/modern-micro-with-r...

It looks like this, and anyone who grew up with the BBC Micro will instantly recognise it:

    RISC OS 192MB
    ARM1176JZF-8 Processor
    Piccolo Systems SDFS
    ARM BBC BASIC VI (C) Acorn 1989
    Starting with 97040636 bytes free
    >_

BTW, i recall Intel showing off a variant of the python interpreter being run directly from GRUB. Would have been interesting to see that ported to RPi. Also, i think there was someone working on a Python CLI that could replace bash etc.

That was me: https://biosbits.org/ , presented at Pycon 2015: https://www.youtube.com/watch?v=bYQ_lq5dcvM and 2016 with networking: https://www.youtube.com/watch?v=AlkKvetGFSk

> Also, i think there was someone working on a Python CLI that could replace bash etc.

That was "xonsh" (http://xonsh.org/ , pronounced "conch"), by Anthony Scopatz, presented at PyCon 2016: https://www.youtube.com/watch?v=uaje5I22kgE

Looking back, it was a great idea, because it is one of the few ways to get the feel of retro computing and programming, along with its advantages to getting started, that is still useful and relevant. My TI-BASIC knowledge continued to be helpful into college.

Prior to ICT - meaning Information [and] Communication Technology - there's was IT. In IT we learnt to make teletext pages, use databases (choosing whether they should be computer ones or not), did DTP (eg newspaper layouts), learnt to type, made graphs, played text-driven games.

There was no Computer Science at GCSE (perhaps it was a subject prior to that) and very few schools, none in my town, did it at 'A' level.

I started programming at primary school age copying out of an intro book that came with an Acorn Electron. AFAIR there were no opportunities during my schooling to learn actual programming, I'd have lapped that up.

I was amongst the last generation of people to take 'O' levels (ISTR that GCSEs came in two years after me?), and our school had computer science as both an 'O' and 'A' level option. Our little sixth-form BBC Micro lab (networked via 'Econet') was where us nerds and geeks hung out (although we didn't know we were nerds or geeks back then).

After I left school for many years I just assumed that things had carried on as they were. It was only years later that I learnt about ICT and the damage (IMHO) it had caused. :-(

My dad was a teacher. He used computers to teach industrial design, graphic design etc in a well-funded school in the 1980s. (We have a photo of me using AutoCAD, age 4, on a 286...)

In the very early 1990s he started teaching IT, but he certainly had no programming skills. Wikipedia says GCSEs were introduced in 1988, which would be the new curriculum the article refers to, with the first exams therefore in 1990. That's probably when the subjects he'd been teaching were removed from the curriculum, and teaching IT was the natural way for him to continue his career.

I fiddled with BASIC on our Acorn Archimedes, but couldn't progress -- my dad didn't know anyone he could ask for guidance, yet he knew IT teachers in many other schools. I had one book, that had come with the computer, but was stuck for what to look at next, until a chance conversation some years later.

> Maybe it was up to individual schools how much they bought into it.

And on that point -- there was some flexibility within the IT/ICT curriculum. My dad could avoid teaching databases, and the other teacher at his school could avoid teaching bitmap or vector graphics. My school (different) could teach some very basic programming, making a model automatic door open and close or a lift go up and down.

(The computer graphics work some of my dad's students did was brilliant, a couple even started very successful companies based on their ability. But it belonged in art lessons, not "computer" lessons.)

    Download crouton.
    Create a chroot on the local device based on Ubuntu 14.04 (Trusty Tahr).
    Install Visual Studio Code into the chroot.
    Install git into the chroot.

It's also worth noting that putting your Chromebook into Developer Mode will wipe the device, so if you decide to do this, make sure all your local files are backed up first.

[0]: https://github.com/dnschneid/crouton

Probably the last Google-backed device I'll buy.

Yeah, I just run ubuntu on it.

ChromeOS was always about being a thin-client. A better kiosk OS, if you will.

With that being said, I use Chrome OS for development. I have a DigitalOcean server that I SSH into using the excellent Secure Shell app, do all of my development there using tmux/vim and test in a browser tab. If you already like this workflow (some don't, I understand), then Chrome OS works very well for web development.

I'd think it fairly necessary to have a full Linux environment (and ideally good package support) underneath the IDE in order to actually work with the editor. And it works quite well in practice due to the integrated terminal that's running full Ubuntu (as you've said, due to the chroot).

The comment is fair, but I've tried to explain this as clearly as I can in both the website and the installation script itself (there's a confirmation explaining exactly what will be done and what that means, although I obviously try to keep it as straightforward as I can without obscuring anything - at least not intentionally).

The native part refers to the architecture. It executes natively on ARM, rather than through some kind of emulation solution (like QEMU) that would make it untenable in practice (I've been dogfooding the scripts with this for some time while trying to polish the process).

The instructions also mention that you can just install into an existing chroot as a standard apt-get install call for anyone that has one set up already and knows what they're doing, although it should also work side-by-side.

I'll review the website in light of your comments though, to see if there's anywhere this can be made clearer!

I played with this several months ago, and don't currently use it. Seems like development has stopped, and a recent support comment seems to indicate that ChromeOS updates have rendered it non-working.

The answer should be pursued through Android. Apps for ChromeOS are officially second class. Chrome the browser, a window manager and a basic file manager seems to be all ChromeOS is ever going to get. The rest should be done through Android to make your efforts future-proof

We detached this subthread from https://news.ycombinator.com/item?id=12957989 and marked it off-topic.

Maybe that's true for proprietary software. But the Pi can run any open-source project you throw at it. I used one as an (admittedly slow) development box for a while.

Some open-source software can't work on ARM, but it's in the minority. Code in high-level languages is generally not tied to a particular processor architecture.

Maybe in twenty years people in this forum will be trying to think of a way to get their children excited about hacking drones or building phone apps.