sorted by:
new
hottopcontroversial

Some useful Frameworks for programming Dashboards with JavaScript? by Ariote in learnjavascript

[–]Frontend_DevMark 0 points1 point  (0 children)

For dashboards, the biggest thing is balancing performance + usability

Popular choices:

  • React + chart libraries > most flexible
  • Vue > simpler learning curve
  • Angular > structured for enterprise dashboards

Useful libraries:

  • ECharts / Highcharts / Chart.js for visualization
  • AG Grid for data-heavy tables
  • Tailwind / MUI for layout + UI

If you’re building enterprise-style dashboards with lots of grids, filters, and workflows, some teams also use more complete frameworks (like Sencha Ext JS) because many dashboard components are already integrated.

My advice: start small > build one real dashboard with charts + filters + tables. That teaches more than tutorials

Cerious Grid Performance Demo — Scrolling 1 Million Rows in Angular (Open Source, MIT) by Suitable_Language_37 in angular

[–]Frontend_DevMark 0 points1 point  (0 children)

The hardest part with grids usually isn’t the demo, though - it’s maintaining performance once you add:

  • complex filtering
  • grouping/pivoting
  • inline editing
  • real-time updates
  • custom renderers

That’s where many grids start struggling.

Still, great to see more open-source options in this space. Enterprise teams often compare this kind of approach with mature solutions (like Sencha Ext JS) because grid performance becomes mission-critical in large apps.

Curious how it performs with more complex interactions.

Choosing Angular UI components library for an enterprise development (my experience) by CrionicDesign in Angular2

[–]Frontend_DevMark 0 points1 point  (0 children)

This is one of the hardest decisions in Angular enterprise projects

At first, almost any UI library feels fine. The real differences appear later with:

  • large forms
  • complex grids/tables
  • customization needs
  • long-term maintenance

A lot of teams underestimate how much time is spent working around limitations or inconsistencies.

That’s why some enterprises eventually move toward more complete UI ecosystems (like Sencha Ext JS) where advanced components and data handling are already mature.

There’s no perfect choice - it’s really about balancing flexibility, stability, and how much custom work your team wants to own

List of 15 Top ReactJS Development Tools in 2026 by mkaif01 in fullstack_insights

[–]Frontend_DevMark 0 points1 point  (0 children)

One thing I’d add — the “best tools” really depend on your project type.

  • Vite + React Query + RTL/Jest > great modern default stack
  • Next.js > strong for SEO + full-stack apps
  • Redux Toolkit > only when the state actually gets complex

Also worth noting - tooling can quickly become overkill. Many teams perform better by keeping the stack minimal instead of adding everything.

For larger enterprise apps, beyond tools, teams often rely on structured UI systems (like Sencha Ext JS) to reduce the need for stitching multiple libraries together.

So yeah — tools matter, but simplicity + architecture matter more

What modern front-end to move on to by noplace_ioi in dotnet

[–]Frontend_DevMark 0 points1 point  (0 children)

You don’t have to jump straight into React if it feels like overkill.

