Languages & Frameworks tools

Most used tools

1. #1
   

   TypeScript

   Typed superset of JavaScript that compiles to plain JS

   5 users
2. #2
   

   Python

   Versatile high-level programming language for all domains

   5 users
3. #3
   

   Next.js

   React framework for production with SSR and static generation

   5 users
4. #4
   

   Tailwind CSS

   Utility-first CSS framework for rapid UI development

   5 users
5. #5
   

   React

   JavaScript library for building user interfaces

   4 users
6. #6
   

   Storybook

   UI component explorer for frontend developers

   4 users
7. #7
   

   Rust

   Systems language focused on safety, speed, and concurrency

   3 users
8. #8
   

   Django

   High-level Python web framework for rapid development

   3 users
9. #9
   

   Go

   Statically typed, compiled language for simple and reliable software

   2 users
10. #10
    

    Swift

    Powerful and intuitive language for Apple platforms

    2 users
11. #11
    

    Nuxt

    Full-stack framework for Vue.js applications

    2 users
12. #12
    

    FastAPI

    Modern Python web framework for building APIs

    2 users
13. #13
    

    Node.js

    JavaScript runtime built on Chrome's V8 engine

    2 users
14. #14
    

    Bun

    Fast all-in-one JavaScript runtime and toolkit

    2 users
15. #15
    

    Hono

    Ultrafast web framework for the edge, runs everywhere

    2 users
16. #16
    

    JavaScript

    The language of the web, and the survey's most used language every year

    2 users
17. #17
    

    C++

    Systems language with zero-cost abstractions

    2 users
18. #18
    

    Objective-C

    Apple's pre-Swift language for macOS and iOS

    2 users
19. #19
    

    Elixir

    Dynamic, functional language for scalable applications on the BEAM

    1 user
20. #20
    

    C#

    Modern object-oriented language for .NET platform

    1 user
21. #21
    

    PHP

    Server-side scripting language for web development

    1 user
22. #22
    

    Scala

    Language combining object-oriented and functional programming

    1 user
23. #23
    

    Clojure

    Dynamic functional Lisp dialect on the JVM

    1 user
24. #24
    

    Dart

    Client-optimized language for fast apps on any platform

    1 user
25. #25
    

    SvelteKit

    Full-stack framework built on Svelte

    1 user
26. #26
    

    Astro

    Web framework for content-driven websites with islands architecture

    1 user
27. #27
    

    Ruby on Rails

    Full-stack web framework following convention over configuration

    1 user
28. #28
    

    Laravel

    PHP web framework with expressive, elegant syntax

    1 user
29. #29
    

    Flutter

    Google's UI toolkit for cross-platform native apps

    1 user
30. #30
    

    React Native

    Build native mobile apps using React and JavaScript

    1 user
31. #31
    

    HTMX

    Access AJAX, CSS transitions, and more directly in HTML

    1 user
32. #32
    

    Solid.js

    Reactive JavaScript library for building user interfaces

    1 user
33. #33
    

    Perl

    Text-processing language and the original glue of the web

    1 user
34. #34
    

    Julia

    High-performance language for technical computing

    1 user
35. #35
    

    ASP.NET

    Microsoft's web framework for .NET

    1 user
36. #36
    

    Blazor

    Web UI framework running C# in the browser

    1 user
37. #37
    

    Backbone.js

    Minimal MVC library that started the front-end framework era

    1 user
38. #38
    

    Meteor

    Full-stack JavaScript platform with real-time data out of the box

    1 user
39. #39
    

    GraphQL

    Query language and runtime for APIs

    1 user
40. #40
    

    Flask

    Lightweight Python web framework

    1 user
41. #41
    

    Symfony

    PHP framework and component library

    1 user
42. #42
    

    Qt

    Cross-platform C++ framework for native GUIs

    1 user
43. #43
    

    Unreal Engine

    High-fidelity real-time engine from Epic Games

    1 user
44. #44
    

    pandas

    Python data analysis and dataframe library

    1 user
45. #45
    

    NumPy

    Numerical array library at the base of Python's data stack

    1 user
46. #46
    

    PyTorch

    Machine learning framework with eager execution

    1 user
