6 ms·
First off, this article isn't actually answering the strawman question it looks like its asking. I think most people who don't work in the space would assume th
by jcranmer 5y ago
First off, this article isn't actually answering the strawman question it looks like its asking. I think most people who don't work in the space would assume the question means "why aren't there people selling new languages/compilers?" That's a strawman question with a trivial answer, though--free compilers have been the de facto standard for decades [1], so if all you have is a new compiler or a new programming language, you're going to make only a pittance on it directly.
The actual question is why are there so few startups for people who work on PL technologies--which isn't limited to compilers or programming languages, but includes things like IDEs, debuggers, static analyzers [2]. For example, Coverity--a decently well-known paid static analyzer--is kind of the best model of what you'd expect to see more of here. So it is somewhat more interesting to ask why this tool space isn't particularly well-served as a market.
[1] The biggest exception to the rule is custom hardware (particularly embedded, but this also holds true for mainframe and HPC systems), where custom compilers come for the ride. But that would be a hardware startup, not a PL startup, so it doesn't really count.
[2] I tend to lump in decompilers into the formal methods/PL/compilers/software engineering/computer architecture spectrum, mainly being a low-level compiler developer myself, but I suspect most people would consider reverse engineering tools to be a security side of things rather than a PL side things. And decompilers are certainly another noticeable successful paid-software niche, with the very expensive IDA Pro still remaining more or less the industry standard.
- lalaithion 5y agoSelling static analyzers are hard. Your customer either has a bunch of code, none of which was written with the static analyzer in mind, and so they have to spend a bunch of time fixing spurious errors and warnings, or they have no code, in which case they probably also have no money to pay you with.
- NordSteve 5y agoI've implemented static analyzers in several codebases, and every time it's paid off in finding multiple "must fix" bugs.
- acdha 5y ago> so they have to spend a bunch of time fixing spurious errors and warnings It's rare for a tool to be so shoddy that this is all you get. From what I've seen, you'll get three categories of report: valid bugs, valid bugs which the developers insist are false positives until forced to do in-depth analysis, and actual false-positives. The exact ratios vary depending on the tool in question but generally I've seen the first two categories be a good bit larger than the third.
- colinmhayes 5y agoMy last job was a fortune 500 that decided to start using a static analyzer on a 20 year old project. Thousands of false positives and less than ten true positives after hundreds of hours were spent going through it. Now the codebase was definitely a piece of work which is why there were so many false positives, but there were plenty of "the static analyzer is horrible" false positives too.
- acdha 5y agoYes - I’m not saying that you won’t see false-positives, but I’ve rarely seen a project where it didn’t find real issues, including some that people resisted accepting (including exploitable security holes). If you approach it determined to reject everything, or to blindly follow the tool, you’ll get poor outcomes. If you view it as a tool which can help you improve your code and triage results accordingly, you’ll almost always have better results.
- naasking 5y ago> Thousands of false positives and less than ten true positives after hundreds of hours were spent going through it. Ten true positives could very well be worth thousands of programmer hours if they're severe enough.
- geofft 5y agoI think this depends on two things: 1) Quality of existing language/compiler. Some languages are more prone to turning carelessness into exploitable bugs than others. Some compilers are better at flagging questionable practices than others (and, as an approximation, newer compilers for basically any compiled language are better than older ones). 2) How much you care about fixing the problems. If a team is understaffed and asked to overdeliver, they have no time for fixing technical debt of any sort, whether static analysis warnings or old cryptographic hashes or whatever. Static analysis tools do best when 1 is low and 2 is high. But that's unusual. First, you never start a project in that situation. If you care about the sort of bugs a static analyzer will find, you almost certainly are going to pick a good ecosystem to implement in. So you're working with legacy code, almost by definition. And if you have the bandwidth to address tech debt, there are many ways to use better toolchains and deal with legacy code. And this isn't a "Rust solves everything" post - frankly, upgrading your C/C++ compiler and listening to what it says will get you a lot of the way there. But that itself tends to be a sizable tech-debt-reduction project. (I'm one of the people on the GCC upgrade team at my own workplace, and we do justify the work to senior management by pointing out that new warnings are helpful for code quality, and we do spend time addressing those warnings.) We also have more tools and frameworks for moving parts of your computation to a different language or toolchain (more norms around microservices, better serialization libraries, etc.) if you want to go the rewrite route but want to do it incrementally. And there are plenty of language choices for a rewrite; frankly, most use cases in the '90s that needed C++ will do just fine today with unoptimized and easy-to-read Python. So, if 2 is high, you have a lot of options other than static analysis. (Aside: the post is about PL startups. I would bet the average PL grad would rather work with the ecosystem of a new, modern programming languages that has benefited from recent research than write tools to work around an old and known-suboptimal one.) I think the only real case where static analysis can work is where 1 is low but the choice to buy the static analysis tool causes 2 to become high. Basically, it acts like a consultant. The devs already know, vaguely, that the code is crap, and they wish someone would give them resources to fix it. Senior management buys a shiny static analysis tool, which is an objective outside voice saying how bad the code is. They tell devs to fix it, and devs are happy to knock out obvious fixes, your category 1 - and they'll still debate the non-obvious fixes, your category 2, because they're not being motivated by the static analysis tool, they're motivated by their own sense of what code is crappy, they just know that their new OKR is to silence all the static analysis warnings. That's certainly a better outcome than not fixing anything, but that's still a worse outcome for the company, probably, than asking your devs what's wrong with the code and how they want to fix it.
- fredophile 5y agoI'd day there's another big group you're missing. People with large codebases that compile with tons of warnings that just get ignored. If you aren't willing to spend the time fixing the existing warnings to prevent problems why would you spend money on a tool that will give you more of them?
- zwieback 5y agoCoverity is what I was thinking of when I read the article, also Resharper. Since I work at megacorp I have access to licenses but I think the problem is that running these tools effectively adds a lot of overhead. We programmers are a jittery bunch so planning ahead and integrating these tools and then spending the time is hard. Back when I started my career almost nothing was free. At the time I worked at a startup and we were always drooling over the stuff in "Programer's Paradise". We did pay for a few crucial tools but couldn't afford many. Times have changed a lot since then and the fact that high-quality compilers and IDEs are effectively free has raised the bar for paid products substantially.
- majormajor 5y agoIs the answer "because tools for themselves were one of the first things developers made"? That's like a forty year old market that's already gone through consolidation and commoditization. The author talks about how a lot of the tools currently being pitched are not that useful day to day - the static analyzer, say, that shows you the ten thousand things you could improve but never actually will. Lots of devs out there using print statements instead of proper debuggers, so even the existing tools often offer far more than they think they need to learn! From there, my guess would be that the space of truly useful groundbreaking tools that wouldn't be just competing with a good-enough free one or an established incumbent is pretty well explored. This isn't as true for new areas - Kubernetes management interfaces tend to majorly suck, say, especially if you aren't a keyboard fiend who's going to get the hang of k9s quickly - but new areas are also niches that could be risky to try to build a company in. And probably also still suffers from the "don't know what I don't know" issue. "Why aren't developers more interested in tools" is an interesting resulting question, to me, then. I think it probably has to do with the business-driven focus on building new systems and new features at high speed. We aren't building code to last for more than a few years, in many cases, so how deep is it justifiable to go on a particular block of it?
- skmurphy 5y agoThis is a good analysis. The core question is, "Why aren't more startups are working on programmer productivity." My early experience was in system design for board level and chip level systems (e.g. ASICs, FPGAs, SOCs) where there is considerable investment in tools ("electronic design automation" because we had some clear metrics for developer productivity. My simple answer is there are multiple reasons: + The industry has been very well served by open source tools. + Outsource development and test firms tend to bill by the hour not the result, cutting hours lowers their revenue. + Coaches tend to focus on methodology and process results, not programmer productivity. + Managers of the programming / development function don't appear to devote cycles to determining where investment in commercial tools would pay off. There are exceptions. + First level managers tend to measure success by headcount, mirroring the outsource development and test firms, and not results. --- I think there are significant opportunities for startups developing productivity tools but they are in niche markets that complement existing open source where development teams are paid for or rewarded on results not hours.
- brundolf 5y agoHere's my theory: tools for developers are one of the most obvious and satisfying kinds of projects you can work on, and immediately benefit the person working on them, which means the free/open-source options are exceptionally competitive (compared with the free/open-source options in other categories) Though there is probably also a "commoditize your complement" effect going on from big tech. Just look at VSCode: it's incredible - Microsoft could definitely charge for it - but they aren't even interested in doing that.
- q-big 5y ago> it's incredible - Microsoft could definitely charge for it - but they aren't even interested in doing that. Because the telemetry data is worth more to them.
- phillipcarter 5y agoNot really. I mean, the telemetry data is important to the business, but it ain't the reason why VSCode exists. A much bigger value is that VSCode brought Microsoft into the consciousness of developers who would have otherwise never thought of using a Microsoft product for anything. It's been so successful that there are even classes of developers who think that "Visual Studio" refers to VSCode, not big-poppa-windows-application Visual Studio. Source: I worked in the dev tools business at Microsoft for the past half-decade.
- Fire-Dragon-DoL 5y agoThat's very reasonable. Our company looked over at azure while it wasn't even in the back of our mind some years ago.
- kungito 5y agoI'm not sure you are being completely honest even though you say you worked at Microsoft. VSCode exists because Visual Studio is becoming harder and harder to maintain and they wanted something to target all the other languages not supported by VS2019. Also, they use Visual Studio Code to upsell their other paid services. They have first class integration with Azure and GitHub meaning the first thing people try to use with Microsoft's free service is some other paid services. They have the same playbook with Windows -> Office & OneDrive ecosystem. I'm not saying this is bad or evil but let's first be honest
- AceJohnny2 5y ago> [1] The biggest exception to the rule is custom hardware (particularly embedded, but this also holds true for mainframe and HPC systems), where custom compilers come for the ride. This is exactly what RISC-V was created to address. People here get excited about running Linux on it, but really the goal is to have a flexible, extensible ISA that can be used from microcontrollers [1] to DSPs, GPUs, & TPUs. Full-on Application Processors, with their FPUs, MMU & Cache, are only a small part of the design space of RISC-V. The shared ISA means the rest of the stack could share and leverage tools. Any day now ;) [1] https://www.espressif.com/en/news/ESP32_C3 https://www.espressif.com/en/news/ESP32_C3
- AceJohnny2 5y agoFor this information, I recommend viewing Dave Patterson's "50 years of Computer Architecture" talk: https://www.youtube.com/watch?v=HnniEPtNs-4 https://www.youtube.com/watch?v=HnniEPtNs-4 Dave Patterson is one of the creators of RISC-V, and his credentials include pioneering RISC, the original concept. https://en.wikipedia.org/wiki/David_Patterson_(computer_scientist) https://en.wikipedia.org/wiki/David_Patterson_(computer_scie...
- amelius 5y agoMy theory: no sane programmer wants to be locked-in by the vendor of a programming language. Hence, all successful programming languages are open and free.
- quantified 5y agoHow open? Neither Go nor Kotlin cost money to use, so I’ll give them free.
- native_samples 5y agoWhen was the last time someone forked a programming language? (note: not a runtime, a language) In practice the only kinds of languages you don't get locked in to are those with excellent interop with other languages. It's got little to do with whether the reference implementation is open source. Kotlin's lack of lock-in doesn't come from the fact that it's open source - that's nice but in practice most community contributions are small. It comes from the fact that you can recode individual classes in Java if you so wish. And in fact, even convert Java to Kotlin automatically, if you're going the other way. Also, lots of developers have written code in proprietary languages with a single vendor. It's HN groupthink to believe that nobody 'sane' does this. Look at ABAP, Apex or MatLab. All very widely used, even though you may not have heard of them. In the past Delphi was also very popular, and it's only recently that the C# compiler went open source.
- AnimalMuppet 5y ago> When was the last time someone forked a programming language? (note: not a runtime, a language) Python 2 -> Python 3? Perl 6? I know, neither of those intended to be a fork. Before that, C# could be considered as a fork of Java, and C++ as a fork of C.
- capableweb 5y ago> Before that, C# could be considered as a fork of Java, and C++ as a fork of C. C# and Java might be eerie similar, but by no definition of "forking" might C# be considered a fork of Java. Maybe you could consider it a fork of C as its original name was "C-like Object Oriented Language" (COOL).
- rz2k 5y agoWould you consider proprietary solvers or optimization software in that category?
- ibains 5y agoWe’re building a primarily PL startup at Prophecy.io - Low Code Data Engineering Platform. We user parser combinators heavily, code generation and all. Hard to find skilled engineers these days in compilers though. The Low-Code movement seems very focused on programming, no?