21 ms·

Ask HN: What novel tools are you using to write web sites/apps?

• j-rom 6y ago
  I built GoodPlates [1] using Netlify [2] for rendering the HTML, JS, CSS. Instead of using vanilla CSS, I used TailwindCSS [3]. My backend consists of API Gateway [4], Lambda [5], and DynamoDB [6]. I also use CircleCI [7] for deploying my API Gateway / Lambda changes. [1] https://findgoodplates.com/ https://findgoodplates.com/ [2] https://netlify.com/ https://netlify.com/ [3] https://tailwindcss.com/ https://tailwindcss.com/ [4] https://aws.amazon.com/api-gateway/ https://aws.amazon.com/api-gateway/ [5] https://aws.amazon.com/lambda/ https://aws.amazon.com/lambda/ [6] https://aws.amazon.com/dynamodb/ https://aws.amazon.com/dynamodb/ [7] https://circleci.com/ https://circleci.com/
• runawaybottle 6y ago
  Many things can be a text messaging service or an email digest if that helps you think outside of the box.
  • anonymouse008 6y ago
    This is the next big thing. Companies like Attentive are way ahead of the game.
• crazypython 6y ago
  Semantic HTML, CSS, Vanilla JS, and JAMStack. Semantic: embed data directly in HTML. If I have a list of wines with categories, each wine's "class" attribute has a class for each category. HTML: can be generated by anything and consumed by anyone. Great SEO. CSS: These websites were all made with the same HTML, only CSS changing. http://www.csszengarden.com/ http://www.csszengarden.com/ Let's imagine we have a checkbox, that when checked, should dim every wine that is not a white wine. Next to it is a div of wines, with the "container" class. The div contains wine elements. 3 lines of CSS: input[type="checkbox"].whiteWine:checked + .container > :not(.whiteWine) { opacity: 0.5; } You can replace the checkbox's appearance with an image, a video, just about anything– it doesn't have to look like a checkbox. This would take many lines of JavaScript in any other framework. Instead of attempting to warp HTML into a UI library, this uses HTML as a data format, and CSS as a way to present that data.
  • nickthemagicman 6y ago
    IS CSS really this well featured and expressive these days? I havent tinkered with it in years.
    • b0afc375b5 6y ago
      Yep, thank god for flexbox and grid layouts.
    • chrismorgan 6y ago
      :checked and :not() have been dependable for quite a few years now. Firefox has had ’em since at least version 1 (2004), Safari got ’em in 3.1 and 3.2 (2008), and Internet Explorer was the last player to the table in Internet Explorer 9 (March 2011). The rest of the selector features (tag, attribute, class, adjacent sibling, child) are older still (IE7 supported it all).
      • nickthemagicman 6y ago
        That's totally awesome. Everyone always just jumped to JavaScript for that kind of thing with jQuery.
  • rbdone 6y ago
    What’s old is new again <3 Great example, btw!
  • dkarras 6y ago
    What happens when your wine types are dynamic? How do you typically bridge the gap?
  • busymom0 6y ago
    Wow at this one: http://www.csszengarden.com/219/ http://www.csszengarden.com/219/
    • crazypython 6y ago
      Indeed, and that website only uses 2010 CSS features.
• yen223 6y ago
  I have been exploring offline-first approaches to building web apps. In a nutshell, the UI interacts with local state, and a background service syncs local state with server-side state and vice-versa. This theoretically allows the app to remain fully functional even when offline, while maintaining the benefits of your stuff being accessible from all your devices. There's also UX gains as well - your UI interactions don't need to be blocked by network calls. In practice, that means using something like IndexedDb to manage client-side state, and modelling data as CRDTs or similar in order to have eventual consistency with the server.
• recursivedoubts 6y ago
  I am working on two alternative tools for building web apps: https://htmx.org https://htmx.org - uses HTML attributes and HTML-over-the-wire for AJAX/Web Socket/SSE interactions https://hyperscript.org https://hyperscript.org - an experimental front end programming language derived from HyperTalk that is event-oriented and that removes the distinction between synchronous and asynchronous code. Both tools are HTML-oriented and are designed to be embedded directly in your HTML, rather than along side it. I am trying to popularize the term "Locality of Behaviour" for this idea: https://htmx.org/essays/locality-of-behaviour/ https://htmx.org/essays/locality-of-behaviour/ There are a few tools that are moving people this direction these days, notably AlpineJS and Tailwinds.
  • geoah 6y ago
    on the same note, I'm really enjoying basecamp/hey's hotwire stuff together with go templates. will be checking out htmx as well, thank you for the links.
  • mrwetsnow 6y ago
    "Locality of Behavior" is how everything started, when we used to embed PHP code into html. :)
    • recursivedoubts 6y ago
      yep the idea wasn't wrong, but the level of expressivity wasn't there yet trying to fix that
  • systemvoltage 6y ago
    I've played with HTMX (and previously intercooler.js). Just wanted to say - everything you touch is awesome. Thanks for your efforts. I also like Alpine.js and Stimulus.js projects. They're trying to simplify the insanity of front-end development. Go + HTMX is super powers. It peels away the piles and piles of framework layers and still gets you 90% there. For the 10%, just use React/Angular/Vue.
    • 6y ago
• rektide 6y ago
  Still working to get to launch, but been very happy using Github Catalyst[1], a Basecamp Stimulus inspired library for easily authoring Web Components. [1] https://github.com/github/catalyst https://github.com/github/catalyst
• cpach 6y ago
  Hugo running on AWS Amplify. A really great combo for static web sites.
  • kilroy123 6y ago
    Interesting. What made you go with AWS Amplify over netlify?
    • cpach 6y ago
      I already had an account at AWS. And I like paying for services that I use. Netlify has a free tier, whereas Amplify has a low and reasonable price from the start.
• DanHulton 6y ago
  I built Nodewood: https://nodewood.com https://nodewood.com I really enjoy NodeJS/Vue for web apps, but I got sick of having to connect together all the packages from scratch each time, set up ESLint, testing, database connections, write the user auth/management, all that common stuff. So instead, I put together a boilerplate with all my common practices and basic app features. I figure, it ultimately saves me time on all future web apps, and if other people want to build a similar style of app, spending a few hundred on a decent boilerplate is cheaper than hiring a freelancer to do it for it, or even doing it yourself, if you value your time at anything higher than minimum wage.
  • williamdclt 6y ago
    My ex-company was an web agency, we were spinning out new projects every few weeks. I developped a "project generator" (more dynamic than a boilerplate) that would create a full project with Django-React-ReactNative-Postgres, with the Terraform configuration to deploy to AWS. Apparently it was huge for sales, and got projects starting on the right foot. You can probably make that into a full product!
    • xcubic 5y ago
      What kind of input did it take?
• yawn 6y ago
  Just to add some off-the-beaten-path solutions I've come across recently: https://github.com/Bogdanp/koyo https://github.com/Bogdanp/koyo - Koyo: a web app toolkit written in Racket https://github.com/yawaramin/re-web https://github.com/yawaramin/re-web - ReWeb: a ReasonML/OCaml web framework https://cons.io https://cons.io - Gerbil Scheme has an embedded web server that supports writing handlers for
  • notagoodidea 6y ago
    https://aantron.github.io/dream/ https://aantron.github.io/dream/ - Dream, also a web framework in OCaml/ReasonML
• grantlong 6y ago
  https://withkoji.com/community https://withkoji.com/community Provides "core services" for web apps much like mobile OS's do for native apps. Also allows devs to fork existing published apps and built from a pre-existing codebase. Fun to experiment with.
• k__ 6y ago
  I'm currently working with the AWS CDK and the more I used it, the more I have the feeling tools like that could be the next big thing. It's melting the walls between cloud infrastructure and application code and the fact that it does IaC with the same language I use to program web apps (JS/TS) plays an important role here. I think, it's not 100% there yet, but it's on a good way.
  • debaserab2 6y ago
    I spent a lot of time with CDK last year using Typescript. Very impressed with it and I have zero regrets after moving over our app's infrastructure to being deployed with it after 9 months in production. I felt like being forced to use typed IaC helped me understand AWS API's and services themselves better.
    • k__ 6y ago
      While I'm not a big fan of some decisions the team made when building the CDK (the whole class/context stuff feels very un-javascript-y), it was the first project where I appreciated TypeScript over JavaScript.
• news_hacker 6y ago
  I'm really enjoying working with MDX (JSX & markdown hybrid). https://mdxjs.com/ https://mdxjs.com/ I was able to quickly put together a blog with some pretty nice features (e.g. margin notes): https://pratik.is/writing/essays/media-as-food https://pratik.is/writing/essays/media-as-food Writing content in markdown while adding interactivity with JSX is pretty nifty. If you click "Raw" here you can see how the blog post is just markdown with some custom JSX elements littered in, e.g. <WrappedSidenote />: https://github.com/pringshia/pratik.is/blob/master/pages/writing/essays/media-as-food.md https://github.com/pringshia/pratik.is/blob/master/pages/wri...