47. #47
    

    Uvicorn

    ASGI web server for running Python web applications with high performance.

    1 user
48. #48
    

    Ruby

    Dynamic language designed for simplicity and productivity

    0 users
49. #49
    

    Kotlin

    Modern, concise language for JVM and Android development

    0 users
50. #50
    

    Zig

    General-purpose systems language for robust software

    0 users

Rising this month

• Django 3 added in the last 30 days, 100% of its 3 users
• Python 4 added in the last 30 days, 80% of its 5 users
• Storybook 3 added in the last 30 days, 75% of its 4 users
• Rust 2 added in the last 30 days, 67% of its 3 users
• TypeScript 2 added in the last 30 days, 40% of its 5 users
• Next.js 2 added in the last 30 days, 40% of its 5 users
• Tailwind CSS 2 added in the last 30 days, 40% of its 5 users
• React 1 added in the last 30 days, 25% of its 4 users

Often paired with

• iTerm23
• Visual Studio Code3
• Arc3
• JetBrains PyCharm3
• Vercel3
• pnpm2
• Docker3
• Figma3
• Bun2
• Notion2

Moves in Languages & Frameworks

Fewer e2e tests means faster feedback on what actually broke

by Ruby SandovalLanguages & Frameworks

I used to write end to end tests for everything. Click this button, fill that form, check the result. It felt safe but every test run took forever and when something broke, all I got was a screenshot showing me a blank form or a missing element. Then I'd have to dig through logs to find which function actually failed. The shift was simple: keep the e2e tests only for the flows that would genuinely tank the business if they stopped working. For me that's user signup, payment processing, and core search. Everything else moved down to integration tests with Vitest where I test the actual functions and API endpoints directly. Now my test suite runs in under a minute instead of ten. When a test fails, Vitest tells me exactly which function broke and why, not just that something on the page is wrong. I can verify a complex checkout flow with an integration test that sets up the database, calls the controller, and checks the response in about thirty lines. The honest caveat is that this approach assumes you have good logging and error handling already in place. If your app swallows errors or logs them poorly, you'll miss bugs that e2e tests would have caught. I also still need the handful of e2e tests because screenshots do catch visual regressions and weird browser quirks that integration tests miss entirely.

75

Shrinking Docker images with multi-stage builds

by Elif YilmazLanguages & Frameworks

Before I adopted multi-stage builds, my Go service images were bloated. I'd compile everything inside the container, and then ship the entire build layer to production. The image sat around 800 megabytes because it contained the Go toolchain, git, and every build dependency. That meant every deployment pulled that extra weight, and every running container exposed toolchain binaries that had no business being in production. I restructured my Dockerfile to build in one stage and copy only the final binary into a fresh stage. The first stage does all the compilation work with all the heavy dependencies available. Then I use a `FROM scratch` or `FROM alpine:latest` for the final stage, and I `COPY --from=builder /app/service /service`. The resulting image drops to about 30 megabytes for a typical CLI tool or microservice. Here's the concrete shift: my build stage runs `RUN go build -o /app/service .` with the full Go installation present, but the runtime stage starts from scratch and only contains that single statically-compiled binary. No source code, no build cache, no compiler. The attack surface shrinks because there is literally nothing left to exploit except the binary itself. The caveat is that this approach works cleanly for statically-compiled binaries, which Go excels at, but falls apart if you need runtime dependencies or configuration files. If your service needs shared libraries or certificate bundles, you have to explicitly copy those into the final stage too, which adds back some size and complexity. It is not a universal solution for all container workflows. ```docker FROM golang:1.25-alpine AS builder WORKDIR /src COPY go.mod go.sum ./ RUN go mod download COPY . . RUN CGO_ENABLED=0 go build -o /bin/api ./cmd/api FROM alpine:3.24 RUN apk add --no-cache ca-certificates COPY --from=builder /bin/api /bin/api ENTRYPOINT ["/bin/api"] ```

64

Adopted Tailwind CSS for all new projects

by Sergei GordeichukLanguages & Frameworksbackdated

Utility-first CSS has been a game changer for our team's velocity. Inspired by @sarah_chen

63

Adoption history