Things I am looking for:
* The web/app one man show stack. What's the most reasonable way to get there, alone, assuming you start from scratch with now expectations about the tech you are going to use.
* Flexibility, initial dev speed and maintainability. I am looking for a stack that can work reasonably well for websites and apps, on the web + android + ios, or any subset of those. The less redundancy and additional parts to learn to make it all work, the better.
Things I am willing to give up:
* App speed and performance, specially on the client side. webviews are okay, if it eases the dev process.
* Matureness. I assume if something had already won in this space it would be apparent.
* Beginner-friendliness. I don't need any amount of no code, and I don't care if it's easy to pick up (but if it's not I do expect something tangible in return for my additional brain cells. I am not looking for something exotic, for the sake of being exotic. If there's two solutions that check all the other boxes equally, for this particular exercise, I am going to pick the one that's simpler.)
Things I am currently looking at include Flutter and Meteor, and maybe Rails with Hotwire (as soon as Strada is released). There's no need for all the required tech to fly under one name, but I'll probably grow increasingly suspicious the longer the list grows.
EDIT: If you take the time to respond, that's super cool, but if you are actually trying to answer the question, please be specific and point at the individual components.
Buy this: https://jumpstartrails.com/
Then also use either TailwindUI or Flowbite.
~$400 later, you probably saved 100+ hours of boilerplate setup, and you can pump out realtime web apps with a reliable tech stack and can fairly easily port to mobile with Turbo-iOS/Android.
You don't need to wait for Strada, they've said it's just going to be some additional helpers. You can build mobile apps now with Rails and Turbo.
- Start with SaaS Pegasus https://www.saaspegasus.com/
- Deploy to Heroku
- Get comfortable with "X-in-HTML" frameworks - Tailwind, HTMX, Alpine
- Deliver your mobile app as a PWA https://web.dev/what-are-pwas/
(Nowadays I'd replace Turbo/Stimulus -> HTMX/Alpine)
Special thanks to Cory for his excellent guides on Django + JS: https://www.saaspegasus.com/guides/
you basically have HTML++, very gentle learning curve, you can leverage your back-end (which is where you are going to add the most value) and just get on with it without a huge investment in front end architecture
i am the creator of htmx
You can get most of this from just using https://legendaryframework.org/
Want native apps? LiveView Native is a thing https://native.live/. One app to do it all.
It lets me use vue js as laravel views and pass data around without the need of an API. This just makes development super fast.
I went even further and used laravel jetstream, that comes with inertia js and with Auth and other useful stuff already solved
Clojure for web stuff is fairly mature. Cross compilation between Clojure and Clojurescript allows you to write code that runs both on JVM and Browser. There are endless attempts at web frameworks for Clojure(script) to get you off the ground faster. My suggestion would be Luminus if you are not incredibly experienced with it.
Speaking from experience, the expressive nature of Clojure, as well as functional programming, lends itself to concise syntax, suitable for solo development.
You may find less mature tooling in Clojure land when it comes to mobile development. There is a react native library for Clojurescript called Krell though I can't speak to how well it works because I haven't used it before.
If you don't have experience with JS/JVM, you'll have a steeper learning curve as a lot of Clojure(script) libraries suffer from software rot (probably) requiring the use of Java or Javascript libraries via Clojure's interop feature. Interop works well, but you'd still need to be mindful of the host (JS/JVM) quirks like managing state and constructing objects.
I write backends with either a static server, AWS Lambda, Python aiohttp or Java with JAX-RS. The last two basically work like Sinatra. I have used Java at work since Java was in beta so I am comfortable with it and I have almost as much experience with Python. I have a lot of fun developing little applications for myself (a party controller for my music system, a workflow application for handling job applications, a similar system for constructing machine learning data sets.). Java though rules the roost in terms of being reliable under heavy load. I really have a lot of fun though with websockets in aiohttp.
For front end I have been using React, use MobX when appropriate, but I am thinking about how to transition to WebGL (maybe react-three-fiber) because I am inspired by video game interfaces, AR, and such.
I’d say that any shoestring project needs a lot of de-risking and you have to balance time spent learning and doing. If you are learning a language and framework that is radically different from what you know then you are going to do very little. Thus I’d tell people to stick with something they know if they like it. If you project is ambitious and time is limited you just add something new (like the WebGL stuff for me) only if it lets you do something that would otherwise be impossible.
Does anyone have experience with https://github.com/hotwired/turbo-ios or https://github.com/hotwired/turbo-android ?
Flutter is a dream to work with. Very rapid development with hot reload. Firebase is great for abstracting away almost all the dev ops bs. You can use local emulators for rapid development there too. It's quite a nice stack.
I happen to love Dart, and tolerate Typescript. I get to almost completely escape the js build hell, but Firebase functions do still require either JavaScript or Typescript.
I will include the caveat that Flutter web is not the best target for forms/text heavy projects. Flutter does all is own rendering so you don't get the html stuff like Ctrl f, copyable text, css "for free".
But for true apps that you don't just want to look like a word press site, it's awesome.
Most of these are back + front.
After a lot of experiments, I ended up with the idea that once I know a hammer (framework, language) I will see everything as a nail.
So I went for
Front: Quasar (quasar.dev). It is based on Vue and recently also on Vite. Use that combo. Also Typescript.
Pros: very complete, has everything you need for an average front, including PWA or of the box. Very good documentation.
Cons: the community is meh. Rarely someone respond and the SO tag does not have a lot of traction.
Back: I used to be pure Python, now I try to do everything in Go (after an initial strong dislike I learned to like the down to earth code)
Infra: everything goes into a docker container, this makes dev and deployment sooooo much easier.
> Ask HN: Companies of one, what is your tech stack? - https://news.ycombinator.com/item?id=32960033
I was hoping someone would compile all the responses into a table or chart. Surprisingly, the top-voted comment is about WordPress.
If you're aiming for web + Android/iOS, I would say React and React Native with shared API(s). The backend could be external or custom built, most likely a combination, written in any preferred language like JavaScript, Go, etc.
I'm using it with React, but any frontend framework would work with it. It grew up along with Rails so there's some similar thinking, and you can choose which level of bare metal or magic that you want depending on what you're doing.
I also recommend considering something like GraphQL for your API interface as it will reduce the amount of times you have to dip back into the back-end to add a single property to a response or write a new optimized endpoint for a particular view.
Front-end IMO it really depends on what you’re trying to build, React Native doesn’t really reduce your overall work IMO so much as the cognitive load. You still end up not only having a separate codebase from your web UI but also have to at times dip into xcode and angular studio to write some platform-specific code. I would probably explore Flutter if I really needed to write something once, but I can’t really comment on it today. For the stuff I work on I usually just try and make the web experience as mobile-friendly as it can be and leave it at that. For B2B customers that’s almost always sufficient anyway. I tend to work in Angular more often than React and have been pretty happy with the amount of reuse I get between projects and the quickness of the dev loop.
From the docs:
> Building an app with all the modern best practices is fiendishly complicated. Those practices include build optimizations, so that you load only the minimal required code; offline support; prefetching pages before the user initiates navigation; and configurable rendering that allows you to render your app on the server or in the browser at runtime or at build-time. SvelteKit does all the boring stuff for you so that you can get on with the creative part.
App support is the tricky part in my experience. I haven't found a workflow that I love yet.
Developing for web and creating an app that wraps the website works fine. The problem is that you'll likely get rejected when submitting to the app store & play store.
You could go with Flutter for app & web or react-native-web but it's still very early days and there's lots of issues. I find it's not worth the effort.
The best compromise I do right now is React for web. And then a separate react-native app. Realistically, you could have similar architecture for handling data. However, the rest will still be different. Eg: Routing & Display components.
At that point you’re free to decide how you want to run your client side, I tend to start with HTML and avoid JS until it’s necessary, then convert where relevant into React. As other posters have mentioned Tailwind is awesome for avoiding writing custom css, there’s a class for literally everything.
Clear separation between your API and your FE pays off down the line.
- go, a natural fit for backend with types and compilers and speed
- clojurescript (and react via reagent), a natural fit for frontend with dynamism, flexibility, and data centrism
- aws, a natural fit for infra. like linux, literally everyone is using it. if you avoid architect advice and tape over most of the knobs, it’s quite good
example:
Good starter: https://github.com/graphile/starter
I can add a column the the db, and my frontend gets that autimagically (in dev mode, it generates a graphql schema out of the db, and from that it creates composables for my frontend wiht graphql-codegen). On the frontend I use Vue 3, the starter is build with nextjs/react.
Additionally, I found Firebase to be a really great way to start and run projects. The most important piece of that is Firebase Auth which solves a complex and important problem without costing an arm and a leg. Other services such as Hosting, storage, and functions were really easy to start with.
Vue with Quasar is pretty good for getting you a good development velocity in the front end and has a lot of useful build targets. I like to build fat clients to minimize what the server is doing. If you can just convert an image to the proper sizing in the front end, why not just do it there? Lowers your cloud costs and makes what there is nice and responsive, just need validation.
The backend can be whatever you prefer.
it's the most boring part of a system to me, but if it's not built in from the start then it's a terrible time trying to back it in. it's one of those things that stops me from ever starting a project.
For database I use Datastore and for storage I use Cloud Storage.
Front end uses an express app that routes the marketing pages to static html pages and then routes everything starting /app to a generic html file that uses React to render everything / sort out routing.
Still looking for what the best database-as-a-service is though.
For the web, you have ASP.NET Core. It feels like Rails or Django, but with static typing that makes a lot of things easier. You can do things like `db.Books.Where(b => b.PublishedAt < DateTime.Now && b.Rating > 3 && b.AuthorId == 101)` and you get all the normal auto-completion because it's statically typed. With .NET, you can compile down to a single, self-contained binary which makes it really easy to deploy a simple app and Microsoft has really easy Docker container setups if you want to deploy with Fly.io or anything else. You also get the benefit of more speed than you'll get from Ruby or Python. That's certainly not a deal-breaker with other languages, but it's always nice to have something that is just a bit faster.
ASP.NET also makes it really easy to get started. I think a lot of things that aren't named Rails or Django don't make it easy to get started - or they make it easy to get to "Hello World," but then you're left with "uh, how do I connect to a database? I guess I find my own library for this? Is there a template engine? Wait, do I need to choose a JSON serializer?" One of the things that makes Rails and Django so great is that they offer you a great starting experience. ASP.NET offers that Rails/Django-like experience.
It's also simple to return JSON from your endpoints to create an API for your front-end (if you want to use React or something) or your mobile apps.
C# feels a lot like Kotlin to me. It's a Java-like language that has made practical decisions that make it a lot easier to use. There's a lot of things that just make it pleasant to use, if you're looking for the imperative/OO style of programming you'd get with a Ruby/Kotlin/Python/Java/etc. If you're looking for Lisp, it's not Lisp.
C# and .NET are both very mature and Microsoft is putting a ton of work into the ecosystem. Performance is already top-notch (which basically means equivalent to Java and Go in the GC world) and they're continually improving it every year. They're investing in a lot of great stuff like Blazor which is basically a replacement for things like React and Vue, but using C# and Razor templates via WASM (and that can also be executed on the server).
`dotnet watch` is just great. It'll hot-reload your code when you change things and when there are edits it can't hot-reload, it'll recompile and relaunch in a second or two.
.NET offers MAUI (Multi-platform App UI). Basically, write your apps in C# and MAUI and get native apps for Android, iOS, Windows, Mac, Tizen, and likely community-support for Linux. MAUI has some rough edges, but it's getting better and you can always web-view your website to begin. At the same time, Microsoft is putting a lot of effort behind it and I think it will pay off with nice apps that use native widgets without requiring two separate code bases. You've noted Flutter and that's probably the biggest alternative, but Flutter doesn't use native widgets. That's not necessarily bad, but it does mean that the apps are probably going to feel a bit less at home on iOS. There's also the chance to basically share the objects that you're returning as JSON from your backend with your mobile app. Instead of having your backend `Book` class and then making sure your Dart front-end's `Book` class remains in sync with any changes, you just have a single `Book` and don't have to worry about it. You talked about "redundancy and additional parts" and while keeping that stuff in sync isn't necessarily hard, it can be an annoying task that doesn't bring joy. Heck, one of the big things about Rails was that so many stacks made you do tasks that weren't necessarily "hard", but really didn't bring joy - especially when you were searching for a typo that just made things not work.
The great thing about Rails is how productive it lets one person be. You aren't spending your time choosing libraries and wiring things together. I think ASP.NET Core offers that and more - static typing, great performance, and dead-simple deployment with self-contained binaries.
Personally, I'm liking HTMX for adding interactivity to my app. I don't have the most experience with JS out there and I'm not looking to create something that needs the level of interactivity that might require React and it allows me to do the things that will be nice for users.
If I were looking for more interactivity and didn't mind giving up a little "App speed and performance, specially on the client side", I think I'd reach for Blazor. I believe .NET 7 (coming in November) will be making improvements in Blazor performance and client download size, but it's still decent with .NET 6. Plus, improvements to WASM will make Blazor a lot better. Right now, GC'd languages need to ship their garbage collector as WASM code in the download, but it looks like WASM will handle garbage collection natively in the future. Blazor is around half as fast as React and the download sizes will likely be 3 times as large, but as Microsoft improves Blazor and WASM gets better the gap will likely narrow. Plus, with Blazor, you can just create a .NET MAUI Blazor app and now you have your iOS/Android apps. Later, if you want a more native experience on iOS/Android, you can shift to a native .NET MAUI app (rather than web-view powered).
What are the downsides of the .NET/C# ecosystem. First, I'd say that if you're not on Windows, you're going to want to pay for JetBrains' Rider ($150/$120/$90 per year for first, second, third+ years). It just works and it's wonderful. There is a Visual Studio for Mac which is decent and better than a lot of IDE/editor ecosystems out there for other languages. There is VSCode with its C#/.NET support and again it can be decent if you're used to working with an editor that doesn't help you 100% of the time. Rider can just be so pleasant though. Also, once you get over a certain amount of revenue or employees, Visual Studio Community isn't free. If you have over 250 PCs or $1M in annual revenue, you have to pay the $500 for Visual Studio Professional. That isn't much compared to the $100,000-300,000 per year you're paying a developer or even the $150/year you're likely paying Slack, but it can certainly be a turn-off to some people. There is always VSCode which is decent and free and Rider which is just wonderful (and only $250/year for businesses from the third year on), but I know some people just hate the idea that the best editor experience might cost some money (and that most people in the C# world will just pay $100-500 a year to get it rather than fighting the system for open source).
Second, I'd say that nothing really matches Rails' asset pipeline in terms of letting a backend-heavy programmer have a decent front-end setup without having to dive into the whole world of Grunt/Webpack/Gulp/Browserify/etc. It's been a while since I've used Rails, but I remember that being such a nice addition. Microsoft does have some docs (https://learn.microsoft.com/en-us/aspnet/core/client-side/bu...) and you can always use Gulp or Webpack or whatnot and LigerShark's WebOptimizer will let you minify and bundle things in C# (and handle TypeScript compilation, Sass, vendor prefixing, etc), but I remember Rails' opinionatedness being kinda nice for this.
Finally, I'd say that C# and .NET can be annoying if you care about little things. For example, I've heard a lot of people debate significant whitespace vs. opening/closing braces or tags. If you care about those things, C# might be a bit annoying. I'll give you an example to illustrate. This is what a simple data class would look like in C#:
class Person
{
public string Name { get; set; }
public int? Age { get; set; }
public boolean IsAdmin { get; set; }
}
I get complaints like that, but it's also stuff that kinda falls into the background when you're actually trying to get work done. Java beans didn't fall into the background. You'd be fighting constant little cuts and it would be hard to differentiate a class that had special behavior from one that was just a basic bean. The properties in C# are easy to see that they have no special behavior and easy to see when they do have special behavior (you can just do `{ get => _age + 10; set => _age = value; }` if you want a custom getter).
ASP.NET Core really grabs so much of the best ideas out there in a language that's really good with great IDE support and dead-simple deployment as a single binary - and all with one of the biggest companies out there funding people to make it better, write docs, etc. And it takes time to write great, in-depth posts like this: https://devblogs.microsoft.com/dotnet/performance_improvemen.... I find it a pleasant place to develop where I can just focus on my work.