As a side note, Microsoft login echo system sucks big time in the context of office. You have no idea which URL to use to login to office 365. Between login/logout/timeout/other office apps/personal accounts/business accounts/forgot password workflows browser redirects to various URLs at least a dozen times. And you keep seeing new URLs I am wondering how less tech savvy people are coping with their authentication workflow.
Depending on how you are authenticating you will see URLs with various words in them.
This reality bit me when my Skype account was rolled into Microsoft's Live/Outlook/something system. Both accounts had the same email address, and suddenly my Skype account was no longer accessible. I finally figured out how to delete the non-Skype account, but it was a major pain and I had to wait 60 days for it to finally go away.
All public facing URLs should go through Marketing. On macOS, when an Apple app contacts an Apple service and my firewall shows me the domain/host, it almost always looks very thoughtful and pretty. Compare that to MS Office on macOS. So many different requested domains with no thought and coherence behind them.
Thats because the team that wrote Groove Music (and Movies & TV) originated from the Zune desktop player and Windows Media Center. In fact it still used a lot of core code from the Zune days for things like library management and DRM.
Doubt it. Even if the app wasn’t published previously, it likely descended from existing code that already carried the name.
I work on a codebase that still carries product names that stopped being meaningful almost a decade ago. No value in renaming across the codebase and it’d be expensive because of how much code has to be touched.
It's a huge problem for MS login flows and Google's login flows. As they absorbed various disparate products with various logins and tried to force a unified login flow on all of them they end up with a mess.
Everybody I support at my office gets super confused about this. Add on top of that local vs web versions of every app, plus UWP vs standard desktop applications (OneNote, OneDrive). Plus naming conventions that change, and applications that have 70% overlap. Just use the classic portal for this, and the new portal for that...
Recently got caught in a loop of trying to create an Office 365 account and being told that my email is already in use, then trying to say that I forgot my password and was told that my email is not associated with an account.
I wonder at what point the number of domains and subdomains that you can log into becomes its own phishing vector. At least with most services, you can look in the URL and pretty quickly know whether or not you're in the right place!
As much as I can imagine MS would love to kill VBA it would be a major loss of business if they did. Oil and Gas lives in the stuff and would probably even sue MS if VBA died. That said could it be getting a much needed fixup... probably. I suspect the same is true of COM plugins.
I rewrote a 3000 line VBA function into C# earlier this year for a Oil/Gas company. It was surprisingly easy. Sometimes tedious, but easy. It runs faster, it's easier to maintain and now they can slap whatever front-end they want on it.
Is it money, fear or gatekeeping that keeps these VBA programs untouchable?
I used to be in the Medical Devices field. A couple years ago, I was told to add a feature to a massive VBA app hosted in Excel that we (S/W development) inherited from another department. It was hands down the worst code I have ever seen. Everything was a global variable. I flat out told my boss that it barely worked, didn't come close to meeting the weakest of our development standards, and since it was used to disposition product (determine whether or not it was acceptable to be used on Patients) it was an FDA audit nightmare waiting to happen. I added the features, but made some pretty unpleasant commit comments since I didn't want to have my fingerprints all over it.
In all fairness, it was originally developed by a scientist with no SW dev training (I knew him well) for his own use, and just grew over the years as he was told to add more features to it. I have no idea how a company with that level of process strictness ever allowed this fiasco to happen.
I estimated the rewrite at 6-12 months. It was really not a very complex program and since we already had the Validation tests written and documented, we at least knew what tests its replacement would need to pass. The problem was all the stuff that we knew it was doing that wasn't in any of the tests. That would have been the majority of time spent to replace it.
Since I left, I heard ownership of it was transferred to Corporate IT and they were making it into a web app to run on their intranet. Heaven help those guys.
> Since I left, I heard ownership of it was transferred to Corporate IT and they were making it into a web app to run on their intranet. Heaven help those guys.
At my last job, I developed automated processes. Some software companies sell tools to automate clicks and keypresses. The idea is then to reuse that Excel macro no one understands inside a VM on a server, and adding a friendly webservice on top of it. Users of the web services don't know an actual screen is running and and an Excel file is being clicked for them.
It's simply that the people doing the development only get to use VBA. Not that having a chemical engineer teach themself C# over their lunch break is going to turn out great software...
Having worked at a big company as a mechanical engineer and produced a few crappy VBA apps, I did it because it would take significantly more time and effort to get approval for an IT project, than to learn VBA and do it myself.
Most of them aren't maintained by technical people. Someone wrote some excel file years ago and every month it's copy pasted and the new data put in place of the old and it usually works until it doesn't.
> Is it money, fear or gatekeeping that keeps these VBA programs untouchable?
I was involved in work with a regional financial institution. They had a suite of line-of-business apps written in Access and VBA. This was in a pure support and maintenance mode. This series of apps was written over the course of a decade by one developer nee business user. It represented a literal Great Wall of Chesterton. There was so much process and institutional knowledge tied into this suite and the original developer left after being absorbed into the IT organization.
Some fun observations from work that was done on this suite of applications:
- "We can tell where the original developer learned various programming techniques and when something was written based on that."
- There was a source control and deployment app written entirely in Access DBs and VBA
- There were two scheduling applications, one designed to replace the other, but the first never fully retired. These launched jobs based on dependencies and timings.
- The applications ran in Access 2010. No upgrade was possible due to observed breakages when attempting to change.
- A Windows security update caused an outage for a day.
- Some data was centralized into a SQL Server instance and Access was a thin app layer on these tables. Others held data in the Access database.
- Different apps could reach into and run arbitrary queries on data of other apps. This was sort of RPC. Huge spooky action at a distance.
- There is a ticking time bomb based on Access database size limits. They run compaction jobs on a regular basis, with increasing frequency. One of the core apps will simply stop working one day in the not so distant future when its database cannot be compacted to be smaller than the Jet engine limit of 2GB.
I mentioned that this thing was in perennial support and maintenance mode. There were several assessments over the years for a migration to .Net. All were eventually scuttled due to cost and fear of functionality shifts. No one knew if what was there was correct, and some of the bugs we fixed demonstrated that there was plenty that was incorrect, though scope and impact were difficult to measure. No one wanted to own a migration due to the likely fallout. Different would be wrong, even in the face of huge evidence to the contrary. A C-suite executive was ousted largely over this suite of applications. The Access lives on.
Eventually a migration, in part or whole, will be necessary. It will be expensive. It will be painful. Each day increases the expense and pain. But every day, it is cheaper and easier to run and maintain.
 This thing hit commercial and customer facing processes, internal things like HR, letter generation, asset management, and basic reporting, among other things.
