Again, I'm not saying it's going to happen. But people were making similar arguments about linux in 1996: "Windows just works." And very similar to linux, it dropped the barrier to entry for server programming. Either you had paid through the nose for Unix, or you were coding on NT, and your company was paying through the nose for the server licenses.
Don't get me wrong, I really like FPGAs. I genuinely think they're the coolest tools in embedded engineering, full stop. However, a big part of the allure is how incredibly arcane and niche they are.
Isn't that the point of LiteX and Migen though? To reduce the barrier to entry in time and budget? Before the RPi came along SBC's were fairly expensive, and the RPi was only able to offer a product at that price because of scale.
And here we have an FPGA based video processing platform for only $350 produced in low-volume. https://hdmi2usb.tv/numato-opsis/
I'm not saying you're wrong, I just don't think your argument is as much of a slam-dunk that you think it is.
Reprogramming them is not a chore at all anymore since you can write stuff for them at a much higher level of abstraction then you can for microcontrollers. Complexity only really starts once you start having issues with timing closure or are forced to implement an DDR SDRAM controller. This all heavily depends on the toolset you are using.
It seems like that's more about having a cheap desktop computer than doing electronics? But I already have a desktop computer.
Whatever you go with, as a beginner you're going to want a lot of help from pre-written software. The Arduino IDE and Wiring/Arduino standard API is a good example. The mistake I made with my first purchase was not making sure that a good audio library was available for the hardware I picked. (I might consider writing one for fun, but not in C++ since I don't have much experience in that language.) But it looks like Teensy has a nice audio library, and there are other projects that look intriguing like Bela and Axoloti.
I expect (speculating) that a similar rule would apply for an FPGA; it would only be appealing to most beginners if someone more experienced came up with an interesting design that makes use of an FPGA and documented it pretty well, so you're not starting from scratch.
It's hard to compare working with an HDL to working with a programming language like C; they are fundamentally different. The short answer to that question is that using an FPGA can lead to massive but situational performance increases. You can't use an FPGA for everything, but when you need it, you need it.
>testing then export designs into hardware
This is another common use case. Some designs can be tested on an FPGA before committing that design for production as an ASIC. There's also the case where you may need to reconfigure the hardware, so you can never truly commit to an ASIC, and continue using the FPGA.
For many projects, people choose something higher-end than an Arduino because their project requires more compute or memory than the 8-bit microcontroller in the Arduino can provide. Common issues:
- You need to do math with larger numbers (anything > 16 bits is really slow on the Arduino), or need to do lots of math.
- Your working data exceeds the ~2 kB of RAM.
- Your project's binary exceeds the ~32 kB of flash.
With that being said, the Raspberry Pi isn't necessarily the best candidate for every project that exceeds these constraints. The Pi is basically the cheapest possible board that includes a graphics card that can handle HD video, Ethernet, and WiFi. It also has a lot of RAM compared to other single-board computers. It is weaker for "real-time" applications like signal processing - if you need to do that sort of thing you might want to look into buying a BeagleBone Black, which has two "programmable real-time units" (PRUs), which are basically small auxiliary microcontrollers that can be used to handle the real-time work.
There are other cheaper/lower power parts in between the Arduino and the Raspberry Pi/Beaglebone level of complexity, but many of them require complicated tooling and libraries that might be difficult to use if you're not already pretty familiar with embedded development.