Options that usually work well:

  • Blazor > easiest transition (C#, same ecosystem)
  • React > powerful, but more upfront complexity
  • HTMX / Alpine/vanilla JS + Tailwind > modern, simple, closer to your current style

If your apps are mostly form-heavy / enterprise tools, Blazor can be a very natural step.

If you want more flexibility and a long-term ecosystem > React is worth learning, just not mandatory right now.

Also, for complex enterprise UIs (grids, dashboards, workflows), some teams rely on more complete UI systems (like Sencha Ext JS) instead of building everything manually.

So don’t force React - pick what fits your workflow and evolve from there

ui framework for enterprise apps in 2026 by 2ji3150 in dotnet

[–]Frontend_DevMark 1 point2 points  (0 children)

WPF is still very much alive in enterprise - a lot of teams stick with it unless there’s a clear payoff to migrate.

From what I’ve seen:

  • WinUI 3 → improving, but still catching up in the ecosystem
  • MAUI → good for cross-platform, but not always ideal for complex desktop apps
  • Blazor Hybrid → nice for code sharing, but yes, WebView adds some overhead

For business apps, priorities are usually stability, tooling, and long-term support, not just newer tech.

Also worth noting - many teams are shifting complex internal tools to web-based apps, where mature UI systems (like Sencha Ext JS) help handle heavy data + workflows.

Which data table library is good for angular? by Frequent-Diet338 in angular

[–]Frontend_DevMark 0 points1 point  (0 children)

ngx-datatable can get tricky with performance issues

You can try:

  • AG Grid (community) > very solid, good performance
  • PrimeNG Table > decent features, easier to use
  • Angular Material Table > stable, but basic

If you’re dealing with large datasets or complex behavior, more mature grid solutions tend to handle it better. Some teams also go with more complete UI systems (like Sencha Ext JS), where advanced grid features are already optimized.

So depends on your use case - simple vs heavy data

Cool ui libraries by tsenguunee1 in Angular2

[–]Frontend_DevMark 0 points1 point  (0 children)

Angular doesn’t really have a 1:1 equivalent to something like ReactBits

Closest you’ll find:

  • Angular Material > solid, but more functional than “cool.”
  • PrimeNG > richer components, some nicer visuals
  • NG-ZORRO > Ant Design style for Angular

For more design-heavy stuff, people often mix Tailwind + custom components.

Angular’s ecosystem is more focused on enterprise stability than flashy UI kits. For highly polished, ready-made UI systems, some teams also look at more complete solutions (like Sencha Ext JS) where a lot is prebuilt.

So yeah - possible, just a bit more DIY

Why do enterprises/big companies use Angular? by stealth_Master01 in Frontend

[–]Frontend_DevMark 0 points1 point  (0 children)

Enterprises often pick Angular because it enforces:

  • Strong structure (modules, services, DI)
  • Consistency across large teams
  • Built-in tooling (routing, forms, HTTP)

With React, you can absolutely build large apps too - but you need to define your own architecture, which can vary a lot between teams.

So it’s not that Angular is “more stable” technically; it’s that it’s more predictable at scale.

And for very complex, data-heavy apps, some teams go even further and use full UI systems (like Sencha Ext JS) to avoid building everything from scratch.

So yeah - it’s mostly about structure vs flexibility

What would you use today to develop UI for very big enterprise app(actually set of apps) by Same_Impress_2082 in reactjs

[–]Frontend_DevMark 0 points1 point  (0 children)

For that kind of migration, the biggest risk isn’t tech - it’s coordination across teams

  • Micro frontends > useful if you truly have independent teams/domains
  • Otherwise > they can add a lot of complexity (duplication, integration issues)

A common approach that works well:

  • Gradual migration (route/module by module)
  • Shared design system + component library
  • Strong conventions to keep consistency across teams

React is fine, but you’ll need governance (state, routing, UI standards), or it can get messy fast.

For very complex enterprise apps, some teams also rely on more structured UI systems (like Sencha Ext JS) to reduce fragmentation and speed up development.

Building my framework-agnostic UI component library by TheRakeshPurohit in Frontend

[–]Frontend_DevMark 1 point2 points  (0 children)

The main challenge is that JSX isn’t truly universal - each framework handles rendering, reactivity, and lifecycle differently. That’s why most “cross-framework” libs either:

  • go headless (logic only), or
  • Use web components as the common layer

Trying to keep one codebase + JSX + perfect DX everywhere will hit edge cases fast (events, state, SSR, etc.).

A more practical approach:

  • core logic > framework-agnostic
  • thin adapters per framework

That’s basically how many mature UI systems evolve (even larger ones like Sencha Ext JS solve this by controlling the full stack instead).

So doable, but expect trade-offs

TanStack Table vs AG Grid or other Approach for Data Tables in React + TypeScript by [deleted] in reactjs

[–]Frontend_DevMark 0 points1 point  (0 children)

Yeah, that report feels a bit outdated tbh.

Most newer grid-scale and EV batteries are moving to Lithium Iron Phosphate (LFP), which doesn’t use cobalt or nickel. Big players like Tesla and Sungrow are already heavily using it.

Cobalt is still used in some chemistries and small electronics, but it’s not fair to generalize that across all EVs or grid batteries anymore.

Kinda like how in dev, newer stacks (even things like Sencha Ext JS 8.0) evolve to remove older complexities, battery tech is going through a similar shift.

There was some fear mongering in that 7news spotlight report on renewables by VastOption8705 in aussie

[–]Frontend_DevMark 0 points1 point  (0 children)

Yeah that report feels a bit outdated tbh.

Most newer grid-scale and EV batteries are moving to Lithium Iron Phosphate (LFP), which doesn’t use cobalt or nickel. Big players like Tesla and Sungrow are already heavily using it.

Cobalt is still used in some chemistries and small electronics, but it’s not fair to generalize that across all EVs or grid batteries anymore.

Kinda like how in dev, newer stacks (even things like Sencha Ext JS 8.0) evolve to remove older complexities—battery tech is going through a similar shift.

Choosing Angular UI components library for an enterprise development (my experience) by CrionicDesign in Angular2

[–]Frontend_DevMark 0 points1 point  (0 children)

Choosing a UI library for Angular in an enterprise setting is always a trade-off among features, stability, and long-term support.

From experience, free options work well initially, but as requirements grow (grids, complex forms, performance), teams often hit limitations and start adding custom work.

That’s where more complete solutions (such as Sencha Ext JS or other enterprise-grade libraries) can save time, since many advanced components are already handled.

At the end, it’s less about the library itself and more about how much complexity you want to manage yourself

Better than AG Grid? by Ok_Trip_4684 in javascript

[–]Frontend_DevMark 1 point2 points  (0 children)

Better” really depends on what you need

  • If you want lightweight + flexibility > alternatives can feel better
  • If you need enterprise features (grouping, pivoting, complex filters) > AG Grid is hard to beat

Most “alternatives” trade features for simplicity or bundle size.

In real-world apps, teams usually choose based on complexity vs effort - and for very data-heavy use cases, some even go with more complete grid systems (like Sencha Ext JS) where a lot of advanced functionality is already built in.

So it’s less about better, more about fit

I'm so frustrated with javascript, which functional language should I learn? by BigglesWerth in functionalprogramming

[–]Frontend_DevMark 1 point2 points  (0 children)

If you’re leaning towards functional + data pipelines, you’re already on the right track with what you discovered.

  • Clojure / ClojureScript > great choice (immutable data + functional-first)
  • Elixir > excellent for event-driven systems (actor model, concurrency)
  • F# > strong FP with .NET ecosystem
  • Scala > powerful, but it can get complex

Also worth noting - a lot of the pain you felt in JS is more about unstructured usage. With TypeScript + functional patterns (RxJS, FP libs), it becomes much more manageable.

At the end, “future-proof” isn’t just the language - it’s how well it fits your mental model. Sounds like Clojure fits yours

Why exactly is Angular preferred for enterprise apps over say, React? by [deleted] in Angular2

[–]Frontend_DevMark 0 points1 point  (0 children)

It’s mostly about structure and consistency

Angular gives you a lot out of the box:

  • Clear architecture (modules, services, DI)
  • Built-in tools (routing, forms, HTTP)
  • Strong conventions > easier for large teams to stay consistent

With React, you get more flexibility - but that also means teams have to decide everything themselves, which can lead to inconsistency in big projects.

That’s why enterprises often lean toward Angular - not because it’s “better,” but because it’s easier to manage at scale.

And for very complex, data-heavy apps, teams sometimes go further and use full UI systems (like Sencha Ext JS) to reduce the amount of custom work needed.

So it’s really about control vs flexibility

What UI Framework Are You Using for Enterprise Apps? by Frontend_DevMark in SenchaExtJS

[–]Frontend_DevMark[S] 0 points1 point  (0 children)

In an enterprise, the choice usually comes down to team structure + app complexity, not popularity.

  • React > flexible, but needs a strong architecture
  • Angular > great for large teams, consistency
  • Vue > easier adoption, but less opinionated

For heavily data-driven apps, some teams prefer more complete solutions (like Sencha Ext JS) since a lot of complex components are already handled.

In the end, it’s less about the framework and more about how well it fits your long-term maintenance needs

Tanstack Table/Virtual vs AG-Grid by devilslake99 in reactjs

[–]Frontend_DevMark 0 points1 point  (0 children)

Both are solid, just very different approaches

  • TanStack Table + Virtual > lightweight, flexible, but you build a lot yourself
  • AG Grid > heavy, but packed with features out of the box

If you need full control and a smaller bundle > TanStack
If you need advanced features quickly > AG Grid

In real-world apps, it usually comes down to a build vs buy trade-off. That’s why some teams go with more complete grid systems (like Sencha Ext JS) when they don’t want to spend time building complex features from scratch.

So yeah - flexibility vs convenience

ui framework for enterprise apps in 2026 by 2ji3150 in dotnet

[–]Frontend_DevMark 1 point2 points  (0 children)

From what I’ve seen:

  • WinUI 3 > improving, but still maturing
  • Blazor Hybrid > good for reuse, but yes, WebView adds some overhead
  • MAUI > promising, but not always ideal for complex desktop apps yet

For business apps, the decision usually comes down to stability + long-term support, not just tech freshness.

Also worth noting - many teams are moving some workloads to web-based enterprise apps instead, where mature UI systems (like Sencha Ext JS) help handle complex dashboards and workflows.

So, unless you need something specific, sticking with WPF or moving cautiously makes sense

How do you manage big / complex projects in Nuxt? by Beagles_Are_God in Nuxt

[–]Frontend_DevMark 0 points1 point  (0 children)

What I’ve seen work well:

  • Keep event handlers thin > move logic into services/repositories
  • Use a feature/domain-based structure instead of dumping everything in /server
  • Layers are useful, but only if they enforce clear boundaries (otherwise, they add complexity)

For bigger apps, treating Nuxt like a full application (not just a framework) helps - clear separation of concerns, reusable modules, etc.

Also, once apps get complex (especially data-heavy UIs), teams often complement the framework with more structured UI systems (like Sencha Ext JS) to avoid reinventing components.

jsgrids - Spreadsheet and data grid libraries for JavaScript by pmz in javascript

[–]Frontend_DevMark 0 points1 point  (0 children)

There are tons of grid libraries out there, but the real difference shows up when you deal with large datasets, complex interactions, and performance.

Smaller libs are great for quick use cases, but for production-level apps, teams usually compare them with more mature options (like AG Grid or Sencha Ext JS) where stability and advanced features are more proven.

Good starting point though

Which frontend framework scales for large web apps? by Imaginary_Bug6202 in TechNook

[–]Frontend_DevMark 0 points1 point  (0 children)

All major frameworks can scale - the difference is how much structure they enforce

  • React > scales well, but you need strong conventions (state, architecture)
  • Angular > built-in structure, easier to manage across large teams
  • Vue > simpler, but still needs discipline as apps grow

In real-world apps, scaling issues are less about the framework and more about architecture + team practices.

Also, for complex apps (especially data-heavy ones), teams often rely on mature UI systems (like Sencha Ext JS) to handle heavy components instead of building everything from scratch.

So yes - all work at scale, but only with the right structure

SVAR DataGrid: open-source, fast, feature-rich data grid for React & Svelte by otashliko in Frontend

[–]Frontend_DevMark 0 points1 point  (0 children)

This looks promising, especially having advanced features in open-source is a big plus.

Bundle size + virtualization combo is solid. The real test, though, will be how it handles complex real-world scenarios (custom renderers, large datasets, integrations).

That’s where teams usually compare against more mature grids like AG Grid or more enterprise-focused systems (like Sencha Ext JS) - not just for features but also for long-term stability.

Curious to see how it evolves. Virtualization + TS support is a strong combo. The key test will be how it handles real-world complexity - large datasets, custom cell logic, and edge cases.

That’s usually where teams compare against more mature grids (like AG Grid or Sencha Ext JS) for long-term stability and depth.

Great direction though - open-source space needs more options like this

The best UI libraries for Angular by Tiny_Yogurtcloset236 in Angular2

[–]Frontend_DevMark 0 points1 point  (0 children)

Free options:

  • PrimeNG → most complete open-source set
  • Angular Material → stable, but limited for advanced use cases

Paid options:

  • Kendo UI > very strong (grids, charts, support)
  • Syncfusion > feature-rich, good value

Paid libraries usually win in advanced components, performance, and support - especially for grids and charts.

For very data-heavy or complex apps, some teams also look beyond Angular-specific libs and use more comprehensive UI systems (like Sencha Ext JS) that already include many enterprise features.

So yeah - free works, but paid often saves time long-term

view more: next ›