• Leftium 6y ago
  SvelteKit, Serverless, Backendless.com SvelteKit[1] is a framework for SvelteJS (like Next.js is a framework for ReactJS). I've tried both Svelte and React. Svelte seems to be more elegant and lets me implement my ideas faster with less code. Svelte is very flexible; SvelteKit adds some opinions on how to do things like routing. SvelteKit also embraces the serverless paradigm[2] (AKA JAMstack[3]). Although a node.js server is still an option, you can also have pages rendered in serverless functions or pre-rendered at build time. Even static pages can be "hydrated" on the client so they are not totally static. So this results in fine-grained SSR (server-side rendering) at the page level. The two main reasons for SSR are performance (especially on mobile devices) and SEO. Backendless[4] is a VADP/MBaaS. This platform offers a lot of services, but the main one I'm looking at is authentication/identity. I was looking for an authentication service that supports anonymous guest login, social login, as well as traditional email/password login. The other contenders were Google Firebase (slow, and confusing sign in/sign up flow[5]) and AWS Cognito (too complicated/difficult to use). Auth0 was a contender, but they don't support guest logins. [1]: https://kit.svelte.dev https://kit.svelte.dev [2]: https://www.serverless.com https://www.serverless.com [3]: https://jamstack.org https://jamstack.org [4]: https://backendless.com https://backendless.com [5]: https://github.com/firebase/firebaseui-web/issues/665 https://github.com/firebase/firebaseui-web/issues/665
  • systemvoltage 6y ago
    This whole thing feels like layers upon layers of complexity. Not to mention, the brittle aspects of any javascript project - immature, lack of robustness and dependability. Your stuff is working on Node v12? Good luck with Node v14 - both LTS versions. It is a shitshow. Let's keep Javascript inside the browser IMO. SveltKit is literally 2 months old.
    • raihansaputra 6y ago
      SvelteKit as a project is literally 4 months old (since announced), but Sapper (the predecessor) have been around for longer, and SvelteKit has been used on NYT's county-level COVID tracker. There will be some teething problems but it's definitely not a totally greenfield project.