Don't count yourself so sure - A lot of shadow IT gets done by that excel expert in finance or the engineer who took a programming elective. If anyone ever gave them a database login password, odds are they're pulling into excel or access and writing VBA!
I dealt with it peripherally in my last job. Apparently the only reason Office has a 64bit version at all is Oil and Gas was causing Excel to run out of ram and demanded it. We were developing a COM addin, and we had clients complain that we broke some of their VBA they were using (turned out it was another VBA addin they were using that wasn't doing proper error handling). But it was definitely common for us to see clients that were deep into VBA.
It's really not. YAML is a superset of JSON, but you wouldn't call a YAML document a JSON document. The set of all colors is a superset of the set containing only orange, but calling every color orange makes no sense.
I don't think it's exactly right to call it a superset either..
It adds types and constraints that have no effect on the resulting transpiled code besides an insurance that said type constraints are being met.
I know the architecture too good, more than I need as I was leaving MS recently. This tweet is not likely to happen.
Talking about desktop apps, this doesn't make any sense. Office apps have millions of lines in code and many years of lost knowledge between the classes. Just too many screens, checkboxes and features. A complete bloatware. Buy MS doesn't take any feature off the app- if you have 1B users, most likely that any minor feature cut will hurt some of them, hundred of thousand of them, and they are probably paying, not free riders. Any new office version only hides features, letting this small users group to get them back, never deleting lines of code. MS doesn't want to get billions fined as happend when they moved to docx/pptx/xlsx and didn't support backwards.
Talking about the online versions of office, it is a mess. For Word and PPT they tried to replicate the desktop to the web, rewriting the code, so their current online versions are already using (mostly) new code dedicated for the web. Saying that, they also have a huge number of legacy components and features that they need to support for backward compatibility.So for word and ppt this is a mix in code, not a total re-write. They also have a substantial subset of the features that appear only in their older desktop brothers. Even the PMs don't dare to dream on features parity between the versions.
Excel is a different world and a big-big elephant that won't likely be rewritten any years soon. Think of a code that is maintained over 30 years. Literally, developers are still maintaining code written in the 90s.
Trying to bring Excel to the online world made MS create an architecture of html frontend which communicates with a dll session behind the scenes. As weird as it sounds, this dll lives as long as the browser has the spreadsheet opened. Think of it as MS raising VM for every excel file that is opened over the internet. While this is not very cost effective (saying the least) and not very performance friendly (hey ma! I made an understatement) this allowed them to move forward with Excel online very quickly by having a UI communicating with the bloatware dll that runs on the background in Azure. Summarizing Excel, it probably won't also be rewritten in js.
So this PM might be talking about the new apps - Teams or flow or something similar. Not the office cash cows. Personally I really hope he is talking about Skype which became a total garbage in the past versions.
Anyone from Google here? I'm looking for a job :-) ping me (chengmau) in the blind app
The way I see it, even saying that this is the goal is bad news. It's basically an official admission that Microsoft intends to abandon the Desktop OS entirely. Windows 10's bullshit isn't just some bump in the road that would eventually be recognized as the bad idea that it is, it's a deliberate move to push people off of Windows Desktop and on to Windows tablets, smartphones, and a desktop web kiosk. Windows as a personal computing Desktop OS would be completely dead, and given the state of the alternatives that means that personal computing desktops are also dead. Everything will be a web kiosk or a console.
It's pretty much exactly the scenario of my nightmares.
Is it possible there will simply be "Office 365" standalone apps that are basically just baked-down versions of the web apps (like typical Electron style apps), but distinct from the official desktop apps? I could see there being some utility to this such as speed vs running in the browser, large-scale enterprise deployment, convenience reasons (why I always run the standalone Slack app myself), etc..
Why not C#? Seems a bit of a missed opportunity to feed some of the APIs undoubtedly created for this into the new .net core stuff. I guess i'll just keep dreaming of the day when i can reliably convert a docx into a pdf without using office interop.
Actually at one point they went very close to replace VBA with .net. It was called VSTA and meant to be a mini visual studio in office apps. I believe one of the office apps shipped with it in Office 2007, then they killed it.
This is a good point. MS has agreed to support IE11 until 2025. I'm not sure if that means they have an internal mandate that Office 365 must work with IE11, but I wouldn't be surprised. Those poor poor MS developers.
I wouldn't call them "poor" in this case. WASM is super cool and has a hopeful future, but productionizing wasm apps is currently still quite difficult in practice - it's still missing a lot of relevant tooling (debugging is hard)
They are actually using Typescript, and this will lead to less friction wrt hiring devs, supporting all those platforms and integrating web components. Still I would have hoped that MS would be a little more forward thinking, and put some of their MSR tech in good use, to encourage the use of better languages. Just like how Facebook is pushing ReasonML.
I think that the C# focus of .NET is a major mistake holding the platform back, especially when we have languages like F#, Scala, Swift, ReasonML and Rust these days.
How do you know they're doing that? Not that it doesn't make total sense to use TypeScript from any angle I can imagine.
> I think that the C# focus of .NET is a major mistake holding the platform back, especially when we have languages like F#, Scala, Swift, ReasonML and Rust these days.
Yeah F# is really nice, but the IDE support is kinda meh. Also .Net expects you to embrace nil at a lot of points which doesn't gel so nice with F#. But Swift has a worse problem with Objective-C-isms but being a first class citizen really helps as they make a lot of API's really better to use with Swift.
I wonder if it has anything to do with their being more JS developers than C# developers. Though, I imagine the average C# developer is a better programmer than the average JS programmer, but since quality is often a function of quantity, maybe there are going the later route. Or maybe it's something entirely different ;-)
> to do with their being more JS developers than C# developers.
It's interesting they're using Electron for Win7/Win8 when React Native for Windows has a WPF rendered that works nicely on Win7 and 8. Perhaps they just found that maintaining two slightly different RN office apps for Windows wasn't worth the effort given the declining market share of the older Windows versions.
Also, I expect the existing code base isn’t small, so a rewrite won’t be ready soon.
Considering they are uniquely positioned to make it happen given their C# buy-in and probably more than just a bit of existing software to leverage, I'd say this is as strong a signal of non-endorsement as it gets.
I don't think we can read that much into it. The tweet says the project is nearly finished, and this doesn't sound like a small effort — so it would have started either before WASM was really a thing or when WASM was still a very risky bet. I mean, I don't imagine they'll be jumping to WASM, but I don't think we can read it as "they're deliberately not endorsing WASM" so much as "WASM is still quite new."
They just demoed running a winforms app in the browser using .NET CORE so maybe it would be less work/more successful to explore this path instead of trying to somehow re-implement the oxygen-sucking monster that is Excel using only the "new hotness (tm)".
I bet this is only the new stuff like Delve and the less functional, more social apps/components. I can't imagine how they could pull this off for a full version of Excel or even Word or PP..
Oh god please I hope they have. In my experience, dynamically typed scripting languages struggle to keep up with the rigorous structure enforced by statically typed languages once the project gets large enough.
Yes, in theory you _can_ write big projects well in dynamically typed languages, but in practice you get a mess of undocumented interfaces and unit tests that don't quite catch the plethora of errors not present when a static type system is in place.
I think Typescript is a great middle ground between the loose running JS hipsters and the Haskell loving Hindley-Milner type system CS researchers. You can enforce the type restraints that you want (I personally am strict about explicit "string | null" declarations) but you're still hip enough to draw the JS talent.
"No they are not electron apps. They are compiled to native code.
It's now finally one toolchain(#webpack)
It's one codebase and it compiles to:
WIN32 (only one that uses electron)
7:52 AM · Jun 13, 2018"
comment seems to be saying -- in modern windows (UWP) it'll be using native code, but microsoft is taking the easy path on win32. i guess some people are surprised that despite years of telling people that win32 is going away microsoft is finally making good. but I am not, I'm more excited than anything at another good sign that Microsoft is finally done with legacy windows.
Nobody who truly participated in or contributed to the "complete" rewriting of Office in JS would be capable of expressing the positive emotions the subject of OP does...their soul would have been drained of the capacity to express joy long before the project would be completed. The tone smacks of the delusional cluelessness that MSFT's culture seems to uniquely foster.
The whole thread and all later clarifications just look like a guy spewing random stuff loosely related with what he's working on at Microsoft. There's not much meaningful information to take from there.
UWP doesn't run on win7. If you think getting rid of WinXP was hard, wait to see the phasing out of Win7. If you write for the desktop, chances are you are writing an internal app. Lots of large enterprises (including my present employer) just switched to Win7. Win10 is a looong way ahead. A significant part of your userbase won't be able to touch a UWP app for a long time.
This isn't Office for Windows the suite. WIN32 is a platform they're not really supporting any more, I think they're basically saying if you're on WIN32 then you're getting the web version in future, not the real deal.
The challenge here is social. The Web has fist-mover advantage. Also, I fear that doing it the right way would be equivalent to forcing standardization on a single operating system (or a family of systems).
You would inevitably just end up re-implementing a shittier Web with less features and no adoption. A waste of time.
In the best case scenario you implement something almost identical to the current web which is only slightly better, and therefore not worth moving the entire world over to your stack just to get these minor improvements.
If, by "everyone", you mean "everyone as in everyone who's currently having strong enough feelings about this thing to make a bunch of noise about it on the Internet." Which is probably a much smaller and more variable set than "everyone as in every single person."
> Scripting languages as first programming language for CS bachelors are WRONG. You are not able to write an OS, a DBMS, or even an Office suite with an scripting language.
I honestly thought this was a satire tweet. I guess I just don't associate even a CS bachelor's degree with writing that kind of software. I mean, it can, but there are more theoretical tracks that don't involve writing a OS/DBMS.
I very much agree that this is a broken line of argumentation.
As a first practical programming language for a non-CS bachelor, scripting languages are fine. Without CS courses to support you, other approaches might be too difficult, while scripting languages often let you get (terrible) programs up and running (ish) while ignoring basically all CS aspects during the learning phase (only while you're not making anything big, though—the "high level" illusion breaks down fast as things grow).
(Also, yes, you can write a DBMS or an Office suite in a scripting language. I can't possibly comprehend why you'd want to do something like that, but it's very much possible. Bringing OS's into things is cheating, as most compiled languages can't be used there either, and those that work often only work with a subset of the full language.)
You can't deeply learn programming in a language like assembly or even C. You don't have enough expressiveness to tackle large-scale problems (like office suites or DBs!) within the scope of what one person can work on in one semester; you'd be spending your time thinking about how to implement a hash table instead of how to use one.
One of the nice things about so-called scripting languages is the breadth of library support. If you want to put together a GUI that displays some word-wrapped text, you can do that within the first hour of using the language, if you have some homework instructions you're following. At that point you can think about the interesting parts of writing a word processor, and not just how to put a window on screen (which tends to be more about docs and APIs and not about actual computer science). Also, importantly, at that point you've successfully done something, which is pretty important for the learning process.
Most of the CS tracks I've seen recently (and even back in my days) have an "introduction to C/Linux" module which requires writing common command line tools, starting easy and gradually ramping up to a basic shell, a web proxy, etc.
I had to take a mandatory course where we wrote a simple flat-file db in x86 assembly, complete with a simple console-based interface. I’ve rarely needed to even look at assembly professionally, let alone write a real db, but I fully agree with the tweet.
Really the choice of language is unlikely to be the cause of any slowness you are experiencing in different versions. JS can be faster than a native experience, all depends on program architecture. The main JS engines are blazing fast and a low-latency UI is perfectly possible; sluggishness is not a sacrifice you must accept when coding in nearly any language in 2018. But bad practices in any language can lead to a poor user experience.
Part of that is electron itself - I've heard it carries quite a bit of bloat - and part of that is the DOM. The DOM is very slow because of the guarantees it makes. You can edit any part of the HTML at any time - by hand or by API - and everything will resize and reflow implicitly. That's an incredibly powerful yet heavyweight feature. If they're using React Native, the only non-native thing is the raw JS logic itself, which is far, far less of a bottleneck.
Updating the DOM in Electron is like updating the DOM on the web -- you can do it fast or you can do it old. Most Electron apps I've worked on or looked at the source are using things like React for the DOM, which is much faster than what you describe.
But if an app does it "old school" then it can definitely be very slow.
Not true. The DOM in Electron is precisely the same as the one on the web, yes. But while React is faster than some of the other data-driven frameworks, it is not faster than "old school" DOM manipulation. The advantage of modern frameworks is developer experience, not performance. The DOM API is fundamentally slow because of how much work the browser has to do under the hood to respond to changes. Every framework, including React, goes through that API at the end of the day. This is why React has its own whole virtual DOM: so that it can touch the real one as little as possible.
My full-time job is writing tools in React that often have to handle datasets in the >10k items range.
My point stands if by “updating DOM” it is meant the developer approach to making DOM changes, which in React go implicitly through a virtual DOM first, yes, which is vastly faster than updating the DOM directly. And an Electron app doesn’t need to be slow just because it uses a browser DOM.
I work on a React project that has a faster UI than its native desktop counterpart.
An Electron app doesn't need to be slow just because it uses the browser DOM, but UI mutations will almost universally be slower than their native counterparts. Now, if the desktop app is poorly written and the Electron app is well-written, then of course the Electron one can be faster, because there can be sources of slowness other than UI mutations.
Let me illustrate the DOM question with an example.
Let's say you've got an "old style" jQuery to-do app. The user types something into the field, and clicks "Add".
- The input field will be cleared
- A new element will be added to the list, containing the string
- The counts for "total items" and "items remaining" will be updated
Now let's say you rewrite this app in React. The user types something into the field, and clicks "Add".
- The input field will be cleared
- A new element will be added to the list, containing the string
- The counts for "total items" and "items remaining" will be updated
Your code that accomplishes this will look completely different - much more readable and less fragile - but the exact same DOM API calls will be made, and it will perform exactly the same.
The "speed" we associate with React is not in comparison to "old school" libraries, but to the naiive way of achieving data-driven syntax. You could just nuke the page entirely and re-render everything from scratch each time your data changes. This would be the easiest way of achieving data-driven syntax, but it would indeed be extremely slow. React gives you (something approaching) the performance of jQuery-style mutation, with the developer experience of reconstructing the DOM from scratch every time data changes.
The issue seems to be down to your network connection. As Outlook is sending or receiving emails and making other service calls you experience a slowdown. Onsite our connection is very slow and everyone experiences this problem. Additional bandwidth was not considered for the O365 and if you monitor your service calls with fiddler for example you'll see constant traffic to the O365 servers.
We're talking about pressing keys on a keyboard and the corresponding letters appearing on the screen, maybe even with spellchecking. This has been computationally achievable for decades. It's not something where you need a state-of-the-art PC in order to be able to experience it.
Exactly. Microsoft won't tell their enterprise customers that their crypto now runs in a browser and is no longer compliant with the standards of their industries. They would lose almost all of their sales revenue if they did that.
Actually, I think the opposite is true. Instead of seeing new desktop versions without feature parity, we will finally see the iOS/Android/MacOS/Web versions of the Office Suite get feature parity with the Win32 versions because they will all be built from the same codebase.
I know that it's common for rewrites to not approach feature parity, but I think Microsoft is aware of how much people rely on Excel and Word and will make feature parity a high priority because of that.
I find it hard to believe they will ever duplicate all the edge cases. I mean in some cases it's literally impossible because IIRC VBA can actually hook into Win32 functions (I mean I guess you might argue that feature is a bad idea)
I was wondering that after reading more of the tweets; React native doesn’t compile the JS to native, so not sure what they are using to do all of that? Bit worried about the far superior languages C# and F# if they are not even dogfooding anymore.
There has been a constant divide between the developer tools division (where C# comes from) of Microsoft and the OS/Office divisions. They both have worked very differently in the past and not at all in the same directions.
I'll wait until it's done, released, and I have the opportunity to actually use it. Skype is already much worse than the original, so I really hope they don't go this way. I'm definitely not going to buy a 32GB notebook just to be able to use the most recent version of MS Office. (32 GB is nice BTW but a huge battery drain.)
Most of the comments seems to say "it's a bad idea" , keep in mind Microsoft is now using React very intensively for most of their projects as well as angular (VSCode , Windows Server etc... )
Meaning it's not the language the real issue , it's what you do with it.
Also Junior at school are less and less trained with Java and C# but straight up with JS or PHP , so it will be much easier to integrate juniors on this re-written version of office rather the pile of legacy C++ / COM / C# bridges mess they have right now.
This is literally the same argument of the tweet's first poster (to which the linked tweet is a reply). This is just simply not true. I know many people who make mail apps for some big big companies. They have CS degrees and would admit they suck at C++ (I wouldn't even mention C) but they are great at Python
> no offence you don't want someone straight out some boot camp of dubious provenance
None taken .
No they are not electron apps. They are compiled to native code.
It's now finally one toolchain(#webpack)
It's one codebase and it compiles to:
WIN32 (only one that uses electron)
> how is that even possible? there are tons of legacy features in there, COM/OLE APIs, SDKs, plugin architecture, macro system, VBA interpreter, VBA IDE, graphing components etc. Almost 30 years of development. No way MS is going to rewrite all of that. (Maybe the "mobile" version)
I think this is a strong indication that all these technologies are going away.
This would be suicide for Office. I struggle to believe that Microsoft is replacing the full Windows desktop version of Office with a version rewritten in JS. It makes no sense. Many, many, many businesses absolutely rely on the features you're mentioning, and many others that would be a tremendous undertaking to re-implement. There has to be something that's not being communicated right here. Maybe they mean the "lite" versions of the programs.
Strongly agree. Backwards compatibility has always been a strong suit for MS. Changing that stance is a major strategic shift, and IMHO would be a huge error, similar in scale to IBM's open PC architecture.
Have you even read the comment you're replying to? Where the hell did you read that OP loves linus torvalds or linux. Microsoft is the one that claims to "love" linux , yet they don't release a linux version of office despite it being programmed to be platform independent. Why are you intentionally trying to misrepresent what OP said?
That said, I am glad I was taught using C++ in college. Not because I plan to ever write an OS or DBMS, but because it taught me valuable lessons about pointers, how memory is managed, how arrays and lists differ, and other computing fundamentals that still inform you when writing in higher-level languages, even if you don't have to deal with those concepts directly.
This is true, but people like the orginal tweeter often pretend that this learning order is somehow the only "real" way to do things. I don't see why it isn't equally as valid to learn high-level concepts first and then learn the gory details later. I'm confused why there seems to be such a large number of low-level people so stubbornly insisting their order is the right one.
From both my own experience and the experience of teaching people, those "gory details" are the nouns and verbs that compose higher-level abstractions. I haven't written C++ in anger in a decade, but it informs what I'm looking at when I'm reasoning through how V8 or the JVM is going to handle my code.
I've been required to teach people in the top-down manner that has left knowing gaps and rendered them without the tools necessary to solve their problems. That's not to say somebody who eagerly learns on one's own may be fine. Of course they might, so long as they have a way to determine what they need to learn. But most people don't eagerly learn on their own, and so a prescriptive "start at the bottom and build up" provides the necessary knowledge and grounding despite themselves.
It can be a more difficult transition to go from high to low than from low to high. Not impossible, but frustrating and confusing.
But also - not to stereotype too hard - but low-level people often have that crusty-old-sailor syndrome where they've been doing things the hard way since before these youngun's even first saw code, and if they can manage their own memory for performance then god-dangit everyone else should have to too.
Is this the "real" reason why they bought Github? They want to migrate their entire office products to use the ElectronJS. VisualCode and others were like the guinea pigs before going fully in with their office products. /end_speculation.
Yeah, I know what Typescript is. It's another transpiled language. I don't care what the syntax looks like, the point is you've added a secondary level of knowledge required to operate in a codebase written in it, and most don't fluently know the first. Please tell me more about what I don't know.
Well, if you remove your assumptions about how incapable people are, TypeScript is the way to make large JS code bases maintainable. It doesn’t even change any of the JS syntax, it just adds to it. It’s the opposite of CoffeeScript in many ways.
It's a "real" language, it's just not a terribly good or fast one. It's works decently when its use is limited to what it was made for: manipulating web pages. For anything else, the "designed on the back of a used piece of toilet paper" starts to shine through.
And no, a JIT can't save you from this, it can only make things acceptable.
That it can create "real world value" is an extremely low bar, which is passed by any turing complete language. COBOL creates "real world value".
From everything I've seen, its performance sits just below Java (4x slower, perhaps) on some standard algorithms or tasks, and significantly faster than languages like Ruby, Python, etc.. I never see hate for those languages like for JS, so I'll disregard that.
>not terribly good
This one never has made sense. What is it missing that makes you hate it so? I think it has rather robust asynchronous handling, 'everything is an object' has lots of nice implications when paired with functionality like Object.keys / .assign, ... So what are the issues you see that make it 'bad'?
"4x" is a lot slower, and a lot of things are much worse than this. You have to have deep knowledge of the VM (such as knowing how "hidden classes" work in V8) to be able to get JS close to Java.
> so I'll disregard that.
You shouldn't. Claiming a JIT'ed language is fast due to being faster than Python, an entirely interpreted language, is like saying a moped is a fast vehicle because it's faster than biking. Apples and oranges.
Being faster than PyPy, the JIT'ed Python implementation, is a more interesting thing, but this is still very far off "fast" languages.
> What is it missing that makes you hate it so?
Most language features, really. "Everything is an object and objects are hashmaps, EVEN ARRAYS" (terrible for performance, type safety), "array of int16" strings with totally broken unicode codepoint handling (ES2016 brought new ways to deal with codepoints, but the standard way is still broken), the "Number" type which is totally retarted, the terrible "prototype" system, the malice that is "this" and how any bare function expression had its own this context (arrow functions are a good workaround now), and god I could go on.
"Everything is an object" is only useful if you either actually need a hashmap (then use one!), or you have sloppy types.
JS, as a langauge, is not well designed. I'm not saying it had to be Haskell or Rust, but JS is far below average.
It works, and does it job decently due to the very hard work of JS engine implementors trying to make this crazy thing fast, but that's not the same as being good.
> 4x" is a lot slower, and a lot of things are much worse than this. You have to have deep knowledge of the VM (such as knowing how "hidden classes" work in V8) to be able to get JS close to Java.
That's a solid argument for only programming in C and Assembly because they are often 4x faster than anything.
> Most language features, really.
AKA, your preferences are "language features".
> Everything is an object
So you don't like Python. Or Ruby.
> the "Number" type which is totally retarted
Very technical argument there.
> the terrible "prototype" system
So you prefer classical inheritance. Cool. Doesn't mean prototypal inheritance is a bad thing.
Wow, now we're complaining about the outdated versions of a language? Come on man. Nobody is going to write a modern application in ES5 and there are plenty of warts in old Java, C and Python applications as well. That's the nature of them being "old".
Why does that impact whether or not it's a reasonable choice to use the language today? Old libraries I could understand, but old independent projects? How do they affect the current state of the language?
I read it that he meant "fixes for these things are missing and that makes me hate it", i.e. I read it as the answer to your question. He doesn't hate it because it lacks features, he hates it because the existing features are badly implemented/thought-out.
If I threw billions of dollars of vested interest at Python/Ruby/COBOL/(insert language of your choice) we can probably make those run at JS speeds as well. Does that solve the fundamental drawbacks of the languages?
Nope. No it does not.
JS is not the only language with nice async support, practically every mature language has async support and a good number of the compiled ones have proper parallel support as well.
every dynamically-typed language has "weird" behaviour around type coercion, that's simply the nature of the beast.
sure wish i knew what you are talking about w/r/t "silently failing". JS has working exceptions just like 99% of widely used languages.
> every dynamically-typed language has "weird" behaviour around type coercion, that's simply the nature of the beast.
No, that's not true at all. Dynamic languages don't necessarily have type coercion at all, much less weird behavior around it (and, conversely, statically typed languages they have coercion may have weird behavior around it; there's just no link between dynamic typing and weird coercion behavior.)
> Who's to say not doing type coercion isn't weird?
Well, if someone has to do it, I will: not doing type coercion isn't weird, and doing inplicit type coercion (not strict promotion) is both weird and dangerous.
But, in any cases that's not really the point. The point is that in this...
> Every dynamic language treats things slightly differently.
“dynamic” is irrelevant. Languages have a wide variety of approaches, doing promotion, coercion, neither, or both (though where both are done, it's often just called coercion even when it is promotion), and dynamic vs. static is mostly irrelevant.
 that is, where the “from" type has a range that is a subset of the range of the “to” type.so that there is never a change in meaning resulting from the conversion.
Yeah, and I can do the same thing in Python, and it will be equally as lame: both languages are fundamentally single-threaded.
You act as if JS has all problems solved: Erlang/Elixir/Golang have far superior async & parallel stories and will happily thrash JS/Node in performance and efficiency.
How’s it working out for me? Well I do a lot of stuff in Haskell and Rust now, so pretty great actually.
1. Type Safety. TypeScript helps, but until strong typing is mandatory in the language, I can't fathom using JS in any sizable project. This is also true of Python, et al.
2. A sane dependency management framework. Maven solved this problem a decade ago. Gradle is trying to fix Maven's XML mistake. But the fact is, if I need a dependency in Java, I know how to get it. And as a bonus, Maven Central isn't going to go down next Tuesday because Timmy in Alberta threw a temper tantrum or something.
2. After the npmjs.com registry became immutable and npm got lockfiles I feel npm is pretty much there as far as dependency management systems go. I'm not sure if npm shares the cache across projects (like the ~/.m2/repositories folder for maven/gradle/leiningen), but you can get that with the yarn client if saving disk space is important.
> ...until strong typing is mandatory in the language, I can't fathom using JS in any sizable project.
There are quite a large number of counter-examples to show type safety isn't especially important to the success of large projects.
I think the guarantees it provides are far too limited and weak to support large software systems. It relies on static code analysis, which doesn't mean much unless your app is a single build and runs as a single instance. That's more of a '90's style Microsoft Word type of app than what a typical large software project is today. Meanwhile the guarantees it does provide are only helpful to the extent developers can map their domain problems to the capabilities of the type system. Sometimes there is a nice natural fit, but usually the typesystem is both too weak (doesn't provide a convenient and natural way to impose the constraits of your problem domain) and too strong (imposes constraints your don't need or want, encumbering your development process).
The only other language that I have seen generating as much hostility is vb6, and also I believe because some developpers found themselves forced to use it.
I use Elixir + Ruby + Coffeescript and I still wish JS was never invented.
"There are only two kinds of file systems. Those that corrupt your data eventually and those nobody uses."
Luckily, filesystem designers worked hard at making their filesystems journaling, fault tolerant, and more. And we stopped complaining angrily about filesystems ruining weeks (or months) of work, because it stopped being a regular occurrence.
We still complain about the flaws of C++ because they are a constant source of pain.
Stroustrup is arguing that if something is popular criticisms against it must therefore be invalid. He's wrong.
I don't think he's saying the criticisms are invalid, but just that they are at the forefront of more people's minds because the respective language is more prevalent. Languages that are barely used also have their problems - they are just undiscovered or spoken about less.
If he wanted to make the really mundane point that people don't complain about things they don't use there would be absolutely no reason to bring C++ into it. He could just remark that nobody complains about the bad handling of the Model T anymore because nobody drives it. It's true but why is that relevant or at all interesting? Do we really believe this is the mundane observation Stroustrup is making?
No. Stroustrup uses his snarky retort to deflect criticism. When C++ is criticized by (academic) language designers, his comment reads as "and yet people use my language and not yours". And that's pretty immature.
Popular tools have to meet a high quality standard because every wart in the language affects millions of people.
Good languages are local maxima in the language design landscape. C is a good language. As is Python. And C#. There are many projects for which C or Python or C# are fine language choices.
Other languages have great ideas in them, but the languages themselves are a mixed bag. Perl, Java, C++. Perl inspired Ruby. Java inspired C#. But we haven't seen a good successor to C++ yet, probably because building a systems language is much more difficult than building an interpreted/scripting language.
COBOL was the state of the art when it was designed, but any evolution on top of that is, by necessity, limited by a 60-year-old core design. While it _has_ produced a lot of real world value in the almost 6 decades of its existence, starting a new project in COBOL would be ill-advised.
Existing projects were written in whatever language for whatever reasons, it's "Would I start a project in this language today?" that's the bar to beat in terms of language "quality" and, in that sense, COBOL is a fairly low bar for most domains.
"real world value" is a completely fair metric. You might be able to argue that different languages offer more value than JS, for different use cases. But mocking the idea of "real world value" seems to completely miss the underlying point of app development -- which is to deliver value.
It's very much in the same state that VB was, or even "Excel programming" is today: it certainly works and it certainly produces a lot of business value. It's just that the downsides appear further down the road; maintainbility and scalability issues, or intrinsic conversion causing data loss. That kind of thing.
Every time someone waits for an Electron app to load, or watches it eat their ram? That gets added to the prejudice scale. Every overly-slow page load that eats mobile battery. The feeling that "it doesn't have to be this way" is very strong.
Maintainability is a problem regardless of language, scaling is moot as these run native code, scalability is an odd word choice given we are talking about desktop apps, and intrinsic conversion can be solved via TypeScript, Flow or any other typing framework. C, Java and C# all have their own set of downsides as well, but we don't pretend those aren't "real" languages.
You are correct that "it doesn't have to be this way" which is why native compilation exists and is continuing to grow.
Microsoft are using React Native here (aside from the Win32 build), which is going to be a lot more lightweight because it relies on the native platform for the heavy lifting.
If your only concern is the ergonomics of the language then there are lots of compile-to-JS languages. Some of them also compile to WebAssembly, which allows them to bypass the GC. It’s still not native speed, but it’s close enough for many applications.
There are pros and cons, but within the next few years it could become common to write in your language of choice, compile to WebAssembly, and ship an app that’s within roughly 50% of native speed.
I imagine JS will still be hugely popular even in that scenario, but that’s a different topic.
the millions are not saying it's perfect. that would be wrong. as you say what we have is js, so let's move on and make something useful with it instead of complaining about it being flawed. it is evolving, being standardized and getting new features. its not going to go away anytime soon, so instead educate yourself into avoid the pitfalls that exist in the language and have fun being productive.
Nobody is claiming you can't write real software in JS. What they're saying is that it is a waste to do so when so much better tools are available. When you're in the browser there are such huge benefits that it makes sense. Elsewhere I find it hard to understand JS mania.
It's about prevalence. The more prevalent a language is, the more the complainers come out in force. PHP is another language that has created billions of dollars of value, yet it doesn't stop the computer science purists from bashing it every other day. Just ignore the negativity and keep writing code in what makes sense to you.
There, I fixed that for you. I didn't miss the boat. I've had to maintain mountains of awful code written by careless programmers in a pathetic language with a morass of constantly changing libraries for run-times (web browsers) that can't even be counted on to interpret the code the same.
I wrote crypto algorithms and protocols, compression algorithms, browser engine sandboxes and similar in JS professionally for 5 years (don't ask why), and often had to deal with fun things like mis-compilations from JS engines and other fun bugs. I'd argue that I have quite extensive knowledge of JS, far beyond the average JS programmer (but far from the highest of experts, of course).
JS's only unique, redeeming quality is its availability through the deployment of web browsers, and the benefits that come with such widespread use. JS wins marketshare because it has marketshare. Any language could have taken JS's place, and most would have been better. WebAssembly, when DOM integration and others become a thing, might allow us to throw JS off its throne.
JS doesn't have advantages on its own to make of for its disadvantages, and relies heavily on extremely advanced JITs to make it borderline acceptable. The language itself still has very clear signs of having been designed on the back of a used napkin (its number type, its "array of int16's" string, "this", "prototype", ...).
I would like to acknowledge that ES2016 brought some things that did remove some retarded areas of JS (like arrow functions, which do not have its own "this" context, unlike the old function expression, class definitions that can briefly make you forget the terrible underlying "prototype" madness, and ways to access proper unicode code points in strings), but we are very far away from having actual advantages here.
Kool-aid in the sense that JS is extremely attractive to MBA types that don't have to write anything with it. There is a huge pool of JS developers (quality is questionable but price range is mostly low), browsers run everywhere, Node.js made it possible to run the whole stack on it, so that's a win for MBA types and a great value proposition. The fact that it's a historically atrocious language doesn't matter as they have peasants (i.e. us) to deal with it (to be honest, it got much better since async/await was introduced, but hacks/warts are still there to be abused in horrible ways).
I wrote bleeding-edge games and other crazy stuff in JS you might be using right now in your business, so my opinion is not unfounded.
We're mostly just bitter from years of being beaten with it. I can't actually face using node.js as an example. It is physically painful compared to other options that I have dealt with (flask, asp.net). Also for me, I've been burned before. Do you remember when everyone jumped on the PHP bandwagon? That. Again. Look where we are now.
On the web, and now suddenly on the desktop, velocity is not what we need. We need quality and consolidation. Down the line can you see any ES6 based API lasting as long as win32? Hell no. Why would I want to risk building a major capital product on such guarantees?
I think most devs who dislike it because it reduces the barrier to entry which undermines both their own prestige and quality of coworkers. Its similar to dislike of outsourcing in many ways.
From a technical perspective, there are couple disadvantages in the long run that can make large codebases unmaintainable. In particular JS and PHP are resistant to static code analysis since they support functions like exec. So it becomes difficult to deprecate functions because the references are not necessarily explicit, thus can lead to tech debt buildup. ES6 does a better job but its backwards compatibility can leave the code vulnerable.
> I think most devs who dislike it because it reduces the barrier to entry which undermines both their own prestige and quality of coworkers.
I think the prestige comment is a bit unfair, but today at work I had to educate a JS dev on what headers are in a HTTP request/request and some other pretty basic things (a dictionary/record type object and a JSON string are not the same thing for one). They were like "I know I've got to do these things, but I don't know why/how they work".
So yeah, I don't think disliking it because that's the average quality of JS dev I see is an unreasonable position. I'm sure there's some great ones out there doing impressive things, but I'm sure you could point them towards nearly any language and they'd produce something equally cool.
The language has some very ugly warts (although ES6+ fixes many things), I find that the quality/maturity/stability of third party libraries lags behind other languages, and the whole build/dev environment best practices is constantly in flux and breaking things all the time. Also Electron, for all it's advantages, is renowned for being a massive resource hog making what is otherwise a fairly fast and efficient language appear horribly slow at times.
That being said, developing in JS today is a lot better than 3-4 years ago, and I suspect that that pattern will continue.
Not only that, billions of hours of invested time and knowledge will be thrown out of the window instantly and everyone who integrates anything with Office will have to start again from scratch. Literally at least a third of the world is built on bits of spaghetti and duct tape on Office.
For developers though, this is chargeable so I'm on the fence :)
this js-is-not-a-real-language stand is only to be expected from someone like a professor or a computer science student. universities and educational institutions in general will always be the last ones to adapt to changes, after the rest of society has moved forward, and they will try imposing those conservative opinions on everyone who are not in their camp. times are changing, computers are becoming more complex and we need more abstractions too. and the ignorant js-is-only-a-scripting-language statement is simply not true anymore.
Except computers have not gotten more complex. We are dealing with the same kind of filesystems, virtual memory, relational databases, encryption, compression, and network stacks as 20 years ago.
a little overstatement, but okay. js is very suitable for this in my opinion. i don't what counts as "serious" application development in your world, but i've seen quite many good, performant applications around written in js. and servers too!
The ideal of an IT dept is to force all of their users to use only a locked down ipad. Of course they won't be able to achieve any work on them, and productivity will go down the drain, but that's not the problem of the IT department.
This was kind of true with OneNote up until recently. There are currently two desktop versions. One that comes with Office and looks/feels like the rest of the Office suite, and one that is made with UWP and available for free from the Windows Store. That one looks/feels a lot like the Android/iOS OneNote app.
However, they've announced that they're EOLing the Office version, with bug fixes through 2020 and security updates through 2025, and are continuing forward with the UWP version.
Perhaps we will see a future where they EOL the other Office applications in favor of new versions that are more similar to the iOS/Android versions. The iPad versions of Excel and Word are already pretty good.
In the past the reasoning to replace the menu system with ribbons completely and not allowing to switch back is the understandable desire to not having to maintain and test two different UIs all the time. Two different ribbons may still work, as the ribbon already has information about "importance" or "prominence" of each item, but I fear eventually there'll be only one remaining in the future.
The positive side of breaking compatibility with all legacy technologies (COM, VBA, XLL, etc) that currently force large companies to stick to MS Office is that it has the potential to reintroduce competition in the office-like software space. And in my opinion Office is the main reason why large enterprises stick to Windows. Most internal apps are moving to the web. If office backward compatibility goes away, then it's not clear that Windows is an obvious choice anymore.
And it is kind of consistent with Microsoft's new strategy to de-emphasize Windows.
It's just a tiny example of how silly this whole thing is. What's the point of having a committee to draft and design an language that can't even be bothered to have a working Set implementation? It simply doesn't make sense.
It's not about adding a method or two, I showed one symptom of a much larger problem. Of course one can add a method, but then why bother with the default crippled implementation in the first place? I'd rather have nothing and go find a third party library than having a half-assed one that's almost useless.
> You have no idea how to use the language because you don't use it.
Doesn't it depend on the benchmark? Yes, for some numeric problem as described here (https://www.linkedin.com/pulse/algorithmic-performance-compa...), the 7% figure seems reasonable. But for a real world app with object creation/deletion, the C++ memory model at a lower level would provide a much better performance over a garbage collected higher level one.
And even if (hypotheically) the performance difference a constant 7%, that is still a tangible cost.
I know, right? Friendly, bearded, probably lives on the west coast and uses a Mac. Ugh. Can't wait for new technology to make these pathetic hipster devs hired by Microsoft for their abject lack of competence to go out of work.
You wrote this comment thinking that you're right; that the only thing that is not hipster is ASM and being socially awkward.
But you're both wrong, and I know it's obvious to everyone reading this comment but I'm spelling it out for you and OP specifically because nobody ever calls anyone out correctly.
There is a nuance to technology; it's not black and white and leaping to the extremes is not helping.
My point is (if I'm trying to make one), making things natively is certainly better for users RE: desktop software. So if you care more about your users time and their resources than you do your own development time then it makes sense to do it in a native language. (Not ASM, that's facetious)
The question invariably becomes: "Yeah, JS is /classically/ a bad language, mostly known by people who aren't formally qualified programmers who understand systems"
"Yeah, but can you imagine making something cross platform in C++ in 2018! talk about foot guns!"
There is middle ground here, but unless we can talk about it professionally and with charity to the "other side" then we'll never get anywhere.
Compare the JS talk here to how sanctimonious everyone gets when PHP comes up. Then it’s “right tool for the job”, “don’t hate on something just because you don’t prefer it”, et cetera. When JS is the topic, well, see for yourself. Amazing.