• Article is about: best practices + guide + awesome list of tech-stack(libs,tools...), platforms, workflow.
• Multiple options: are for you to decide based on your goals.(compare X vs Y, pros/cons, use-case..)
• Recommendations: given based on summary of various factors: test or compared reviews of experts on the field.

Decisions: have long-term impact. Dev-stack/toolchain + working method/strategy impacts your progress.
Making right choices: early on, increase success and progress chances, self-respecting your skills.
Nothing's perfect, yet... better options/methods improves DX, workflow, structure, progress, efficiency.

To Contribute >> add links to items, reason/prove an obvious better option, improve doc.

_{* target users - keywords: developers, designers, researchers, students, startups, decision makers}

Starter intro

Awesome list

Programming Languages

Frameworks - more info/details

Extra information and discussion

Don't make technical decisions just based on what others do, market hype, popular trends...
...instead, decide based on multiple factors, such as:

Pros/Cons - Review Comparison - Requirements- Best fit / Integration,
Problem solves - Feasable / Accessible - High Rated - Popularity,
Focus / Goals - Priority / Importance - Stable Eco-system
and finalize your decision considering:

• Main Priority - Best fitting - Feasable? Can be done? (adopt / implement / execute)
• Work type: startup/job/personal - State: start / scale / remake / migrate / available.
• Impact: team, users, cost, dev-cycle, integration, stablity, milestone, completion.

Wish you good luck!

Native SDK Android, iOS, embeded runtimes... if targeting specific device abilities or inclusive native functions of an embeded device, phones or a VR headset.

Web if the development target is general, multi-platform, web/communication based, and not limited by vendor lock-in, then use the web platform, which has most use cases, most open and is cross-platform. It covers all platforms client, server, browser, mobile devices, cloud and desktop.

System in case lower level control/privacy/system access is required, or direct Hardware/OS access and high performance at scale, then a server/workstation system/s plus a custom software stack (low/mid level programming languages, SDK, runtimes...) is more suitable.

Cloud A complete or custom system solution on web/network. You subscribe to a managed virtual system, in different levels from VPS, API, Host... much features, managed/maintained. All pros, only cons: no physical control/access/privacy(unless self hosted)

• Being a Dev is not easy, takes time, effort, practice and experience to gain practical skills, much to cover.
• 1st learn the basics including the new updates. Ex: for web >> Basics and new additions of JS, HTML, CSS.
• Learn the main skill from Docs, or best resources, search for recent materials with high views/stats on youtube.
• Group work, join friends, divide tasks/learning, share your findouts, practice as a team, is too much for one person.

Go to beginner guideline details-> Web-Dev guideline

• Chat/Prompt: Online: Groq - ChatGPT - Local: chat with RTX - Jan.
• Platform / API: Nvidia NIM, OpenAI, Clarifi(api), Google, Microsoft, x.ai
• Inference Providers: Fireworks (best value) - Together.Ai - Repliccate - OctoAI
• Browser/Runtime (client/local): Web LLM _ Web-AI _ MLC-LLM _ Jan/Nitro
• AI Strategy: first local, Specific, in-context learning > fine-tuning EiF to usecase > RAG

• Top Ranked: Llama-3.1-405B+ instruct, Claude-3-Opus, GPT4-o-next, Grok.
• Full Opensource: Phi3 _ Mixtral MoE _ Command R+ _ DBRX.
• Run Locally: Mobile: Phi3-mini-3.8B _ Desktop: Phi-3-small - Llama-3.1-8B instruct.
• Vision/LM: PaliGemma combined visual+text LLM + can fine-tune well for specific use-case.

_{* AGI(Artificial General Intelligence) .... MoE(Mixture of Experts)}

• Autonomous Agents _ long-term mem: MemGPT - CrewAI _ +toolchain: Langchain - AutoGPT
• Audio: text to music: Udio _ TTS: Parler TTS PlayHT ElevenLabs _ speech to text: Deepgram
• Image: DALL-E, Stable Diffusion, Imagen - APP-(user): MidJourney, FreePik, Adobe Firefly
• Visual input: Grok vision - Video creation: Sora most realistic videos bythe mean time.
• Code assist: Github Copilot - GPT-4 Chat/API - open-source: Open Devin - Devika.
• Dev Assist: - Local AI Hub: Ollama UI LM-studio Jan - interact with a website: GPT Crawler

Best youtube AI Channels: bycloud - Ai Jason - Matthew Berman

^