• brochington 6y ago
  I've been experimenting with ways of using Web Components with the ECS (Entity Component System) pattern. I'm not sure it will ever become the preferred way of writing web apps, but it does offer promise in exposing some alternate ways to structure Frontend code. Here is an example Calculator App I've made: https://codesandbox.io/s/fervent-elion-isq29 https://codesandbox.io/s/fervent-elion-isq29 And here is the ECS library I'm using (which I've written): https://github.com/brochington/ecstatic https://github.com/brochington/ecstatic
• rashkov 6y ago
  https://rescript-lang.org/ https://rescript-lang.org/ Based on ocaml’s type system which is a delight to use. I’ve been working on this codebase for over a year and I’ve yet to see a runtime error. Maybe there was one minor one, not sure. It’s remarkable.
• Normal_gaussian 6y ago
  For quick personal things I have a massive hack over webpack that makes anything "<filename>.static.<suffix>" into an output. This means there are no parallel directories for assets and my code can be a million times more modular. Its a hack. There are edge cases. It was a proof of concept that has carried me over the line. I even have extra plugins for server side render and compile time render. I keep meaning to write it up and try and port the tests to weboack itself (so I can argue for missing features), but it does what I need, I'm not a front end dev, im busy elsewhere (in life and work).
• kouteiheika 6y ago
  This partially might be more of a what's old is new again, but here's what I use: - 100% server side rendered - Progressively enhanced (fully works without JS, but having JS enabled makes it nicer) - In select places where I need SPA-like snappiness I use a ~100 line long DOM diffing algorithm (I request full HTML through AJAX and diff it into the current page; if the user has no JS enabled then the page just refreshes normally) - Running on a single, cheap VPS; no Docker, no Kubernetes, no serverless - No SQL database; I just keep everything in memory in native data structures and flush to disk periodically; I have a big swap file set up so that I can keep a working set bigger than the RAM - Written in Rust, so it's fast; I can support tens of thousands of connections per second and thousands concurrent users on my cheap VPS
  • marshmellman 6y ago
    What are “native data structures”?
    • blackoil 6y ago
      Not OP, but we had a similar project long back. All data is in maps and structs. We didn't had free text search, all filters had a corresponding Map of key to []ids. A primary map from id to object. Needs lots of RAM, but that is the cheapest thing we can add
    • unixhero 6y ago
      Whatever data types are available in the programming language of choice here; Rust.
    • kouteiheika 6y ago
      Normal structs, `Vec`s, `HashMap`s, `HashSet`s, etc. Basically whatever is natively available in Rust.
  • deleted 6y ago
    [deleted]
  • deleted 6y ago
    [deleted]
• santa_boy 6y ago
  I am creating content websites only using Notion nowadays. It is pretty efficient and quick to launch.
• ggregoire 6y ago
  PostgREST + React.
  • rapind 6y ago
    PostgREST is excellent. I’m using it with Elm on the front end.
    • SuaveSteve 6y ago
      Ever try PostGraphile? I'm evaluating the two.
• swlkr 6y ago
  I use janet-lang The stack lately has been - osprey (sinatra like framework) - tailwindcss - sqlite - alpine.js - turbo (from hotwire) Memory usage is really low, so I can have quite a few websites on a single VPS
• nwienert 6y ago
  Cannot recommend gqless highly enough for making graphql actually fun to use and closer to something like meteor/firebase syntax[0]. And I’ll self-promote, I’ve been working on what I consider to be a “next generation” style system for React that solves my biggest issue with it currently: being able to performantly write styles in a nice syntax that optimize for both web and native. Called SnackUI, still in beta[1]. It has an optimizing compiler that really speeds up React apps a ton, but still lets them run fully on native, even with themes and responsive queries. I’ve been hacking on a cool project for the last year using the two of them and really believe in them both. [0] https://gqless.com https://gqless.com [1] https://github.com/snackui/snackui https://github.com/snackui/snackui
• ajxs 6y ago
  A while ago I created a simple website using an XML file as a storage technology and XSLT to render it to HTML. The data stored would be updated infrequently and suited a consistent format, making XML suitable for the job. Originally the site index file pointed to the XML file and the XSLT was rendered by the browser. This worked perfectly for a long time. Even though there was some technology to learn, it was a zero dependency, browser-native solution. After a few years I decided to make everything completely static to facilitate some changes. It now uses lxml in a Python script to perform the XML transformation. This is run by a makefile and produces static HTML, which is then uploaded. My blog (https://ajxs.me https://ajxs.me) is rendered using a static-site-generator I built myself in Python. Using Python template strings stored in HTML files to create a simple templating engine. The blog entries are written in HTML format and stored in an SQLite database loaded by the build script. The final output is entirely static HTML, not even any Javascript. I'm experimenting with different formats for writing the entries themselves in, however I haven't found anything yet that gives me more simplicity and control than HTML. The LaTeX to HTML conversions I've tried were way too bloated and messy, and markdown doesn't seem to support the level of control I want. With HTML I have very granular control over the final output in the browser and can create whatever arbitrary content I need to.
• claytongulick 6y ago
  Json-patch [1] for dead simple RESTful object mutations via PUT. Mongoose-patcher [2] for using it with mongoose / mongodb. Json-patch-rules [3] for declarative security on patch operations. [1] http://jsonpatch.com/ http://jsonpatch.com/ [2] https://github.com/claytongulick/mongoose-json-patch https://github.com/claytongulick/mongoose-json-patch [3] https://github.com/claytongulick/json-patch-rules https://github.com/claytongulick/json-patch-rules
• mkoryak 6y ago
  Cider with corgi mode
• davidedicillo 6y ago
  I recently built https://listlinks.co https://listlinks.co with flask + js + saasform (to manage all auth + billing) + bulma on heroku.
• ecesena 6y ago
  Fav thread ever! A good 5+ years ago I built HasGluten [1] with react backed by a google spreadsheet, hosted on github pages. Proven technology, it's still working. More recently I hacked together MultiPreview [2] with react + API served by firebase functions. I'm also temp using firebase hosting as I have little traffic, but plan to replace it with edge computing / CDN caching. MultiPreview is backed by Saasform [3]. This is more like a classic node/express (nestjs) application, but I really like how we're separating concerns: the SaaS = MultiPreview handles the biz logic / Saasform handles landing page + auth + payments. While building the new landing page I played with and liked a lot Bulma [4], I used but didn't like AlpineJS [5] and I'm thinking to move to Hotwire [6]. My personal experience is that performance only matters when you're big enough, so in the near future I want to experiment more on usability / nocode side. And I'd love to see more open source alternatives to the big ones. [1] https://hasgluten.com https://hasgluten.com [2] https://multipreview.com https://multipreview.com [3] https://github.com/saasform/saasform https://github.com/saasform/saasform [4] https://bulma.io https://bulma.io [5] https://github.com/alpinejs/alpine https://github.com/alpinejs/alpine [6] https://hotwire.dev https://hotwire.dev
  • dejj 6y ago
    You might want to check hasgluten.com's cert: >> Firefox does not trust this site because it uses a certificate that is not valid for hasgluten.com. The certificate is only valid for the following names: www.github.com, .github.com, github.com, .github.io, github.io, *.githubusercontent.com, githubusercontent.com
    • ecesena 6y ago
      Thanks - fixing.
• bhl 6y ago
  - tailwindcss I moved a React side-project from CRA to Next.js for server-side rendering benefits, but the latter doesn't support directly importing css styles in jsx to avoid problems with the global scope. The two options offered were CSS modules and CSS-in-JS. I didn't like either approaches having hashes in the classname when opening the website in devtools, and both seemed too locked into React/JSX. Tailwind 1. doesn't have component framework lock-in 2. doesn't make me think of css classnames 3. atomic classnames are readable in dev tools 4. provides default colors and box shadows, etc. In addition, they're starting to make a render-less component library (https://headlessui.dev/ https://headlessui.dev/): that means you can customize how components look without having to understand how its javascript internals work, which I'd find a huge plus compared to other libraries like ant design or material-ui. - vite + react More beginner friendly than webpack in starting a new project, and faster developer experience: page reloads almost instantly when you're modifying a component.
  • victor9000 6y ago
    I really don't get the appeal of tailwindcss, and I feel like I must be missing some obvious benefit of using it vs something like bootstrap. But at first glance, it just looks like the framework recreates css rules with class names. What epiphany am I missing here?
    • iovrthoughtthis 6y ago
      it removes the separation between your structure and your styles so you can style as you go. this sounds wrong because “separate responsibilities!” but in reality structure and style are so interconnected, for html and css, that you’re often changing one with respect to another so why not colocate the info. also, managing a large css stylesheet is often terrible and it becomes write only as a result. it is easier to add new styles that override than attempt to find out which styles impact your target elements and change then. this is again due to the way that structure and style are intimately linked for html and css. its better than writing raw styles on the html because that is rather obtuse, tailwind shortens many of the common style attribute names. e.g background-color: #efefef becomes bg-gray-50. this links into then named color palette that tailwind gives you. also, *everything* is configurable.
• brundolf 6y ago
  Not sure if this counts, but for simple stuff (both front and back-end!) I've been loving regular JS template strings for rendering HTML. Your render logic ends up looking very similar to React functional components, and you can get editor extensions that do syntax highlighting inside the string. There are obvious downsides - on the back-end it's slower than a proper templating system, and on the front-end you're rebuilding the DOM tree from scratch each time, with all the limitations that includes (performance, animations get interrupted, HTML state gets lost, any event listeners have to be re-initialized). But for simple stuff, I cannot recommend it enough. Here's a back-end example from my personal website: https://github.com/brundonsmith/website/blob/master/src/render/index.html.js https://github.com/brundonsmith/website/blob/master/src/rend... And here's a front-end example: https://github.com/brundonsmith/blogs/blob/master/docs/site.js https://github.com/brundonsmith/blogs/blob/master/docs/site....
  • atis 6y ago
    You may be interested in doing js template strings with preact/react - no build tools required! Btw there's vscode support for this so you get syntax hilight too https://github.com/developit/htm https://github.com/developit/htm
    • brundolf 6y ago
      Avoiding transpilation is nice, but so is avoiding a library altogether. I take this approach when I just want to get going with zero setup and zero overhead; if I'm going to the trouble to set up React then I'll want bundling, and at that point I'll probably just go ahead and configure JSX and TypeScript.
• _greim_ 6y ago
  I've been using the Vacancy Observer pattern to do data-fetching in my React app for a few years now. https://gist.github.com/greim/3de3bcb71a672e11c75e371b7b81f4bb https://gist.github.com/greim/3de3bcb71a672e11c75e371b7b81f4...
• sillysaurusx 6y ago
  I still use Arc to write most of my websites, e.g. our TPU management system https://www.tensorfork.com/tpus https://www.tensorfork.com/tpus Arc's kind of underrated. It's nice to spin up a form to do arbitrary things without having to hook up any other boilerplate.
• onion2k 6y ago
  react-three-fiber with the new three-stdlib library. It's an approach that enables much smaller WebGL apps through tree-shaking, and the dev experience is really good (Typescript, fast refresh, no bundling step, etc).
• markdown 6y ago
  .
  • dmingod666 6y ago
    Whatever it is, genuinely hope things better for you.
• gmassman 6y ago
  I'm using a combination of Elixir, Hugo, a bit of Python and GitHub Pages for a personal site that hosts my poetry. I set up a simple hourly job in elixir to check Evernote for any new poems I've tagged with poetry:publish. If a new poem is detected, the elixir job downloads the text, runs it through a Python script to add it to the Hugo repo, regenerates the static html and pushes the updates to GitHub. Overall I'm a huge fan of Elixir, it's incredibly reliable and easy to pick up for simple server tasks. Plus the scheduler is built into Beam, no need for any extra deps. My only complaint is needing to rely on extra python to convert the ENML to HTML, but that's a very niche library so not surprising that it doesn't exist in Elixir yet.
• alphabet9000 6y ago
  i wrote an html generator called jibber [0] that works over IRC. the input syntax is similar to markdown; it was written in mircscript and i've been using it for about 5 years for my own websites. [0] http://jollo.org/LNT/doc/jibber http://jollo.org/LNT/doc/jibber
• hendry 6y ago
  Go + VueJS are serving me great. Deployed on AWS Lambda. E.g. https://github.com/kaihendry/goserverless.sg https://github.com/kaihendry/goserverless.sg
  • calltrak 6y ago
    that's my static too. I used it for https://picc.io https://picc.io image file sharing :)
• sriku 6y ago
  A shameless plug - but I'm attempting to build a kind of "deploy first and develop as you go" kind of system for this, inspired by the Smalltalk IDE and VM. Link - https://github.com/imaginea/inai https://github.com/imaginea/inai Associated post - https://labs.imaginea.com/inai-rest-in-the-small/ https://labs.imaginea.com/inai-rest-in-the-small/
• catchmeifyoucan 6y ago
  https://shuffle.dev https://shuffle.dev - drag drop and export as html. Nice for landing pages
• tomjuggler 6y ago
  Have you heard of tabulator? tabulator.info/ - I honestly don't know how my spreadsheet based project would have been possible without this amazing library (and Flask with Jinja) On the personal side I always love using Processing (p5js.org) for interactive canvas visualisations. I recently found out that this can be used with react, so that's the basis for my next learning project.
• zubairq 6y ago
  I'm using a tool I built myself for simple internal apps: https://github.com/yazz/visualjavascript https://github.com/yazz/visualjavascript
• vbsteven 6y ago
  I’ve been playing around with code sharing options between web, mobile and desktop platforms. The idea is that the app core is written once in Rust and bindings are automatically generated to all target platforms. I have a project that starts with protobuf files and generates Rust for the shared core, and Dart (ffi) and JS (wasm) for the client stubs. The generated client interface is “platform-native-async” so Dart Futures or JS Promises. The bridge passes protobuf messages back and forth between both language contexts and takes care of the threading/async mapping.
• jjcm 6y ago
  [Warning: Not Safe For Prod] Pug and Stylus for html / css preprocessors, especially if you're new to coding. I used to teach a lot of web dev classes to non web devs (mainly designers looking to upskill). One of the worst parts of html/css (or code in general), particularly when you're experimenting, is the strictness. Pug and Stylus are great preprocessors for experimenting and rapid iteration, particularly because they don't care. Pug doesn't care if you change between its syntax and html. Stylus doesn't care if you missed a ;, or a : in your style declaration. They are forgiving languages, essentially the antithesis of something like Typescript. Absolutely excellent when you're trying to wrap your brain around something. I highly recommend them.
• dorianmariefr 6y ago
  For my app I use React Native with a webview, I can't imagine doing native now and having to release for every change.
  • willemlabu 6y ago
    https://expo.io https://expo.io does things in a similar vein.
• hnarayanan 6y ago
  Nothing I use is novel. :) I create a static site (happens to be with Hugo) and rsync it to a tiny running Nginx.
• h3rald 6y ago
  For my personal projects I find particularly satisfying using my own stack: - https://h3rald.com/litestore https://h3rald.com/litestore if I need a RESTful searchable data store and some relatively simple middleware logic. - https://h3.js.org https://h3.js.org if I need to write a single-page application and I just want to get things done fast. - https://hastysite.h3rald.com https://hastysite.h3rald.com if I need a static site generator. - https://min-lang.org https://min-lang.org for more complex things. It took a bit to get used to it, but I managed to get quite productive with it in the end. I do occasionally try out more traditional things or the latest stuff but... using my own code feels a lot more gratifying. If I needed something different, I found myself building it from scratch exactly like I wanted it.
  • bokchoi 6y ago
    Neat! I was playing around with min a while ago and it was fun.
  • theli0nheart 5y ago
    Now I really want to know which operating system you use.
• voiper1 6y ago
  Svelte and feathersjs. Feathersjs seems to be just the right amount of magic: choose a backend store with a model, and it creates REST CRUD endpoints for you. You can drop down to middleware or ideally use "hooks" that activate before (e.g. permissions) or after (post processing) each CRUD call. A new endpoint is a breeze to set up.
• disqard 6y ago
  I'm migrating a side-project that was served by a Django-based server running on Heroku. Here's the new version (WIP): https://www.blockstudio3.net https://www.blockstudio3.net It's written in Haxe (transpiled to js), runs on a single VPS with all of its data in SQLite, and is cached behind a CDN, making it pretty snappy.
• BrandoElFollito 6y ago
  I am an amateur dev writing things mostly for myself, just a few were worth sharing as open source. I use Quasar (based on Vue) for everything. Yes, it makes it look like I have a hammer and everything looks like a Quasar-Vue nail,but it always works. Everything is enclosed, components, canvas,... SPAs are easy, WPAs are easy, everything is easy. The community could be better but the docs are excellent. I've learned quite a few things about Vue using Quasar, so this is a plus too. As for the back, nothing fancy, usually Python with flask.
  • dschuessler 6y ago
    This is slightly unrelated but I looked up Quasar and their homepage (https://quasar.dev/ https://quasar.dev/) is the first website that literally makes me nauseous just by looking at it. That's a kind of UX problem I didn't even consider to exist a few minutes ago.
    • yarcob 6y ago
      Oh my god that's bad. What a dumpster fire. - nauseating animaton - nervous animated chevron that looks clickable but isn't - scroll down to be greeted by a "youtube face" - feature descriptions written in light grey text on bright blue backround with white specks moving through the text This website really doesn't want you to stay.
      • BrandoElFollito 6y ago
        > This website really doesn't want you to stay yes, I guess it is pushing you to the docs to try out how great it is :) (I agree that the web page could have been better)
    • api 6y ago
      I bet there's maybe a kilobyte of that that has any value.
• cies 6y ago
  Elm + elm-ui[1] (dont worry about CSS so much) + generated Elm client lib from GraphQL schema + Hasura (GraphQL over Postgres) + Postgres => strong type safety from db schema to frontend with SPA-first workflow; possibly add ReactAdmin[2] to the mix if that sort of thing is needed. Rust + Actix + Yew (Rust browser framework compiling to WASM) => also verrrry nice vor SPA-first! Slightly more traditional: Kotlin and jOOQ on the server side. I also tend to let go of the HTML syntax lately, by using templating eDSLs such as in Elm, or in Rust's Maud[3], or in Kotlin's kotlinx.html or HtmlFlow. [1]: https://www.youtube.com/watch?v=Ie-gqwSHQr0 https://www.youtube.com/watch?v=Ie-gqwSHQr0 [2]: https://github.com/hasura/ra-data-hasura https://github.com/hasura/ra-data-hasura [3]: https://maud.lambda.xyz/ https://maud.lambda.xyz/ [4]: https://github.com/Kotlin/kotlinx.html https://github.com/Kotlin/kotlinx.html [5]: https://github.com/xmlet/HtmlFlow https://github.com/xmlet/HtmlFlow
  • cloogshicer 6y ago
    As someone fairly new to elm: How do you mix Elm with something like react-admin? Do you set up an elm SPA and embed the react part as a custom element? Or do you go the other way around, having the main App be JS controlled and only some components be an embedded elm App?
    • cies 6y ago
      No mixing. react-admin serves as a quick standalone admin interface.
      • cloogshicer 6y ago
        I see, thanks for the response.
  • merrvk 6y ago
    Hasura + the React Admin plugin is a godsend, allowed me to focus on the SwiftUI app I was writing and barely have to think about the backend.
• AntiImperialist 6y ago
  Server-side dart
• notamy 6y ago
  For my projects I've built most of the infrastructure stack myself: - https://github.com/queer/singyeong https://github.com/queer/singyeong if I need message queuing / etc - https://github.com/queer/crush https://github.com/queer/crush if I need a basic JSON store or cache or ... - https://github.com/queer/mahou https://github.com/queer/mahou is my WIP to replace container schedulers It's a very satisfying experience to see my own tooling reach this level of maturity ^^
• cygned 6y ago
  If we do green field development, we often end up with a stack like this: - Backend: Java + Spring Boot We went there from node and we did try a lot of other backend stacks (Go, PHP, Clojure, Python, ...). Java has evolved quite nicely recently, APIs and libraries are rock-solid, well documented and battle tested. I plays very will with our DDD approach anyway. Many problems have already been solved for us here. Flyway for migrations, custom session handling mechanism. We do not use an ORM. - Frontend SPA: Svelte Again, we tried most of it, from vanilla JS, over Backbone+Marionette through React, Angular 1 - ?? and Vue. Svelte is a good compromise of an opinionated approach, high flexibility and ease of learning. It scales very well for big applications. Built with webpack. - Frontend styling: Bootstrap Yes, we developed with all of them again, even wrote our own. IBM Carbon is nice, but the svelte implementation has potential for improvements. People tell me everything looks like Bootstrap, but the point is: it's well tested, very well documented, extensible and accessible, has accessibility concerns baked in and can be themed easily. If done well, an app doesn't have to look like Bootstrap. We might pull in Tachyons for utilities if necessary. - Data store: MySQL/MariaDB or Postgres plus Redis You name it, we tried it. Postgres never let us down, we know it very well and its SQL support is a breeze. I personally like MySQL/MariaDB for some technical reasons. We had mixed experience with SQLite and bad experience with SQL Server. Oracle is pretty good, but the pricing is no in our favour. Everything related to caching and session handling goes into Redis. For search and analytics, we might pull in Elasticsearch or InfluxDB. - Configuration Config files or environment vars à la 12 factor app. We use Hashicorp Vault for bigger systems. We are dispassionate, though, what ever the client has decided to suffer through will be supported. Complementary tools and technologies: Docker, docker-compose, Docker Swarm in prod, trying out Dokku at the moment, Keycloak for OAuth, Jenkins for CI/CD, people are trying to convince me to use Github Actions. Deployments are usually done on big machines on an IaaS offering (we run Azure and AWS as well as bare metal), no cluster systems, no micro services. We do not use Kubernetes.
• dna_polymerase 6y ago
  Currently migrating services to OCaml backend (mostly Opium/httaf). For a webapp experimenting with incr_dom (OCaml that is compiled to JS)
• mro_name 6y ago
  for feedback forms on otherwise static websites I use my https://codeberg.org/mro/form2xml https://codeberg.org/mro/form2xml to unpack raw form dumps into better digestable xml. So the processing can happen where the static site generator runs.
• matthewcanty 6y ago
  I recently built a site for publishing photographs I am takin weekly. It’s all in Golang. Using Pulumi to deploy into AWS. CDN, API Gateway, Lambda, S3. I’m planning to add DynamoDB for metadata and the recently released S3 feature which allows for on-the-fly transformations of objects. It’s been a breeze. Absolutely loving it compared to all the static generators and JS-heavy alternatives I’ve built in the past. I also find some pleasure in finding the resulting HTML being neat too.
• reitanqild 6y ago
  Not novel everywhere but certainly on HN it seems: - JavaEE (see Adam Biens talks) - ASP.net core Maybe more HN usual: - Quarkus (program real Java like its PHP with instant reloads)
• 300africans 6y ago
  Backend: Rails API, redis. Sometimes Hasura with keycloak. Frontend: React, material UI and/or bootstrap for styling
• nickjj 6y ago
  If you're interested in hearing about what folks are using I have a podcast focused on this exact topic at: https://runninginproduction.com/podcast/ https://runninginproduction.com/podcast/ There's 75+ episodes with a new guest / app in each one. We talk about what tools folks use to build and deploy their apps, the why, best tips, etc.. At the moment there's 188 distinct tools (languages, web frameworks, various services, etc.). Personally I'm a big fan of Flask and Rails with mostly server rendered templates. Lately I've been combo'ing that with TailwindCSS, Hotwire Turbo and StimulusJS for the front-end.
• jcelerier 6y ago
  Qt's webassembly support
• da39a3ee 6y ago
  For a startup with a friend: Typescript, Vue, Bulma, Buefy, Django, Postgres For a hobby project: Typescript, Vue, Bulma, Buefy, Rocket (Rust), Postgres I’m slightly worried about the bulma/buefy choice as there doesn’t seem to be a very active online community, but they work well so far. I’m hosting on render but I don’t know if I’ll continue to use them if it starts getting serious with real clients. Is there anything like Django in the node.js world? I mean that gives you so much stuff out of the box?
  • rajasimon 6y ago
    I'm using exact same but instead of vue I just use Django templates. I am exploring Django hotwire now.
• rikroots 6y ago
  For my current personal project I'm having a lot of fun playing with client-side Sqlite[1] via WASM. It's great for situations where you have a set of relational data which you want to query and sift and display on the page in various ways, yet you know users won't need to add to, or alter, that data set. [1] - sql.js - https://github.com/sql-js/sql.js/ https://github.com/sql-js/sql.js/
• benja123 6y ago
  For all of my new side projects I am all in on Phoenix live view. I couldn’t be happier, you can write web apps quickly and it is super reliable. It’s probably not the best choice for every project, but for now it lets me do a lot as a solo dev who has maybe 30 minutes to an hour free a day to code side/personal projects. My personal project that has the most use is https://readastorytome.com/ https://readastorytome.com/. Almost all of the problems/bugs I have with it are to do with my implementation of webrtc and pdf.js. Liveview has been the source of very few problems. And tinylivechat.com is a WIP that is also using Phoenix live view but I am debating killing it
  • vivek_raja 6y ago
    Why are you debating killing it? Is it not making any money, or is it too much to maintain?
    • benja123 6y ago
      It’s not making any money or being used yet (wip) and I have not had much time to work on it recently. It’s been a great project to work on though. I have had to think about how I to handle a lot of issues that come with web chat widgets, like how and when you alert your customer they have a new message or how to create an embeddable widget. Another possibility is I will just make it open source.
• kuon 6y ago
  Phoenix live view was a game changer for me. Never been happier for web dev. I use it with tailwindcss.
• realrocker 6y ago
  I have built an app template which uses Go html/template package to render html on the server. The app is enhanced using sprinkles of javascript(stimulusjs, svelte single file components) on the client, wherever needed. 1. template: https://github.com/adnaan/gomodest-template https://github.com/adnaan/gomodest-template 2. template demo: https://gomodest-template.fly.dev/ https://gomodest-template.fly.dev/ 3. SAAS starter kit using the template(wip): https://github.com/adnaan/gomodest-starter https://github.com/adnaan/gomodest-starter 4. SAAS starter demo: https://gomodest.xyz/ https://gomodest.xyz/ [edit: formatting]
• tdfirth 6y ago
  I'm currently working on a PaaS product called fold.sh (very early days). One thing I'm using that I've seen crop up on this thread is tailwindcss... I've not used it before but I'm really enjoying it so far. It's not a panacea by any means - it makes no attempt to help you organise your CSS or make it modular so you need to 'bring your own discipline'. For example, it's fairly easy to end up with inconsistent design because it makes it so easy to just add a few custom tweaks here and there. That same feature also makes it easy to duplicate information. That said, for the first time I feel like I can actually iterate quickly on CSS and design in general. That probably says more about me than CSS but I'm having a blast. The fixed set of choices and short/consistent class names mean that I spend less time reading docs and more time iterating, which is great in my book. Maybe it's an approach that doesn't scale well to teams? Maybe I'll regret it later? Can't comment on that yet but it has certainly given me a step change in CSS productivity. The rest of the tech I'm using is all pretty dull, with one exception, which is that I'm using the platform to host itself (the backend at least). Hopefully this doesn't count as too much of a shameless plug but it certainly fits the bill of a 'different approach' as I'm the only user right now!! The (very basic) landing page is here: https://fold.sh/ https://fold.sh/
  • alpaca128 6y ago
    > That probably says more about me than CSS but I'm having a blast. No, that probably is just how CSS is - a pile of decisions based on obsolete or incorrect assumptions that cannot be allowed to change due to backward compatibility. To me Tailwind is just a wrapper that's more reasonable for modern webdesign. Just like TypeScript doesn't change how you're still running JS but it's more pleasant to work with.
    • tdfirth 6y ago
      Interesting analogy to TS (which I'm also a fan of). I hadn't really thought about it like that but I think there is truth to it. As you say, the fact is that we've got all of these standards that can't be be changed without breaking the web. Those standards were also first created for a different time, so it's not surprising that some assumptions turned out to be poor. As a result, we've ended up in a place where tools treat those standards as compilation targets. This isn't a bad thing per se but it does lead to a lot of complexity in the tool chain. I think part of why I like tailwind is that it almost feels like I'm using plain old CSS. I get the same amount of flexibility (as much as I need anyway), but I don't feel like there is some great abstraction in between me and the styles I want the framework to produce. At the same time, it's quicker and easier to use. Anyway, I'm aware it's a pretty divisive tool. I see a lot of strong opinions about it on HN! EDIT: grammar
• BerislavLopac 6y ago
  I wouldn't call it "novel", but I've lately turned to designing APIs first using OpenAPI [0], and then using that specification to drive routing and validation using (shameless plug, but that's what I use) pyotr [1]. [0] https://swagger.io/specification/ https://swagger.io/specification/ [1] https://pyotr.readthedocs.io https://pyotr.readthedocs.io
• deleted 6y ago
  [deleted]
• jujodi 6y ago
  I'm currently using Obsidian Publish to build and publish the knowledge base website underlying the information I send people in my newsletter, which is something I've always wanted to do and never had the time to build. I like that it's similar to GitHub pages in that it's just a bunch of markdown files, but it comes with a really amazing editor and it's pretty much 0 effort to host and update.
• jtolmar 6y ago
  Some recent projects: - Frontend only, plain javascript, but a lot of it uses a project-specific custom scripting language. This is a game that consists almost entirely of procedurally generated written content, so I write a language that makes it easy to categorize procedural content bits and make sub-calls to new ones. I have a long way to go on language design still, but it's already better than a json blob. - HTML frontend with some small plain javascript. Backend is node/express, but most of the heavy lifting is done by a shell call to Coil Snake[1], and which inserts a ton of code in ccscript and 65816 assembly. This is a randomizer for Earthbound (http://pkscramble.com/ http://pkscramble.com/), so those are super specialized tools for that purpose. But I really like the Coil Snake ecosystem, and it's definitely going to influence my projects going forward (the decision to use a custom scripting language above was influenced by ccscript). - Plain javascript frontend, vertx backend, postgres database. This is my goto for serious projects. It's fairly boring. [1]https://github.com/pk-hack/CoilSnake https://github.com/pk-hack/CoilSnake
• danjac 6y ago
  Django, Hotwire/Turbo+Stimulus, Tailwind, Postgres. The codebase is small, easy to reason about, and maintainable, it's easy to build an accessible site on top of semantic HTML, and it's fast and responsive enough for my needs. It's nice to use JS for things it's best suited for rather than being responsible for running the whole application. Tailwind has its detractors but honestly I've found (as a decidedly non-frontend person) that it's very productive for building out a responsive design with good support for dark theming.
• leipert 6y ago
  Just finished working on the first iteration of a website for my mom. I didn’t want to deal with a full classical CMS and maintain Databases and such, especially as my experience with wordpress, PHP and typo3 has faded a little bit. My mom’s website is basically a directory of old mansions in former eastern Prussia. Site is in German: https://gutshaeuser-ostpreussen.de https://gutshaeuser-ostpreussen.de Anyhow Stack chosen: Backend/CMS as a Service: https://prismic.io/ https://prismic.io/ which is really great because it has an easy user interface that supports drafts, media, i18n (planning a polish version of the website) and defining custom types for pages which is great to force my mom to enter data consistently. At first I used their SDK to simply query the data and rendered the Page while writing my own static site generator. Obviously very tedious. Since then I have moved away from that and landed on Nuxt which works well for me, because it allows me to iterate faster. Nuxt also supports rendering static pages https://nuxtjs.org/blog/going-full-static/ https://nuxtjs.org/blog/going-full-static/. All of the JavaScript bits are basically progressive enhancements. The page is then deployed via GitLab pages. Every time my mom changes a page, a webhook triggers a build of the Site. What really eases my mind is the ability to simply backup all the data entered, as simple JSON files. So I don’t feel like there is any big vendor lock in with Prismic.
  • pengwing 6y ago
    Regarding Prismic lockin: Have you checked whether the exported .zip contains the entire media library? Regarding SEO: If you (i) host the Cormorant Garamond font locally and inline its CSS, and (ii) use srcset to serve a smaller hero picture on mobile, you will probably achieve a 100/100 score in lighthouse.
    • leipert 6y ago
      Didn’t think someone actually looks at the page. Thank you! Currently I am just saving away the page contents as a JSON when rendering the page. My mom has all media locally. TBH, I considered just crawling all the pages and media via the API/SDK with a scheduled job in CI. Maybe saving them in a git repo to get history for free or just uploading a zip every week to backblaze. Thanks for the SEO tips. Will definitely look into hosting smaller images and the font, also need to add meta tags for descriptions, maybe some JSON LD and other shenanigans for Facebook, Twitter, etc. Had to focus on the mom-visible stuff first ;) Also wanted to look into analytics with something privacy friendly like https://umami.is/ https://umami.is/
• secran 6y ago
  Some languages written in c/q/j, pure css/js, is often only a few hundred lines of a project, I do not use a database, or rarely encounter the need for a database, sqlite/kdb is very easy. You can try my website, https://flashlo.com https://flashlo.com. The back-end code is probably no more than a hundred lines, and the front end is a single page. I don't like vdom. They cover up a lot of details about how things run.
  • secran 6y ago
    In addition, I still don't understand the benefits of this thing for serverless. Most of my personal projects actually don't have the problem of splitting resources and don't have the opportunity to use something from serverless. I use a lot of docker in my development process because it makes it very easy for me to deploy. A project, a very small proportion of memory, fast speed, less than 100 lines of code, this is where I feel the most comfortable.
  • secran 6y ago
    The proportion of mysql is actually very high, maybe a few hundred megabytes of memory, if we use files, etc., in fact, the proportion of memory will not exceed a few meters. I prefer tools that are fast, consume less resources, develop fewer lines of code, and are not overpackaged. Many tools completely cover up the details, causing you to learn exactly the concepts created by these tools. I hate this kind of thing very much now, and of course, if teamwork is needed, it may still be useful.
• hypertele-Xii 6y ago
  I worked as a full-stack developer up until 7 years ago. Evaluating different options for my new website, I ended up just using what I'm familiar with: raw, vanilla PHP, HTML, CSS, and JS. Eliminates the need for any faff like server management on my part; PHP-enabled hosting is cheap and easy. No frameworks, just PHP. Not that novel, I know. There's a stark difference in research and production in terms of output, for me. If I wanna get stuff done I have to think less in terms of the newest, coolest thing and just use the right tool for the job. Edit: Wrote some details on the design and implementation [1] [1] https://hypertele.fi/ec997be8c5933e87 https://hypertele.fi/ec997be8c5933e87
  • spiderfarmer 6y ago
    I only made small changes to my workflow over the last 10 years. My productivity is way above average.
  • donatj 6y ago
    We’ve got a similar setup. To add to what you said, PHP scales horizontally remarkably well because there’s naturally no cross-request state, so when you hit a certain point you can just throw another identical server into the mix. We run autoscaled ec2 instances behind an AWS load balancer and Aurora but manage to keep a pretty simple PHP app serving millions of students a day. For some of the more CPU intensive work we have a couple Go micro-services in the mix. Go is well worth anyone’s time to learn imho, it’s a very nice mix of powerful and easy to learn. TypeScript in strict mode also keeps your JavaScript honest which I appreciate.
  • jitendrac 6y ago
    Same preferences, I learn what is new (at least 2-3 year old) but stick to vanilla PHP, JS and HTML. though I prefer learning a new programming language every year.
  • paul_f 6y ago
    I'm not trying to impress anyone, I just want to solve business problems quickly, get paid, and go golf. I firmly believe that high productivity can be achieved by using boring technology. https://expatsoftware.com/articles/happiness-is-a-boring-stack.html https://expatsoftware.com/articles/happiness-is-a-boring-sta...
• BilalBudhani 6y ago
  I have been enjoying building apps with https://hotwire.dev https://hotwire.dev (server-side rendered with JS sprinkled on top) after using React/Vue heavily in the past. I'm amazed at how simpler & productive it has become to build apps without getting lost in the whole JS tool ecosystem.
• jrwr 6y ago
  I wanted something novel for my "website" so I used a few websocket tunnels, xterm.js and User Mode Linux to make a rather quick booting Curses Dialog menu as my main website [1]. It was a fun challenge to secure it and make sure it doesn't get overloaded, as its on a cheap 30$/yr VPS. since UML doesn't need any CPU extensions, it just about works anywhere. You can read a little but more about how I built it under the "UML" menu [1]. [1] https://jrwr.io https://jrwr.io
  • jrwr 6y ago
    Well now I know a few more failure cases when too many kernels try to boot at once, and a few other failures, (UML Switch has a bug! some kind of strange socket limit)
• debarshri 6y ago
  I have been building react frontend and golang backend (go-gin to be specific) recently. However, post compilation of react app, I use go-bindata to convert it into a golang embeddable asset and service it via specific route in go-gin, For instance (/#/ or /) is there frontend is located and (/api) is there the api endpoints are located. In this way, you can actually distribute the app with just one binary. Downside is that it is a complicated workflow and takes quite sometime to compile.
• jillesvangurp 6y ago
  Kotlin & Fritz2. I had to make some difficult decisions with the startup I'm a CTO of last year. I had a pretty junior team that knew Android, Kotlin, and a bit of server side Kotlin. Then for various reasons we decided to do web, Android, and IOS. So, web based development was a foregone conclusion as we did not have the bandwidth to ramp up separate teams. I did not have the resources to grow the team. And I did not want people to get side tracked learning a lot of new things. Normally, I would have gone down the typescript + react route. I'm a backend developer but I've done some frontend projects with it before. But I was the only one on the team with relevant skills here. So, instead I salvaged what I had which was lot of Kotlin know how in the team, a Kotlin multiplatform library that we built for Android already (api and model classes), and a Kotlin backend. So, I took a calculated risk of picking Kotlin-js as the main way to do our frontend. I stumbled across a new framework called Fritz2 last year, which is written in Kotlin. I liked what I saw. We did a few spikes end of last year to check if it could do the job and worked as advertised (yes). Then we built a new web app with it in a very short time. I would normally not recommend people take that much risk but in our case it was defensible and it worked out great. In retrospect, we've been very fortunate as this is simply a very well designed framework. At this point we are very productive with it and have a feature complete app that we are putting in the hands of customers. Two months is not a lot of time to pull that off and I'm lucky with both the team and the technology we picked. What do I like about this: - It's just another Kotlin project. That means great tools, great language, and it happens to compile to javascript and run in a browser. We refactor at will, use nice Kotlin DSLs, have autocomplete for just about anything. - Fritz2 is written by a small group of developers that know a lot about frontend development. So you get decent component technology (loosely inspired by react), everything is reactive by default (because Kotlin has great support for that), and they also integrated solutions for things like styled components, using and creating web components. So in short, it's a very modern feeling framework that should feel right if you are expecting clean code, components, and sane architecture. - The Kotlin tooling for javascript is pretty great. It comes with lots of ways to integrate with the javascript world. E.g. we integrated leaflet and that was pretty straightforward: add the npm, adapt a few of the typescript mappings. Dukat which is the kotlin type mapping generator that does this automatically nearly worked but ended up generating a few problematic areas. So, I expect this to get better. But manually writing some mappings is not that hard. - Kotlin StateFlows are a great way to represent state. Basically, components subscribe to state flows and respond to any changes you put there. This is a core concept that Fritz2 pushes hard with a concept of stores that store data classes and sub stores that you can derive from that for individual fields. It basically makes you do the right things with your state and you get very type safe and easy separation of rendering code and state management. If you come from Android, that's pretty much how things work there as well these days. Also, it's similar in newer frameworks like Swift UI and Jetpack Compose. - Fritz2 uses kapt, which a compile time annotation processor, to generate code from model classes to make it easy to subscribe to changes in web components. That gets rid of a lot of boiler plate. - It uses webpack underneath, which gives us a lot of flexibility for how we build our software. We also use cordova to produce native wrappers. With some plugins even. - We use koin for dependency injection. And it's just as important of a design pattern in frontend as it is in backend code. Koin is what we used on Android and it's a great fit for Fritz2 as well. Nice testable code and we don't have a lot of Baron from Muenchhausen style self initializing code (like every messy js project I've ever seen). Things I don't like that are long term fixable: - The kotlin-js tooling still has some rough edges. It got a lot better with Kotlin 1.4. though. But undeniably, you will have to do some problem solving when dealing with this. Despite this, we pretty much hit the ground running with this and have not lost a lot of time over this. - Source maps particularly seem flaky. So, debugging in a browser is a bit meh in a browser. If that matters to you, it's a problem for now. I expect this to get fixed as they improve the new IR compiler for kotlin-js. - Performance of the build tooling and compiler is not great. In fairness, it's not a whole lot worse than the typical webstacks out there. It actually uses webpack underneath. But it's definitely not very fast. They do have incremental compilation and usually changes load in the browser after a few seconds. So, that keeps productivity high. - There are not a lot of people doing this yet. So, you need to get creative solving issues. That includes reaching out to developers on the Kotlin slack, digging through OSS code to see how stuff works, etc. The community is very supportive. But if you hit a problem, Stackoverflow does not have all the answers just yet.
• tersers 6y ago
  This is the first thread in a long while that's given me a lot of FOMO anxiety. I've made a lot of one-off server-side rendered apps in Flask, and right now I'm doing some backend work ASP.NET Core for my job, but I have this overwhelming feeling there's so much I don't know and I'm not sure where to start. I only bring this up in case I'm not the only person sharing these feelings.
  • adriand 6y ago
    Honestly I don’t think you should worry about it. Once you know how to program, you know how to program - the fundamentals don’t change very quickly. Anything you don’t know now you can learn when you need it. The most important thing to retain is your love of learning and excitement about new technology, so that when the time comes for whatever is next you rise to the challenge with enthusiasm.
  • jstummbillig 6y ago
    Try this for size: Are you feeling effective at what you currently do? Is there any tangible reason why that would change for the worse in the upcoming year? If not, you are doing fine. There is absolutely nothing out there that obviously and significantly increases your output by dropping whatever tooling you are effective with already and switching as of this time. I have looked. It's sobering.
  • nickelcitymario 6y ago
    It's not a feeling, it's an observation. Technology is like a tree, branching infinitely in all directions. When I was a baby web developer, just knowing CSS on top of HTML was considered advanced. (This was back when the bleeding edge was using tables for layouts.) Today, I can't keep up with all the different ways there are to do something as simple as loading a web page. This splintering is true in every area of tech. At first it freaked me out, but I've accepted two things: 1) The only option is pick a path and specialize in it, knowing there will always be things I won't know. There's nothing wrong with learning new ways, of course. And often that's necessary. But I've given up on trying to master all of them. 2) Just because something is new and popular doesn't make it right. The proliferation of frameworks for otherwise simple things (like loading mostly static web pages) is one such example.
• bullen 6y ago
  I made my own app. server with built in distributed JSON database that can hot-deploy directly from your PC to a cluster of servers async. = instantaneously. This means I have 1 second turnaround from idea implemented to testable on a copy of live. Other than that I am still on manual HTML, CSS and vanilla .js! JavaSE for server and javascript for client. HTTP Comet-stream over XHR/Fetch for real-time. Single serving database salt SHA256 for security.
• allanmacgregor 6y ago
  I switched to Elixir/Phoenix + LiveView for my stack. - Content all markdown - Tailwindcss for styling - Phoenix provides a extremely fast framework - No database at the moment - CI/CD with github actions - Automated deployments with Gigalixir I switched to gatsby and I notice that I was spending more time fighting the system than writing. You can check it out here: https://allanmacgregor.com/posts https://allanmacgregor.com/posts and the code is available here: https://github.com/amacgregor/amgr_phx https://github.com/amacgregor/amgr_phx
  • rapnie 6y ago
    Considering using tailwind too. Only thing is, it doesn't work so well for the generated markdown html output you don't control, esp. when using many plugins to markdown parser (Mermaid, PlantUML, etc.).
    • mewfree 6y ago
      You should check this out: https://github.com/tailwindlabs/tailwindcss-typography https://github.com/tailwindlabs/tailwindcss-typography
• EamonnMR 6y ago
  Python + Fast API. It's the minimal web framework I always dreamed of.
  • jamil7 6y ago
    Loving FastAPI + Postgres for the (small) amount of backend work I do at the moment.
  • zxcq544 6y ago
    you should take a look at sanic https://github.com/sanic-org/sanic https://github.com/sanic-org/sanic It's very popular among people writing async web services in python. It's like 10% faster than fast api.
• iudqnolq 6y ago
  I'm a college student trying to get into software development. I was recently hired to build a dashboard around some data stuck in an archaic platform. I went with Phoenix and Elixir, and I really liked the combination of a focus on development enjoyment (inspired by Ruby on Rails) combined with an anti-magic attitude, so you can trace through what actually executes pretty easily. I haven't had much other experience though, so that that with a large grain of salt. My client was very happy with the speed of development and quality of the final product, so I consider it a successful choice by the main metric that matters here. Edit: The main pain point has been deployment. I spent an afternoon on some shell scripts that scp to a virtual server that mostly work fine, but I don't understand sysadmining very well and I I'm pretty sure they'll blow up on me at some point. It would be really nice if there was a tool that took care of the actual servers part for me.
  • itake 6y ago
    My main issue with Elixir (and maybe this has changed in the last 3 years since I looked at it), is that there isn't a strong open source package libraries available like you see in Rails. People complained that you end up writing boiler plate code for things that in Node or Ruby would just be a package. I've heard great things about the language and framework though.
    • iudqnolq 6y ago
      I haven't run into many issues where I wished there was a package, but I haven't programmed a web app in a language that had a lot of packages available. The main close call I had on this project was that there was only one package that supports generating excel spreadsheets, and it's a labor of love by one person. This wasn't a huge issue for me, I had a plan to write csv and then convert if it didn't work, as I didn't need formatting/fancy output. It turned out to work great, so that wasn't necessary. There was an excellent transactional email library that hooked into the standard templating system, and a few so-so approaches to authentication. I ended up rolling my own on top of a decent crypto library. For the non-web-speicfic bits I haven't found this to be an issue, Erlang has a whole kitchen sink with OTP (even if like a real kitchen sink it's a bit grungy if you look inside), and I've found plenty of algorithm/data structure-y packages.
• js4ever 6y ago
  I use Cloudbackend [1] to create my projects serverless sql database and APIs with the API builder, it's generating the node.js code and publish it to aws lambda. For the frontend I use either Vanilla js (no framework) or Vue.js [1] https://cloudbackend.appdrag.com/ https://cloudbackend.appdrag.com/
• swilliamsio 6y ago
  For my personal website/blog, I use the beautifully simple static site generator makesite.py.[1] For the other sites I've made, I've used WordPress or plain old no fuss static html/js/css. [1] https://github.com/sunainapai/makesite https://github.com/sunainapai/makesite
• privong 6y ago
  I am planning a small compute job tracking/notification service. Initially it will be for my own personal use, but may eventually be offered publicly. I plan to write the server in Racket (likely leaning heavily on [0]) and have it interface with a sqlite database. Since the load will be quite low, I'll put it on a small VPS. I've enjoyed using Racket for some small projects and am interested in scaling up my abilities to use it in a larger project. Based on my reading the first half of [0], it seems like something that's achievable give my other constraints (real job, etc.). [0] https://serverracket.com/ https://serverracket.com/
• snorremd 6y ago
  My blog/homepage is built using: - Gatsby.js static site generator framework - Posts written as md or mdx (markdown with jsx support) - Github Actions to build the site - Published to and served by Cloudflare workers - Uses [sci](https://github.com/borkdude/sci https://github.com/borkdude/sci) and ClojureScript to add a live Clojure REPL component that can be used in blog posts - Tailwindcss is used for styling via emotion css-in-js and a tailwind plugin. The setup mostly works ok, but as always with the JavaScript community the amount of breaking changes can be a bit taxing. Because Gatsby handles static site generation the blog works without JavaScript enabled for those that only want to access the static content.
• raitucarp 6y ago
  - Next.js (react) - Chakra-UI (for ui + ux) - Hasura (graphql + postgresql) - Express.js (for custom actions, event hooks etc) - Kafka for message brokers Previously, I was fullstack javascript developer using raw html with only express js and its renderer. Later I discovered ui and ux, react with dsl also graphql as data layer overwhelmed me. So I found simple stack for faster shipping. Learning curve is not that difficult I think.
  • lghh 6y ago
    Been using Next.js and Chakra. Big fan of Chakra, it's the best UI library I've used hands down.
• sandreas 6y ago
  hugo[1] for static websites, that need SEO SVELTE[2], routify[3] and Orbit.js[4] for SPA Frontend with API requirements API Platform[5] or JsonApiDotNetCore[6] for Backend SignalR[7] when realtime is required [1] https://gohugo.io/ https://gohugo.io/ [2] https://svelte.dev/ https://svelte.dev/ [3] https://routify.dev/ https://routify.dev/ [4] https://orbitjs.com/ https://orbitjs.com/ [5] https://api-platform.com/ https://api-platform.com/ [6] https://www.jsonapi.net/ https://www.jsonapi.net/ [7] https://dotnet.microsoft.com/apps/aspnet/signalr https://dotnet.microsoft.com/apps/aspnet/signalr
• ghego1 6y ago
  For non-app websites, so in other words for "static websites", I have worked in the last 15 years with many technologies. First j was in love with server side rendering. Mostly it was PHP in many flavors. For projects I had full control over I even built custo frameworks. Then I tried server side rendering in nodejs with frameworks such as react-server. I must say that the overheads were not worth in my experience. I also tried client side rendering with js frameworks such as angular (v. >= 2) and react, but to be fully honest that was a not idea solution for "static websites". Lately I've combined all these experiences and I've built my own static web site builder, YASSB (https://yassb-foss.github.io/ https://yassb-foss.github.io/). I've built it combining what felt tome like the best features of all the above. In short: - websites are pre-rendered and served as static websites - pages are composed with reusable components, these can be simple HTML components or can be rendered with js.
• droptablemain 6y ago
  Right now I'm really enjoying building this way: 1) React/Next.js front-end app 2) Lumen (PHP) for the API Maybe not novel per se, but highly performant and effective.
• tschuehly 6y ago
  I'm doing Fullstack with Angular + Spring Boot Kotlin. I love writing the backend but the frontend part really seems overly complex. In the end I'm just mirroring my data from the backend on the frontend, having to maintain two models, mapping the json to an object and then inputing that data into another component where it gets displayed. For example I tried to create a generic edit component but without reflexion it was a huge pain in the butt: https://github.com/tschuehly/DataRecovery/blob/f4003ddebbba7ef45a48fef3860e3978250277c2/datarecovery-frontend/src/app/containers/object-edit/object-edit.component.ts https://github.com/tschuehly/DataRecovery/blob/f4003ddebbba7... I would love to just have an html structure and then just having a template for a component filling it in the backend and sending it to the frontend.
• _fat_santa 6y ago
  I'm from the "new camp", my career started with a React JS gig and I've been in that space ever since. My typical stack is React frontend + Severless backend + FaunaDB if I need a DB. Everything is deployed via Netlify (well except the DB) and I use their functions to emulate a traditional backend.
• gwbas1c 6y ago
  Server-side rendering engine for Node.js: Pogon.html https://github.com/GWBasic/pogon.html https://github.com/GWBasic/pogon.html About a year ago I decided to learn Node.js by writing a personal blog engine. I wanted a rich, template-based server-side rendering engine that would share things like headers and footers among different pages. Mustache and Handlebars (templating systems for Javascript) are awesome, but they don't have the rich kind of HTML-aware templating that I was looking for.
• davidwparker 6y ago
  I'm using SvelteJS[1] (specifically, Sapper[2]) on my product ListenAddict[3]. On other products I'm using SvelteKit[4], which is the spiritual successor to Sapper, but it's _very much_ in beta, and I wouldn't quite recommend it for production yet (even though it is being used in production for the NY Times). I've found Svelte to be amazing to work in, especially compared to React/Vue/Angular. The compiler is great, and the final size in production is fantastic. It's also super easy to do things that I previously found annoying/hard/long-winded to do in React. [1] https://svelte.dev/ https://svelte.dev/ [2] https://sapper.svelte.dev/ https://sapper.svelte.dev/ [3] https://www.listenaddict.com/ https://www.listenaddict.com/ [4] https://kit.svelte.dev/ https://kit.svelte.dev/
• mpweiher 6y ago
  For the Objective-S site, http://objective.st http://objective.st, I obviously had to create something in Objective-S. And because one of the goals of Objective-S is to blur the hard lines between Unix-style command-line programming, Smalltalk-like integrated development and macOS-like apps, I also wanted to to create something to blend these elements. The site is served by an Objective-S program that hooks an Objective-C wrapper for libµhttpd up to a bunch of storage-combinators that define the web-site. The Objective-S program is created in an interactive app called SiteBuilder, which includes Smalltalk-style browsers for the classes the define the program + the resources (some markdown + images). The app has an integrated live-preview that reloads interactively, as-you-type. That preview is served via a special URL handler that keeps everything within the app (no http). In addition it also serves the site on an HTTP port. The code + resources for the site are stored together in a macOS bundle, so a directory wrapper with the files inside. In fact, this data format is a version of a generic "Smalltalk bundle" that is used by a bunch of different live-editing applications. To deploy, the wrapper is rsync'ed over to a DO droplet (smallest instance they have) running Linux + GNUstep. This setup has held up to a HN hug-of-death without breaking a sweat, so it's reasonably light-weight and robust. Other sites are maintained using the same SiteBuilder program, but first exported to a static site.
• jimnotgym 6y ago
  Novel... for Hacker News Wix and Squarespace with Shopify for ecommerce. Every time I get asked for yet another marketing site at work I make people prove these would not work for them first. 10 bucks a month
• sbazerque 6y ago
  It is somewhat whacky, but what I'm doing is: I created a library to have distributed data types directly on the browser [1]. So there are no servers, data is sync'd directly between people's browsers. Then I created a library to bind react components directly to my distributed data types [2]. So the app is just a static page, hosted anywhere, that works as an SPA. [1] https://github.com/hyperhyperspace/hyperhyperspace-core https://github.com/hyperhyperspace/hyperhyperspace-core [2] https://github.com/hyperhyperspace/hyperhyperspace-react https://github.com/hyperhyperspace/hyperhyperspace-react
  • MH15 6y ago
    This is very interesting. I've seen similar peer to peer work with the DAT browser but this looks like it works in existing browsers. I'll definitely be checking it out.
• simonw 6y ago
  I've been using my Datasette tool, originally intended for exploring databases, to build full-blown websites and it's working surprisingly well. It supports Jinja templates and runs on SQLite databases so it's actually a good fit for semi-static sites. Here's what Datasette looks like by default: - https://latest.datasette.io https://latest.datasette.io And here are three websites that are actually just Datasette with some custom templates and plugins: - https://datasette.io https://datasette.io (data: https://datasette.io/content https://datasette.io/content code: https://github.com/simonw/datasette.io https://github.com/simonw/datasette.io ) - https://til.simonwillison.net https://til.simonwillison.net (data: https://til.simonwillison.net/tils https://til.simonwillison.net/tils code: https://github.com/simonw/til https://github.com/simonw/til ) - https://www.niche-museums.com https://www.niche-museums.com (data: https://www.niche-museums.com/browse https://www.niche-museums.com/browse code: https://github.com/simonw/museums https://github.com/simonw/museums ) They're all hosted on either Vercel or Google Cloud Run at the cost of no more than a few dollars a month.
• lawwantsin17 6y ago
  Text.
• beatcracker 6y ago
  I've built a tiny pet project [0] that uses JSON Schemas [1] extensively. Data is defined by the schema and it's used to build a static JSON API on GitHub Pages. OpenAPI [2] definition for API reuses data schema and you can use OpenAPI Generator [3] to generate clients. The site uses docsify [4] to display repo's README nicely. [0] https://beatcracker.github.io/toptout/ https://beatcracker.github.io/toptout/ [1] https://json-schema.org/ https://json-schema.org/ [2] https://swagger.io/specification/ https://swagger.io/specification/ [3] https://github.com/OpenAPITools/openapi-generator https://github.com/OpenAPITools/openapi-generator [4] https://docsify.js.org/ https://docsify.js.org/
• JCVI-syn10 6y ago
  Sounds like an incredibly slow way to handle a LAMP stack. On your website you mentioned manually writing the routing and other basic functions a framework covers out of the box. From your website: "we transfer control to the first PHP file, the router, and begin by importing my little toolbox I've accumulated over the years." If you wanna "get stuff done" that doesn't sound simple or fast. You don't use any js frameworks? You write CSS by hand and throw out all the benefits of SCSS?! This all applies just to your personal blog. It would not scale. "It's a total hack achieved by careful output buffering, variable scoping, and function overloading" how is "a total hack" simpler than OOTB functions provided by a PHP framework? You're even defending ragged-left aligned-right text. In any country where uses are used to reading left-to-right this is the slowest way to read, this has been studied well before the web existed.
• deleted 6y ago
  [deleted]
• cheeseblubber 6y ago
  Client side: React - Typescript Backend: Phoneix - Elixir We're a live message tool and it is basically what Elixir is built for https://github.com/papercups-io/papercups https://github.com/papercups-io/papercups. The Elixir community has been great and incredibly friendly. I originally was worried about the size of the community but that hasn't been an issue the community has been super helpful. I also think the annual stackoverflow usage surveys are very misleading because most of the community's questions get asked in ElixirForum and not on Stackoverflow. Phoneix is the web framework of Elixir which is very similar to Rails but minus a lot of the magic has been very helpful for our productivity as well. If I had to built another service that is websocket heavy I would definitely use Elixir. Even if it was a standard crud app I would still most likely choose Elixir.
• splatcollision 6y ago
  Chiming in here with my latest "weird but cheap" stack: * Use a Trello board as a free CMS. * Write cloudflare worker code to read cards from the board via Trello APIs and render card content as plain old HTML. I use labels as tags for the categories, and have specific formatting in the card descriptions. If an attachment is a YouTube URL, it renders the video as an embed, otherwise it uses image attachments as post images. Card covers render as the link thumbnails on the list pages. Powers our family YouTube blog: https://thunderiron.family https://thunderiron.family (Check it out if you like fun and delicious Keto recipes) An earlier version of this stack powers my personal dev blog, and the approach is written up here: https://splatcollision.com/page/meta-post https://splatcollision.com/page/meta-post What is particularly cool is that I can post things right from my phone using the Trello apps!
  • cusx 6y ago
    haha brilliant!
  • el_dev_hell 6y ago
    Damn! That's certainly novel. Nice work.
  • caspar 6y ago
    Nicely done! In pre-COVID-19 times, Atlassian used a similar hack for its catered lunch menus: a hand-updated Trello board stored the menu items, along with some data about which items are vegetarian, gluten free, etc (using labels?), and then that spat out a nicely formatted menu at a well known URL / on some TVs. Little bit of ingenuity goes a long way to avoid having to maintain yet another piece of software :)
• isoos 6y ago
  Recently I got into a web app idea, which does not require any search engine indexing (mostly admin-heavy stuff), and I gave Flutter Web a try (note: I was using Dart on the server side for a long while, and occasionally as compiled to JS too). No regrets so far: it is productive and handles complex state really well.
• d--b 6y ago
  I am building a tool to construct internal apps quickly: https://www.jigdev.com https://www.jigdev.com The idea is that developers who know business problems are usually bad at frontend. This is a tool to help them build web apps without much html knowledge.
• offtop5 6y ago
  I used Firebase and Flutter Web for a project. I really think flutter is the future, Dart is what Typescript should of been.
• richardanaya 6y ago
  I'm experimenting with creating web pages in Rust WebAssembly using lit-html. https://github.com/richardanaya/lit-html-rs https://github.com/richardanaya/lit-html-rs
• ChrisRus 6y ago
  Working on a new spin on domain models and software product line engineering, in JavaScript, for data scientists that need to build sophisticated process pipelines, and complex interactive visualization UX --- from data and reusable stuff. The dream is an open and extensible cloud that functions like the software service analogue of the system-on-chip ecosystem that's eating the devices/IoT world.
• yboris 6y ago
  My commercial app: Video Hub App - https://videohubapp.com/en/ https://videohubapp.com/en/ App written with Electron & Angular. Includes a "web app" inside that gets served so you can browse videos on your phone - built in Angular. The public-facing website is built in Gatsby, and served from the cheapest hosting I could find: $3/month - also connected to CloudFlare for free-tier CDN. Made a small webpage for users to download their purchased app too - just 3 pages built with PHP (so fast and easy!) All code is MIT open source: https://github.com/whyboris https://github.com/whyboris
• shubik22 6y ago
  I use a pretty standard Rails stack, but just wanted to give a quick shoutout to Stimulus Reflex[1]. For the web app I'm working on, I wanted to add some real-time functionality (e.g. being able to broadcast updates to all the users on a given page in my application, and have them interact with each other) without having to write a full SPA. I ended up implementing that functionality using Stimulus Reflex and it's been great. Stimulus Reflex uses: 1) Stimulus JS for frontend functionality 2) CableReady, a websocket library built on top of ActionCable 3) morphdom, a clientside DOM diffing library to update your UI I'd recommend anyone who wants to incorporate some more advanced functionality into their Rails app to take a look. (I can't speak to how it stacks up against the new Hotwire/Turbo stack, as I haven't built anything with that.) [1] https://docs.stimulusreflex.com/ https://docs.stimulusreflex.com/
• rufius 6y ago
  I don’t do much on the apps/websites side of things. I’m a platform and systems developer by experience/preference. That said, I’ve long maintained a blog. I prefer to build my own tools. I wrote a highly opinionated static site generator in Go over the course of the few evenings during March. I used to use Ghost to host the blog on DigitalOcean but got tired of chasing NPM updates. I got a small VPS instead, installed OpenBSD, and now the site runs off relayd+httpd. relayd handles setting caching headers. httpd handles serving of HTML. It’s working really nicely. If I didn’t use IBM Plex Sans as a font, my site would easily join the lists like 10kb club. I do set the caching header for it though. Other than that, I’ve got a couple of side projects I’ve been noodling on. Back end will probably be Go. Front end app will likely be PHP/Laravel. PHP 7+ has been really nice to work with and it runs well on OpenBSD. If it ever got popular enough, shifting to elastic deployments with Docker/LXC/Podman would be straightforward.
• margani 6y ago
  At the moment I really enjoy converting my previous information website that was written in C# and ASP.NET into a very simple custom static site generator written in javascript.
• thepra 6y ago
  For my personal project quick.collanon.app I'm going with Blazor WebAssembly and I enjoy not having to write no more js for the frontend
• oedmarap 6y ago
  Bootstrap and Jekyll for all of my personal sites and side projects; with HTMX and/or vanilla JavaScript when needed. Same stack as well for clients who need static sites. For other clients (that need a CMS) it's WordPress.
• b215826 6y ago
  Pandoc and a makefile.
• kenlo 6y ago
  A bit on the edge, but superfast development. Saasform for signups and subs management, Flutter for all the frontends, Darklang for serverless backend functions. 100% tested code and GitHub Actions for ci/cd automation.
• gilfoyle 6y ago
  I have used craftwork design method framework to build startup landing pages and websites. https://craftwork.design/downloads/method-4/ https://craftwork.design/downloads/method-4/ It ships with many layouts, blocks and components in React that you can mix and match for building landing pages. If building a page from scratch isn't in your wheelhouse it's quite useful to get something out quickly.
• the__alchemist 6y ago
  Django with raw SQL queries. HTML using templates, with CSS files for repeated styles (eg defaults for a given element type), and inline styles for one-offs. Modern javascript for targeted interactions like managing shopping carts through local storage, validating forms with visual feedback, and processing payments. Typescript as-required; better language, but adds a build step. Rust is promising for both front and back end, but backend frameworks are too sparse for websites, and frontend leads to large downloads for the client.
• xyzzyrz 6y ago
  Plasmic is a web design tool / visual page builder that works deeply with code, builds web apps as well as websites, and doesn't lock you in (exports anywhere). https://www.plasmic.app https://www.plasmic.app It plugs into React stacks, including SSGs like Gatsby/Next.js, and continuously generates code that you can override/extend. (I work on this!)
  • evolve2k 6y ago
    We’ve been seeking the “holy grail” being web dev tools our design team can use. What we’re also seeking is a way that limited end-clients could also use the tool to make minor copy changes (A poor mans CMS if you will). How might your tool support the three different users. 1. Devs who need it to create handcrafted grade code 2. Designers seeking to drag and drop with flexibility 3. Power users seeking to update copy inside the same platform Thx
    • xyzzyrz 6y ago
      Plasmic's user base is in fact split about 50/50 designers/developers. And "visual CMS" exactly describes our most common use case—letting non-developers publish changes. 1. Developers can use it as a UI builder, removing the pain of things like CSS layout (for ex., we use Plasmic to build Plasmic; and engineers at companies small and large use it on their flagship websites/apps). 2. Designers versed in tools like Figma and Webflow are probably the segment with the highest "starting proficiency." 3. Currently Plasmic is most comfortable for designers and developers, but we very much want to accommodate the end-client persona (a "copy-only-mode" is on our roadmap). Prioritization is heavily influenced by early users, so would love to hear your feedback on how this works for your team!
• amorriscode 6y ago
  I use Foam (https://foambubble.github.io/foam/ https://foambubble.github.io/foam/) for my second brain and have it integrated directly into my website: https://anthonymorris.dev/second-brain https://anthonymorris.dev/second-brain
• recov 6y ago
  Wrote a post about mine - https://blog.peasley.me/post/serving-sites-the-lazy-way_2020-02-23 https://blog.peasley.me/post/serving-sites-the-lazy-way_2020... Basically, single VPS with dokku managing multiple sites. Easy to add SSL and more websites whenever.
• qatanah 6y ago
  Using a different setup for deploying client side static html. - React/ Js framework - Deploy Static Files to S3 - Cloudfront for cdn - Cloudflare pointing to cloudfront cdn - Cloudfare Page rules for protected sites / no need create login/auth - Flask - Postgres
• tonfreed 6y ago
  I use Gatsby to generate a static blog using markdown. It goes alright, though since I'm not really a JS person it was a bit of a pain to get running
• jimmont 6y ago
  LitElement + native Web APIs, Deno on Google Cloud Run. Not novel as they've been rolling along a few years, but not as widely used/known. Easier to developer with overall: easier to manage state, loosely couple/compose components, better performance both in development and for end-use, easier to directly use native web APIs--both on the frontend and in middleware, potentially eliminating part or all of build processes.
• vldr 6y ago
  (neo)vim
• Ambix 6y ago
  Server-side-rendering all the way! Still using good-ol PHP which really shines with Comet: https://github.com/gotzmann/comet https://github.com/gotzmann/comet
• XCSme 6y ago
  I started to learn BlitzJS[0], as the promise is it allows you to quickly create apps without worrying about the DB or API, which should make it easy to create an MVP. [0]: https://blitzjs.com/ https://blitzjs.com/
• whateveracct 6y ago
  Shpadoinkle! (in Haskell)
• jboogie77 5y ago
  I like how this thread is asking what ~novel~ tools ppl are using and everybody instead is replying about how they are using php, css, Django, vanilla js, etc