The Perfect Tech-guide & Awesome-list
🛠itech
- tools
- Libs
- Frameworks
best practices
+ guide
+ awesome list
of tech-stack(libs,tools...), platforms, workflow. 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
Shortcuts
Starter intro
Awesome list
Programming Languages
Frameworks - more info/details
Extra information and discussion
To beginners and startups
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.Majority of developers adopted older popular tech/methods by the circumstances in past, by workplace/education requirements job offers, senior advice, or the 1st option encountered, or just due to common hype, in the past, but not the best choice now.
This cycle repeats and non optimal tech get stuck in social, market, and job/edu systems, then if you adopt it, by the time you build your work on it, the tech might be near end of life, or bad/slow pace, as it holds to legacy patterns, and compatibility patches to make it work with ongoing needs of the users.
Therefore instead of market hype, make decisions based on facts, use whatever is best for the job, mostly if you're doing your own business or planning a startup
, deciding better tech/methods, results in productivity, efficiency and saves time/cost.
Therefore If you're not forced or bound by a legacy eco-system or specific rules/conditions, do your research, compare options, and make decisions you benefit.
...extra pointers on this topic...>>
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)
Learning tips
Go to beginner guideline details
-> Web-Dev guideline
Groq
- ChatGPT
- Local: chat with RTX
- Jan
. Nvidia NIM
, OpenAI
, Clarifi(api)
, Google
, Microsoft
, x.ai
Fireworks (best value)
- Together.Ai
- Repliccate
- OctoAI
Web LLM
_ Web-AI
_ MLC-LLM
_ Jan/Nitro
first local
, Specific
, in-context learning > fine-tuning EiF to usecase > RAG
Llama-3.1-405B+ instruct
, Claude-3-Opus
, GPT4-o-next
, Grok
. Phi3
_ Mixtral MoE
_ Command R+
_ DBRX
. Phi3-mini-3.8B
_ Desktop: Phi-3-small
- Llama-3.1-8B instruct
.PaliGemma
combined visual+text LLM + can fine-tune well for specific use-case. * AGI
(Artificial General Intelligence) .... MoE
(Mixture of Experts)
long-term mem
: MemGPT - CrewAI _ +toolchain
: Langchain - AutoGPT
Udio
_ TTS: Parler TTS
PlayHT
ElevenLabs
_ speech to text: Deepgram
DALL-E
, Stable Diffusion
, Imagen
- APP-(user): MidJourney
, FreePik
, Adobe Firefly
Grok vision
- Video creation: Sora
most realistic videos bythe mean time.Github Copilot
- GPT-4 Chat/API
- open-source: Open Devin
- Devika
.Ollama UI
LM-studio
Jan
- interact with a website: GPT Crawler
Best youtube AI Channels: bycloud - Ai Jason - Matthew Berman
About
Different AI generations >>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
:
UI Lib / Kit
- main advantages >>
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 Tinyreason
: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)
- Amazon AWS .... 2. Azure (Microsoft) .... 3. Google/Firebase
Alternatives
:Cloud
: Vercel, Supabase - CMS
: Prismic, Builder.ioSelf-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).All: Web/JS
, AI: Python, JS (APIs)
, Mac/IOS: Swift
. 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
: 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.Avif
, compress/encode-> Avif encoder (best from: AOM, lovell, rav1)
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). Static Site Generation
pre-built app/content > host-CDN > page/app delivered on user request > on client side. Client side rendering
both static and dynamic content on client side. Updates are based on app logic and UI design. Server Side Rendering
UI > client > user interaction > server > processed real-time on server > new renders > client. Custom Multi Model
SSG + SSR + custom optimizations, only changes updates/delivers. +performance
+efficiency
. Reactivity
- Signals
- Runtime
- Compiled
- Snippets
- defined structure
- Event management
.Svelte
: (Best overall), DX+, innovative, compiles to standard web, long term strategic choice. Solid
: (Minimal) fast, efficient, reliable, fine tuned reactivity, react devs alternative. 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.
Present
: Generative AGI. Is the same as above, but more accurate, matured and efficient.
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).
The web was originally made to communicate with text and data, it later evolved to present simple graphics and images.
Good news, the new web standards and innovations, improved the situation, furthermore Frameworks evolved and matured including new Web APIs to provide functionality and access to new technologies. Therefore with much flexibility, compatibility and openness, Web eco-system can now compete with native desktop and mobile platforms.
Whenever learning something, learn latest stable standards and best practices, some of the old prefixes, 3rd party libs,... are not required anymore...(as explained above) unless is justified, mandatory or no alternatives. The recommended trends mentioned here were handpicked by checking reviews comparison, personal experiments, and by looking into new trends top professionals adopt.
Is still popular due to seniors who learned it in past when it was a valid option and using it at work for years, later new developers are forced to follow them. This process might repeat multiple times...
The old popular tech nature: ___ it works, is popular and has big community and resources, yet in time it becomes more complex, due to extensions, compatibility patches and conflict solving layers to make both the original and new syntax/tools/requirements work together... Aside of that each time a new feature is added, this process might repeat, and the platform gets large, complex, multiple different revisions.(Ex: MS SDKs, .net framework,...)
Breaking changes and migration: ___ when a new feature that contradicts something in the system which can't be solved, the devs will decide to either give up on the feature, add extra flags/configs or make a breaking change, thus you must stay on old branch or learn + update your previous codes or totally migrate if is hopeless.
Prevent Issues: an old legacy target which depends on layers of other legacy tech, will encounter conflicts, compatibility, deprecated dependencies, which will cost time + resources + man power to solve them.
Low level coding is not affected much by the mentioned issues. they rarely change, and if so, is about new features, compatibility and stability.
Unnessecary overhead: as old devs retire, new ones might add extra layers of abstraction instead of updating the original code, these issues cause: extra complexity, overhead, extra cost in long-term, Large number/size of files, large developer teams, or slow working pace,...