• Mobile: Web based: (multi-platform) Tauri, Socket - Capacitor Native: device SDK(only if required)
• Desktop: Tauri (Web App), Deno executable(Web/CLI).
• Front-end: Svelte(best overall, best DX) - Vue(past populary, jobs) - Solid(React replacement).
• Back-end: JS runtime-> Deno, Node.js/Bun - or specific platform, services, programming languages...
• Full-stack: Svelte-kit (true fullstack) - Astro(many frameworks) - Next/Nuxt (popular backends)
• Crossplatform: Tauri(desktop, mobile, Rust functions) - Socket runtime (desktop, mobile, P2P data)
• Programming Languages: JS, Zig, Rust, Go, Elixir, Mojo, all based on use-case: client/server, AI, Mobile. (..more)>>

^

Standard CSS:

• when more control, precision and customization or zero dependency is required.
• Big-picture of system design is clear to a CSS specialist, just by looking at the code.
• new CSS standards solve much issuess developers had in the past.
• recommended for: highly custom UIs, advanced projects,
• in any case you must master it to be able to effectively design or use other libs.

UI Lib / Kit - main advantages >>

• reduced text instructions (+readability)
• more uniform design model in teams. (mostly for junior devs)
• faster development and prototyping. (mostly on abstract components)
• tooling automation, pre/post processing...

• CSS utility frameworks -UnoCSS: use presets of tailwind, DaisyUI, etc... it compiles to to standard CSS.
  -Lightening CSS: tool for short codes, presets, functions, optimizing, speed, minifier.
• Headless/Structure (you do custom style): headless ui, Melt UI, Bits UI (Svelte)
• Tailwind: short-code classes, has pro/cons, yet from v3.4 is good to use in right way.
• Minimal Libs: Melt UI(basics), Pico CSS(default styles), BeerCSS, DaisyUI(pure CSS lib)
• CSS toolkit: Tailwind or UnoCSS - build available CSS presets/syntax into standard CSS
• UI-Kits: CSS components: Daisy UI - functional components: Skeleton, flowbite, ShadCN
• Icon-sets: unplugin-icons: best to import various icons, no deps, vite plugin tooling
• 3D: Spline, Babylone.js(FW), Three.js(lib), Threlte(Svelte+three), Unity Tiny

• UnoCSS - best toolkit and presets. (code in other Lib, compiled into standard CSS)
• picoCSS - best for predefined styling of standard HTML Tags.
• DaisyUI - best pure CSS UI components lib you can get while JS is optional.
• BeerCSS - better option in case you're into material design concept.
• Shadcn - best customizable components kit (mostly in Shadcn-Svelte).
• Skeleton UI- best UI components kit for Svelte framework.
• Agnostic UI- various pros, in case it benefit your work.

^

• Cloudflare: most professional option, reliable, advanced network system and services.
• Hosting clouds: used to host site/app, but now offer many cloud functions/solutions Ex: Vercel or Netlify
• Enterprise: (more features+scale - extra cloud functions/services)

1. Amazon AWS .... 2. Azure (Microsoft) .... 3. Google/Firebase

• Alternatives:

  • Cloud: Vercel, Supabase - CMS: Prismic, Builder.io
  • Self-host: Cloud: Coolify - CMS: Sveltia - Server: PocketBase
  • Decentralised -> Nostr, Bluesky/AT protocol. Social features, free, secure, anti-censorship.
  • Self hosted lib: Gun.js => free, encrypted, distributed(web torrent).
  • Fullstack servers + default options: cyclic.sh(full options +S3 +DynamoDB) - railway.app (+postgreSQL)

^

