- This article covers about:
best practices+awesome list of: libs, tech stack, platforms, tools... - The multiple options are for you to decide based on your goals.(compare X vs Y, pros/cons, use-case..)
- Recommendations made based on various factors summary, by comparing reviews of few expert 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 linksto items,reason/provean obvious better option,improve doc.
* target users:developers,designers,researchers,students,startups,decision makers
Shortcuts >>
Don't adopt tech/skill options just based on current market hype or job search...
...instead, decide based on multiple factors, such as:
Pros/Cons - Compare/Reviews - Best fit for task, Problem solves - Use-case/Goal - Rate/Popularity
Goals: work-type: startup/job/personal __ focus target: start, scale, migrate, profit.
Impacts: team, users, dev-cycle, stablity, milestone, cost, completeness...
... expand topic ↴
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)
- 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(various),Google,Microsoft,x.ai. - 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:
Claude-3-Opus,GPT4-o-next,Grok,Llama-3-400B+ instruct. - Opensource:
Phi3_Mixtral MoE_Command R+_DBRX. - Run Locally: Mobile:
Phi3-mini-3.8B_ Desktop:Phi-3-small-Llama-3-8B instruct. - Vision/LM:
PaliGemmacombined 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:
Udiotext to music _PlayHTorElevenLabstext to speach _Deepgramspeech to text - Image:
DALL-E,Stable Diffusion,Imagen- APP-(user):MidJourney,FreePik,Adobe Firefly - Visual input:
Grok vision- Video creation:Soramost realistic videos bythe mean time. - Code assist:
Github Copilot-GPT-4 Chat/API- open-source:Open Devin-Devika. - Dev Assist: - Local AI Hub:
Ollama UILM-studioJan- interact with a website:GPT Crawler
Best youtube AI Channels: bycloud - Ai Jason - Matthew Berman
About Different AI generations >>
Frameworks >>
Mobile: Native device SDK......Open Web based (multi-platform): Socket, Tauri, CapacitorDesktop: 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: Socket runtime (Desktop, Mobile, P2P net/storage)Programming Languages: Zig, Rust, Go, Mojo, Swift... (per use-case: Server/Backend, AI, Mobile).
UI >>
Standard CSS:
- when more control, precision and customization or zero dependency is required.
- new CSS standards solve much issuess developers had in the past.
- recommended for: small projects and teams, in any case you must master it to use libs effectively.
UI Lib/kit - main advantages >> less text instructions(+readability), uniform design model in team, faster development and prototyping, tools automation.
CSS utility framework:
UnoCSS(short codes, presets, functions)
Lightening CSS(tooling, optimizing, speed, new tech)
UI structure(you do custom style): renderless, headless ui, Melt UI, Bits UI (Svelte).Minimal UI Libs: pico css, BeerCSS, DaisyUI(pure CSS lib),CSS toolkit: UnoCSS - compiles other CSS frameworks into standard CSS.UI-Kits: Daisy UI(CSS) ....functional components: Skeleton, flowbite, ShadCN.3D (WebGL/GPU): Spline, Babylone.js, Three.js(lower level), Threlte(Svelte+three), Unity Tiny.
UI Recommendations + reason:
UnoCSS- best tool for presets. (code as other Libs yet it builds to standard CSS)picoCSS- best for predefined styling of standard HTML Tags.DaisyUI- best CSS UI lib you can get where JS is optional (pre UI kit).Skeleton UI- best UI components Kit for Svelte framework.Agnostic UI- various pros, in case it benefit your work.BeerCSS- better option in case you're into material design concept.
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 NetlifyEnterprise: (more features+scale - extra cloud functions/services)
- Amazon AWS .... 2. Google/Firebase .... 3. Azure (Microsoft)
-
Cloud: Vercel, Supabase -CMS: Prismic, Builder.ioSelf-host: Cloud: Coolify - CMS: Sveltia - Server:PocketBaseDecentralised-> Nostr, Bluesky/AT protocol. Social features, free, secure, anti-censorship.Self hosted: PocketBase ...Basic/Dapp-> Gun.js => free, encrypted, distributed(web torrent).Fullstack servers+default options: cyclic.sh(full options +S3 +DynamoDB) - railway.app (+postgreSQL)
Next-Gen: Nostr, AT protocol, GunDB - decentrlized, secure, extra features(DB+SN/COMM).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(fastest SQL on edge),Arango DB(multi-model) both can self host or cloud.Recommendations:Nostr: decentralized communication protocol. user ownership of data, privacy and sharing.
Turso: libSQL DB on cloud/edge networks, libSQL is a fork of SQLite but both local, remote and server.
Drizzle: the only ORM worth using,Reason: work with various DB formats without knowing them.
EdgeDB: simple + you prefer EdgeQL + includes ORM/graphQL-ish model (no need for 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, only effective if correctly queried(not less, not more).gRPC / tRPC. binary data, prioritise performance, volume, and security. next generation of protobuffers.WebSocketFor real time, low latency applications.WebRTC / WebTorrentapplications 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.
-
Programming Languages:- (Low level)
Carbon(semi C++),Zig,Julia: LL Performance, High-Level syntax.Rust: WebASM std / Safe / Precise / System / Performance / Resources / Big Community, Support.Go: (Low/Med level): simple good syntax, well developed/maturity, good for backend.Nim(speed/semi python syntax).Mojo: (+semi-python, resources, AI, Devs).
- (High level): Platforms ecosystem:
All: Web/JS,AI: Python, Any(APIs),Mac/IOS: Swift. - other good langs:
Elixir,Haskel,C++,C#,Bend. Bend: Parallel process computation that utilize CPU/GPU cores without specific/Low-level methods (Cuda, Metal,...)
- (Low level)
-
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/RepoPlatforms: 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. -
Other stuff: find useful libs, online tools, AI tools, which help and improve DX.
- 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,koaBun: 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. highly focused on server/backend oriented dev.Astro: your frontend of choice + a unified good set of patterns on backend, predifined tools, DB!Custom Build:Vite(bundler/dev-server)+Nitro(Server)+Vinxi(Router)+FE framework/tools
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 systemsCloud: 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.
...press to expand.
Hardware advancements in performance and capacity, plus emerging smartphones and social networks caused web based online services go mainstream in network communications, it progressed fast and competes with native platforms. The sudden progress pace in contrast with the concept of keeping it backward compatible with legacy standards, caused some complexity and confusion in the last decade due to workarounds to support new features by vendor prefixes, various 3rd party libs, tools and frameworks to achieve demands of dev/user/market. The slow adoption of new trends was caused by issues with backward compatibility of existing sites and old systems while native mobile and desktop platforms had all breaking changes at once to support new hardware. By then 3rd party libs, prefixes and frameworks... were made to solve/patch the issue and provide features that didn't exist in web standards yet.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.
...Details - Reasons and Pointers on choosing tech stack/methods... (press to expand)
- Avoid learning 6 ~ 10+ years old stuff if a better alternative is available. old tech was made for past era ecosystem, development model and HW/SW/issues.-
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.
- Each time a breaking change shows up, you might need to repeat this process. this makes multiple dev branches in a company if the team can't / won't follow.
-
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,...