To make a successful open-source project is not easy and is about balancing a range of factors, including balancing their work/life. Not everyone can do this, or wants to do this. I think rock stars earn their status.
Yeah, that's true, that they invest a lot of personal time in this stuff, and they do a very good job in balancing, but the problem is that people trust them in important questions like performance even despite the fact many of them don't know CS basics properly (like data structures, etc).
I don't want to say all of them are this way, there are some well-educated people who definitely know a lot and deserve all of this. But as it was mentioned earlier, a lot of them are just 22 years old hip guys who released something what became mainstream/were involved in it and became ambassadors.
I think this is part of the tradeoff that they excel at. There is a huge difference between perfecting and optimizing vs. shipping and growing an ecosystem.
I think that's mostly bunk. For every rockstar there's 100 equally talented individuals who will never get recognition because they were not in the right place at the right time.
Rockstars are incredibly lucky.
IMO, social media and blogosphere driven complex work cannot be deep, just confused.
Any kid with a new idea can have his ideas listened to. This means we don't get stuck.
I would claim that any technical undertaking without understood goals using a process whose main design feature is not efficiency but sluggishness is a pathological one.
A computer system is far more simpler than any countrys political system - it's tractable and optimal solutions can be found. Unless, of course, unless the design process is lost in confusion and bafflement.
I would claim a place where any kid is listened to is precisely the one where everyone will get stuck. If people spend more time reading blogs rather than on CS basics they cannot understand a great ideas because they are on the Kruger-Dunning level of skill development.
This is the only necessary component of stardom.
When something is actually good, it'll retain its popularity.
I'm not a huge fan of the "Javascript programmers are novices" myth. It's quite damaging.
Javascript is a kitchen-sink language these days in the ES6+ world. You've got the functional programming features... monads, functors, applicative and even immutable data structures are just a library. You have classes, interfaces, protocols and of course event-driven programming, prototypes, etc, etc, etc. It's not a small spec these days.
The point is that there are smart people who use the language to great effect. Enough with the "unwashed masses," story please.
Personally I'll take an ML or Lisp based language anyway... but thankfully I can have my cake and eat it too by compiling to Javascript.
There are novice programmers and many of them choose Javascript is more accurate. The aforementioned assertion is used as a pejorative by programmers from other languages who think, perhaps rightfully so, that Javascript is inferior to their language of choice. That doesn't make Javascript programmers as a whole inferior despite what such a blanket statement implies.
And this is not a single story; I've also interviewed some people and for some reason my experience is that JS has very low entry barrier.
Yes, with tail recursion we'll have almost full FP (only pattern matching is missing), but it doesn't mean that every novice will go and study them right after landing – in fact, the opposite, because there are much more tutorials about OOP JS.
I'm a Python guy who's working in Java at the moment. I don't particularly care for JS or frontend work, and I make no bones about it. But if someone were saying all this about the Python or Java communities, I'd be asking for evidence. And, frankly, I'd be pissed. So I think we should hold ourselves to similar standards -- don't just shit on a community because that's how you feel. Provide cases. And possibly even advice on how to improve!
Except COBOL started in 1959, not 2009.
https://github.com/angular/angular.js/releases?after=v1.0.4
...
And I actually prefer ng-1 to the transpiling mess that is ng-2, as well as preferring to use functional composition rather than pseudo-static classes for the controller logic.
JS development will probably go on like if nothing changed, but people that don't like it will be able to opt-out.
If WebAssembly takes too long, I can see JS compilers getting very good, but it's looming availability is discouraging that.
Because having an extra compile step or language to learn is inconvenient no matter what you target.
> If WebAssembly takes too long, I can see JS compilers getting very good, but it's looming availability is discouraging that.
I haven’t seen any of this.
For an environment that's as dynamic and open as Javascript, my POV is that one should be able to dive into library source code -- but that changes resulting from this should be an unusual circumstance, having to do with edge cases. If the normal situation is that you are always doing this, and it is always is flat-out basic debugging, then this is messed up.
The ability to dive into and debug everyone's source code should be considered a blessing. It's a great way to learn coding style and programming! It's one thing that was great about working in Smalltalk. However, the need to do so just to fix library bugs should be viewed as a symptom!
I found the Tessel (https://tessel.io/), but its hardly a microcontroller - its a MIPS SoC.
It looks like the Espurino is more of a traditional microcontroller. But the unit cost is high - $40!
Is anyone using JS on a microcontroller in a high volume product?
And then everyone started to build "rich" web applications (it is called differently every year), with the "best" tool existing. I personally see two major problems – usually cool startups who can afford using the bleeding edge will die soon (or will get enough money to completely rewrite it), so 'maintanence' in idiomatic way doesn't work here – life cycle is extremely small, and it reflects in the way libraries are written in JavaScript. Also, the barrier is low, and therefore we have a lot of complex websites built by novices, running in development mode in the actual production.
Community also is very "poisoned" with the idea that you _have_ to work in your evenings (contributing to OSS, writing your own or just playing with hot technologies), and therefore new stuff is baked extremely quickly. It is usually very low quality, and you have to cope a lot in order to make it work, and often you have to dive into source code, and it is considered as normal, which is quite sick from my point of view.
Also, it is truly "hype" community, which is super excited about what is hot now – and it means that today kings will be overthrown very soon (right now stuff like Cycle.js and Vue.js is gaining traction). Nobody wants to maintain their libraries – and very often you can see projects with a lot of stars completely abandoned.
Recently, Babel.js was defined as _defacto_ standard, and it basically started transpiling era, which is not going to end in the foreseeable future. It shakes the stability, and makes extremely easy to add new features (like stage-0), and people just used to unrealiable tools.
So, all of this works as a snowball, which only speeds up. People create more and more complex web applications, and also js is going into other fields (like microcontrollers, Node.js grows in popularity, React Native is super hot now). When it will stop? Nobody knows. Maybe WebAssembly after implementing will stop it (people will spread over competing technologies), maybe no.