• `Next-Gen: (decentralized/p2p privacy, security, extras): Nostr, AT protocol, GunDB.

• Performance: cloud edge DBs -> Turso(libSQL), Cloudflare/DenoDeploy(KV). multi-model: Redis + modules.

• Innovative: Drizzle + Turso - EdgeDB - SurrealDB - Dgraph(graphQL+DX) - Vector DBs (AI use-cases).

• Open Source:

  • libSQL: a fork of SQLite but both local, remote and server.
  • Arango DB (multi-model) to self host or cloud.

• Recommendations:

  Nostr : decentralized communication protocol. user ownership of data, privacy and sharing.
  Turso : libSQL DB on cloud/edge. (fastest SQL on edge)
  libSQL : best SQLite fork for local DB (server/mobile app)
  Drizzle: ORM worth using, Reason: work with various DB formats without knowing them.
  EdgeDB: simple + you prefer: EdgeQL + native ORM/graphQL-ish model (no need seperate ORM).
  SurrealDB: advanced, lots of DB models, features, customize and options.

^

• REST : a client request data/information... from a server, which responds with state+data.
• GraphQL. similar to rest but query a specific set of data, by relation/s, only effective if correctly queried(not less, not more).
• gRPC / tRPC . binary data, prioritise performance, volume, and security. next generation of protobuffers.
• WebSocket For real time, low latency applications.
• WebRTC / WebTorrent applications of distributed net, shared, p2p, serverless, save cost, user privacy/annonymity.
• ORM (DB interaction model) custom SQL/nonSQL query access method. custom relational behavior, code to DB interfacing.

• Rust: WebASM std / Safe / Precise / System / Performance / Resources / Community.
• Zig - Carbon: C++ alternatives - Julia: low-level Performance, high-level syntax.
• Go: (Low/Med level): simple good syntax, well developed/maturity, good for backend.
• Nim(+fast, semi python syntax). Mojo: (+python-like, resources, AI, Devs like it).

• platform based: All: Web/JS, AI: Python, JS (APIs), Mac/IOS: Swift.
• other good langs: Elixir, Haskel, C++, C#, Bend.
• Bend: Parallel processing computation. Use CPU/GPU cores WITHOUT specific/low-level methods (Cuda, Metal...)

(Type Safety / Typescript):

• Typescript: Not a language, a superset over JS - a type system for JS - compiles to JS.
• Valibot: schema library for validating structural data. also on runtime and integration point.
• ...note: type safety feature is effective for specific use-case and not universal usage.
  ...more on type safety and typescript:

  Majority misunderstand TS for safety, security and a language by itself, while it mostly impacts development cycle. For product is only effective if is implemented at runtime and integration validation points. Therefore use Typescript/typesafety layer only when the usecase is valid, or required. such as immutable restricted and custom defined data structures. Ex: database schemas, configuration, authentication...
  more usecases: large teams - random/changing developers. different developers encounter type restrictions and potential issues/errors, they are forced to resolve type and other restrictions before merging or deliver to other devs. This ensures all follow same guidelines and patterns, getting defined results... yet codebase becomes more complex, takes time and cost. It's simpler and more efficient to use a validation system, such as Valibot, can use it in JS too, and in runtime.

^

• Hosting: .. Vercel, Cloudflare Pages, Deno Deploy, Begin, Netlify.
• Store/e-commerce: free open-source, best for developers: Medusa . best for non-devs: Shopify.
• Static Site Generator: Astro(all), Hugo(go), Hexo(js), Next(react), Nuxt(vue), MkDocs(py)
• Content Management System: Primo(svelte), Strapi, Ghost, Netlify CMS, Apostrophe, Factor(vue).
• Audio API: Tone.JS(free, all round audio API), Twilio(Call communication, speech).
• Dev/Repo Platforms: Github, Gitlab, Gitea (self-host), Stackblitz, Notion, Collab...
• Dev tools: CLI tools(GIT, bash, npm...), vite(bundler), vs-code + extensions, emmet...
• Kubernetes: Fault Taulerant application containers to manage scale, monitor, resources.
• Photo/Image: format -> Avif, compress/encode-> Avif encoder (best from: AOM, lovell, rav1)
  • Libs: Sharp, lib-vips, lib-heif, ImageMagic (good as online tool/ or cloud usage...)

^

• Font-end(client side) - Backend(server-side) - Fullstack(Front and back) - Unified Fullstack(integrated model).
• SSG Static Site Generation pre-built app/content > host-CDN > page/app delivered on user request > on client side.
• CSR Client side rendering both static and dynamic content on client side. Updates are based on app logic and UI design.
• SSR Server Side Rendering UI > client > user interaction > server > processed real-time on server > new renders > client.
• Modern Custom Multi Model SSG + SSR + custom optimizations, only changes updates/delivers. +performance +efficiency.
• various features: Reactivity - Signals - Runtime - Compiled - Snippets - defined structure - Event management.

• 1. Svelte: (Best overall), DX+, innovative, compiles to standard web, long term strategic choice.
• 2. Solid: (Minimal) fast, efficient, reliable, fine tuned reactivity, react devs alternative.
• 3. Vue: (community) __ Angular / React / .Net (GG/FB/MS company platforms), Job offers/forced/required.

• Deno: secure by default, lighter, faster, Wasm, better concept, +DX. (recommended)
• Node: core JS Runtime most libs, support, popular. Node.JS BE frameworks: hono, polka, koa
• Bun : Node.js compatible but higher performance.

^

Sveltekit: complete yet custom scalable solution, flexible use of frontend + backend.

Best web/app framework + DX, combined best practices and innovations in web ecosystem.
Phoenix: Live view generative FE + Elixir BE. Best for server oriented web development.
Astro: your frontend of choice + a unified good set of predefined patterns, tools, DB!
Custom Build: Vite(bundler/dev-server) + Nitro(Server) + Vinxi(Router) + FE UI/interface

Node.js cloudish frameworks: Next(Vercel/React), Nuxt(VUE), Astro(multi platform).

Developer Experience: write less code, concentrate on your ideas, not development complexity.
Standard: the code is compiled to standard JS. Fast/optimized, can be used anywhere, reusable.
Less complexity: easier to read code, compiled, no v-dom overhead, no framework caused issues at runtime.

less Testing/Dependency issues: unexpected reactions, conflicts, misunderstanding source of issues.
less Errors: due to not having runtime dependencies, or external factors except your own code.

Less Cost: easier to read code of other devs => continue their work + less bugs + less testing + faster development.
Smaller bundle size (Compiled), without virtual-dom and framework overhead...

^

• Front-end: Dev/Design of client side web app/site, dev/Design. HTML5, CSS, JavaScript, PWA, frameworks, Web assembly...
• Back-end: processing/data on server network, host/cloud, centralized or distributed. SSR(Server Side Rendering).
• DevOps: manage and process dev/product ecosystem. analytics, control, automation on Local, remote, distributed systems
• Cloud: online server platforms, you can subscribe to services: process, storage, resources, ready made functions.
• Cloud services: when you don't have a scalable server/resources. 2- require API/Apps/services from amazon, google,...
• Developer Experience: (DX) satisfaction rate of developer, plus how empowering, practical, direct, and unambiguous it be.
• Correct development method ⇒ simplify, reuse, secure, update, avoid complex dependencies/overhead.
• Software Engineering: use engineering principles and process-methods to approach the issue/task.
• Solution Architect: a senior lead/engineer that evalutes an idea/goal/issue, then design, document and execute a structured plan while making many considerations.

A solution architect has some business insight/strategy and various technical knowledge/experience, using engineering principles, analytics,... design-pattern-process-methodology and some research experience.

^

1. Learn the base web standards -> (HTML, CSS, Javascript) follow/practice tutorials. Make few apps.(ex: Todo)
2. New web standards -> ES6/next, new HTML, new CSS (grid,...) practice/try what you learn.
3. Update the previous apps you made, using new things you learned. make a game and a blog site.
4. Deploy: learn how to host/deploy your site. Host on cloudflare pages, deno deploy, begin, netlify, github pages,...
5. Learning decision: learn extra stuff once is required(predict it). (Ex: DB, AI, specific tools/libs...)
6. Learn a Framework: better Dev-eXp & scoping. composable, reusable components, structure and configuration.
7. Learn Design: Patterns, tools, UI/UX(user interface/experience). Concepts: visual clarity, visual effects, utility 1st.
8. Responsive design: native looks, any device, clear focus, usability/accessibility. CSS flex, grid...
9. Backend: 1. Sveltekit(if using svelte) ___ 2. Deno: new js-runtime replacement for Node.js by its creator.
10.Personal various experiences, use GIT, github, Make a portfolio site (show case). a social profile: Linkedin + twitter.
11.Testing/Typing: only if neccessary and: in large teams on complex projects with security risk or much new/junior/outsourced devs.
12.Summary: Be an expert in one field, pro on few more, know about the rest. Fullstack: Frontend + Backend + Eco-system + Experience.

^

Past AI: Machine Learning + Data/algorithms.
Output results such as detection/decision/states... are made from a defined input processed by Machine Learning + Data science tools/patterns to extract meaningful data/states, using specific algorithms and models.

Pre/Current: Generative AI, builds result from input data.

• input can befrom single or multiple sources such as: files/DB/web/user prompt/system/parameters...
• input/User describes a composed request: question/s, problem/s, statement prompt/s, data.
• then Ai model process all to construct/expand/difuse/compose/conclude... Finally it generates the result based on request/objective.

Present: Generative AGI. Is the same as above, but more accurate, matured and efficient.

• multi-modal, multi-tooling, larger models, improved data quality and training, higher performance hardware.
• various methods and techniques used to improve results.
• increase precision/performance, reduce hallucination/mistakes, iterative pipelines to improve/abstract/clean/test data, verify, validate results.

Future Ai: is a systemic AGI. It creates custom composed advanced solutions, adding real-time autonomuos abilities.
The past generation recognise, detect, compose a result, This new generation understands (input + general concept + you).

• focused concepts and Results processed in realtime cycle, by a general purpose dynamic multi-model.
• the output iterates/evolves based on all defined parameters, whatever interacts with it.
• time-scalable, includes a history record, remember and relates, process past and current events, consider future.
• optional autonomous act: triggers new events or impact external entities, based on various factors/parameters + input/sensor data.

^

• Better: learn best new tech options, practice, freelance, get hired, build an idea startup team.
• Easier: take a positive internship, learn, collab, you either get hired or improve portfolio/experience.
• Collaborate: Learn/Use collaboration tools/platforms like GitHub.
• Job: find a job or startup a new team. Wish you the best.

The web was originally made to communicate with text and data, it later evolved to present simple graphics and images.

^

^