loading...

What library/language/tool wowed you with its developer experience?

ben profile image Ben Halpern ・1 min read

What thing really raised the bar for your expectations of developer experience when you first went to use it?

Discussion

pic
Editor guide
 

Netlify. It was unbelievable how simple it was.

 

Same thing for Now.sh :thumbs-up:

 

Depending on how complex your API and CRUD are, Now.sh might be simpler and support more languages. But for SSG, it has to be Netlify this time.

 

I'll name a few. Ruby really did capture me in this way. Being able to type irb into a terminal and then type "hello".upcase and see HELLO right there was really refreshing and spoke to me. I've been writing Ruby ever since.

In my brief experimentation with Flutter, I was quite impressed by the attention to developer experience that the developers are going for with this environment. I haven't done any production-oriented work, but if I went back to Flutter the experience would be a big reason for it.

 

Also "did you mean ... ?", Gotchas, syntactic sugar and Active Record in general. Coming from the .Net world where we have to write getters and setters even for the simplest model to this magical world where you can just code a db and a few relationships and everything just magically works. I sometimes get imposter syndrome while writing Ruby / RoR because everything is so easy and I feel like anyone could write a website in a few days. Of course it's not true, but it goes to show how uncomfortably good Ruby makes me feel.

 

Coming from the .Net world where we have to write getters and setters even for the simplest model

Unclear when you last worked with .NET. T PropName { get; set; } is not really that difficult.

Never said it wasn't easy, just that you /have/ to. Even if it's small, my point is that it's redundant. In Ruby on Rails, you don't have to do that, it automatically generates most of the methods you need just by reading your database.

 

For most of my time, I was writing in Python.
I really loved it and was able to argue for Python for hours.
I thought would never prefer another language when I had a choice.

Well... I was wrong.
In current job, I met Ruby (or Rails, to be specific) for the first time.
It seemed nice, easy to learn after Python, had some nice features.
I didn't realize how much comfortable and elegant it is before I did some work on my hobby project in Python.
It's still good, but there were multiple moments when I thought "well, I could write this much nicely in Ruby, shame Python doesn't do this".

 

I agree, Ben. I have done some Flutter work and it was a pleasure to work with.

 

Angular (v9.1.0 as of writing) has been delightful to work with so far. It has an awesome CLI that really empowered me hit the ground running on my new personal site. I am also really keen on learning Ruby.

 

I always thought that Angular would be the hardest of the front-end frameworks to learn, but it was much friendlier than React.

 
 

Laravel, a PHP framework inspired by Ruby on Rails. The documentation is far, far far better than Symfony (and it saddens me because I'm french and I really wanted to support our french tech industry). But I'm forced to say that Laravel is a breeze to use (used it for two years). Eloquent really did make me love Laravel.

Elm has also caught my attention with its attention to super clear and explanatory error messages. It's like having a mentor 24/7, except it's free and it's a script. I don't know you, but I know no language or framework that tells you that:

Line 11, Column 13
The (//) operator is specifically for integer division:

11| test = 5 // 2.0
                ^^^
The right side of (//) must be an Int, but I am seeing a Float. I recommend
doing the conversion explicitly with one of these functions:

round 3.5     == 4
floor 3.5     == 3
ceiling 3.5   == 4
truncate 3.5  == 3

Note: Read <https://elm-lang.org/0.19.1/implicit-casts> to learn why Elm does
not implicitly convert Ints to Floats.
 

Programming Language should make developer life easier.

-It should be easy to learn.
-It should be maintainable.
-It should be easy to read, some languages have short syntax and its hard to find out were it starts and ends.
-It should have meaningful syntax and methods.

C# Meets all these points , I think its better than Java and other languages.

Tool should increase productivity:

-It should help locate files fast.
-It should help find Methods and Variables , References fast.
-It should make debugging easy.
-It should increase productivity.
-It should help build app using rapid development.
-It should make maintenance easier even in large enterprise projects.

Visual Studio and Visual Studio Code meets all these.

What you think ? 😄

 

The only downside of Visual Studio to me is all the magic going on in the background with csproj/sln/msbuild files. I also really like C#, especially w/ the dotnet cli.

 

I wish i can have that kind of enthusiasm with c#. 😂

 
 

For VSCode critiques, I cannot count how many times I have to reload (both the window and TS server). It can also hangs and sometimes slow.

 

I am really surprised no one mentioned VueJS. It’s simply awesome to work with.

From CLI create to deployment, you feel like they wanted you to focus on building your UI only rather than « the rest »

 

Ruby.

The idiomatic methods, the elegant syntax!
I’ve shed happy tears TWICE after looking at arguably the most elegant code I’ve ever seen in my life. And they were written in Ruby. 🙂

 

React Hooks. Thrilling experience with the functional programming approach, plus it takes away the pain of writing verbose class components. useEffect just saves me the mess in componentDidUpDate and code reusability makes things cleaner.

 

Getting back to front-end. after a long hiatus., I tried some frameworks out. Vue's documentation is exceptional. Vue CLI, and the Dev Tools Extensions in Chrome and FF have made the first steps smooth.

 

. . . I agree 💯 Ruby & Elm merit all the praise for their unique grammars and DeveloperX. Personally, what's reigned supreme (after 3yrs (to mere competency) of steep walling) is the Clojure/ClojureScript stack.

For concision's sake I'll share 2 reasonings why still Clojure most wows me...

  1. Unique Homoiconic syntax - Clojure, most evidently, is a LISP (a programming language consisting grammatically of lists). As a LISP, Clojure code is substantively identical to Clojure data. This is possible thanks to Prefix (Polish) Notation where valid expressions follow the order: (( <Functor> < & Args> ). In addition, Clojure uses unique enclosing characters for various data types [ ] <- vector, { } <- map, ( ) <- list, this adds readability and simplifies conventions.

  2. Genuine Metaprogramming - many languages incrementally added Reflection & Metaclass
    protocols/interfaces that allow programmatic changes to source code attributes during runtime( Python, Ruby, Haskell, etc...). LISPs like Clojure or Racket enjoy an abstract syntax tree modeled in source and evaluation, allowing code generation with macros that relates to evaluation 1-to-1. I think features like this need to be a core aspect of a language spec, not an after thought like most other infix-notation languages.

 

I really want to like Elm but I am very disappointed where the creator has chosen to take the language. It really bothers me how restrictive they have made the package system and how only he and a select few are given the freedom to work with native code.

I understand his ideology, but at the same time, it seems pretty arrogant to not trust your user base to code things correctly. The reality is that you are going to have to interop with JavaScript at some point, because the entire world doesn't run on Elm, and all he's accomplished is making that experience even more painful.

 

React and react hooks. Before react, I didn't have any much of framework experience so I was like can this be done easier!!! I use to write wrappers to manipulate DOM and was clunky to maintain. React gave me a great dev experience for the smooth transition.

 

Kotlin.

It integrates with Java so incredibly seamlessly, and coming out of JetBrains, its IDE support is good with lots of helpful inspections and automatic Java->Kotlin conversion.

I also love how the Kotlin team always tries to provide solutions to the general problem instead of a bunch of smaller nuanced features and keywords. An example is a complete coroutines framework instead of singular mechanisms for "async/await" and "generator functions", which can both be implemented on top of the coroutines framework.

The IDE performance could certainly be better, and multiplatform (js, iOS, native) tooling is a bit confusing right now, but it's still a relatively early project and the future is looking very promising for Kotlin.

 

It may sound counterintuitive, but Java as a language because by form and by convention it forces you to be verbose, that is explicit, rather than terse. And the Java ecosystem, which really has no equal in maturity and reliability.

 

IntelliJ. Solving most of my problems with [options+return] is a game-changer, plus refactoring options, fuzzy search etc., out of the box.

Also, Python. Writing readable, easy to understand code is very natural with it. And Django. Ease of setup, great documentation and extendability has won me over in a couple of first minutes.

 

I continue to be impressed with Hugo.

Updates are released consistently and frequently. The ease and speed of getting a site built from scratch really impressed me. A number of the major releases have been super beneficial for my own projects, and the speed of building the site continues to improve, somehow. The active discussion board can get your questions answered quickly and there's a huge list of very useful functions.

 

Can totally agree with that. After trying to get my head around Jekyll I knew I need something better. The first steps were super easy with Hugo. Also, while the structure is not the best, the documentation has many details and features covered. I rarely had to search on Stackoverflow for issues.

 

Elm because of error messages usefulness and no runtime exceptions guarantees.

 

I recently learned that you can get some exceptions if you screw up Regex, infinitely recurse, or incorrectly encode/decode JSON. There's a few more cases people have discovered as well, but I'm not that good at programming language trivia

 

I see. However even with these edge cases I would be really confident with the output. Cheers for mentioning those.

 

I'm shocked more seasoned JS developers would learn TypeScript over Elm, it's uniquely concise and consistent, enforcing a functional approach to programming.

 

Don't be shocked. Elm is great and I would much more prefer to use it instead of Typescript. However getting started with Typescript is so much easier and Javascript code can be migrated gradually towards it, it is better suited for projects that cannot be built from ground up.

 

Python as it has never failed to amaze me on the number of things you can do with it from data science, IoT to microservices.

 

Agree on that.

I have a newfound love for Ruby because of its elegance and beauty.
But Python is so amazingly multipurpose (which is mainly because of its big user base and great packages), it's extremely convenient to at least prototype new idea in Python.
Is it webapp? Is it script to rename all my movie files? Is it IoT idea (on Pi)? Scraper? Or looking into some data in Jupyter? Well, Python is a way to go!

 

This library
jmespath.org/
Have look at here to get the possibilities (For me, this link is cheat-sheet. I bookmarked and visit often.)
jmespath.org/tutorial.html

What it does ?
JMESPath is a query language for JSON. (As per official docs).

It's multi-language supported. Visit homepage to find links.

Previously, I used to loop/iterate through objects to find some id, attributes etc. from json.
For python, it's very easy json.loads....; jmespath.search('patter',object_list_dict_or_whatever_nested).
So, I can avoid many looping (I'm not sure about performance [I believe it's good, I guess it's linear access]. I mean, reduced amount of code (Lesser code mean better code).

 

I agree here. My only pain point with Rust right now is its editor experience. I have spotty responsiveness when working in vscode from the language server whether it resolves members correctly while authoring Rust programs. Experience may be better in IntelliJ, but I don't have $90+/yr to privately buy a license.

 

Have you tried Sublime Text? Curious how Rust support has been.

Sublime marks RLS support as "experimental," so I'm a little hesitant to pay for a maybe.

 

I find rust-analyzer work very well with vscode. You can try it.

 

Golang and the built-in testing functionalities! For other languages you often need to include a testing framework in your code to run your tests, but this is built-in into the language and I really appreciate that. Also, the tests are lightning fast compared to what I'm used to in JavaScript and PHP. It has made me trust the code I write more.

 

Elm taught me that code can be elegant and explicit and that you don't need complex layers of abstraction/encapsulation to make things easier to deal with.

Then hyperapp showed me that you don't need a heavy and complex framework with half a dozen libraries to do state management to build powerful and easy to maintain web apps.

 

Svelte. Immediately clicked in my mind and has TypeScript support coming soon!

 

I'd say knex.js was mine. I was so used to using ORMS and/or Raw Queries and handling migrations manually in every project, it was a pain. I liked the whole RoR experience of well managed migrations in the actual code base and the first time I got knex setup for a project , I got hooked with the speed boost and have been using it since.

Another one would be Colicious, It was made by this dude name kabir and I linked my version of it but the idea of existence of such simple tools intrigued me.

 

Qt framework. Coming from Cocoa, WinForm and Gtk, QT API felt terrific. Their documentation is comprehensive, and API is predictable once you get a bit used to it.

LeftletJS compared to Google Maps is a pleasure to work with.

ImprovMX for creating email aliases for the domain name.

 

React, moving from vanilla Javascript to react was amazing. Coding in vanilla js was agonizing and almost made me want to give up, whereas react made everything feel compartmentalized in a way that made sense to me.

 
  • Flutter
    flutter.dev/
    For building really simple and fast mobile apps

  • release-it
    github.com/release-it/release-it
    For enhancing deployment and releases

  • Table Plus
    tableplus.com/
    One of the best database tool. Used to use mysql workbench but workbench doesn't support ssh keys with encryption.

 

Delphi/Object Pascal: first OO language I had learned. It seemed magic. Most of my education around object orientations comes from this language.

C#: the developer experience was much better than Delphi's or Java's. Still a huge fan of its designer (it was a period when I was very much into language design, trying all sorts of languages from Common Lisp to E).

Python: favorite general purpose language still to this day. I'm so happy for its surge of popularity in the last few years because when I started with Python 2.0 the community was much smaller 😭

Erlang: although I found the syntax weird at first (I had zero experience with declarative programming) writing concurrent programs that could talk through nodes (I used two Linux computers ahah) and restart themselves or notify a supervisor process in a few lines was amazing. Erlang also has the ability to deploy 2 versions of some code and have them coexist and that felt like magic to me. Instantly bought Joe Armstrong's book. I also played a bit with making Erlang talk to Python. Unfortunately I've never used it professionally and forgot most of it now 😭

 

I particularly like Kotlin. It can do everything Python/JavaScript can, plus more. But I have to agree it is more restrictive to write than TypeScript.

On a little shaky footing do I like TypeScript. I can even run a CLI script with ts-node, and I can always escape to JavaScript with any and // @ts-ignore. It also integrates well with the IDE, if you don't escape to JavaScript. Being JavaScript in nature, it feels patchy here and there. Still, I prefer to write server-side code and CLI scripts in TypeScript.

 

Vue. The documentation and the official set of accessory libraries with a great CLI. It has probably one of the best documentation. I started React recently, and I am still coming to terms with the fact I will have figure out every thing separately.

 

When I was working with Ruby on Rails, I remember you could use rails c, which would launch a ruby console configured with a direct access to your models and more. So I could do something like :

me = User.find_by_name("Nans")

(or something similar)
and access my user, enabling me to perform which ever action I wanted. It was great for prototyping !

This is the main thing I missed when starting NodeJS for the backend.

EDIT : as far as I remember, you could even do something like rails c --sandbox and perform anything you wanted; at the end of the session, it would rollback all the changes in your database.

 

Groovy - had stuff for which people like Kotlin
Scala - although so much wow and had more hardcore stuff than Groovy also quite heavy to load for playing with; while Groovy gives you dynamic like feeling to play with stuff this one is for serious stuff when you need it to work good and look nice

Apache Pulsar - I started using it recently, I mean multitenancy out of the box, docker image, JWT thought about, they also work on a nice feature called Apache Pulsar Manager... I mean everything you need in dev mode especially if you use kafkaesque.io helm chart then you have OAuth for message broker (experimental feature) and super easy setup for kubes and shifts

Apache Camel-K - write integration as file and just fire it up into k8s? although if you don't have some online good docker registry it could be not so wow when setting up with local k8s, as for minishift well it's write -> kamel run this.languare -> it runs; warrning still in RC as of time writting

IntelliJ but long time ago when it worked

 

I love kotlin. It has 4 characteristics that make me as developer more productive. Also kotlin has language design make our code more readable without performance overhead that awesome

 

Dart

I was so excited by it's ease of comprehension that I figured I'll probably switch from TypeScript to Dart for development. But Google let me down so... I'll see dart on my next mobile app project

 

I feel that GitLab exemplifies good dx.

I'm not an expert user by any means, but from what I've seen, it houses almost everything software teams would need for a full stack without requiring endless context-switching (thus saving significant development time and sparing focus in the long run). Not to mention the syntax themes, great 3rd party integrations, and more :)

 

Dart has been a joy to learn. I also really enjoy Elixir, and the little bit of Racket/Scheme I have been toying with recently has been a lot of fun. I'd like to eventually learn Clojure based on my LISP adventures.

 

Those who say Ruby is simple have never met Scheme.

 

100% Vue. In my honest opinion if your cli doesn't work as good as Vue's or if your documentation is not written as good as Vue's, then you haven't done your job. It made working with a JavaScript framework fun again. The framework just seems to be designed with the most important thing in mind: writing applications. Before I got into Vue, all the other frameworks made me feel like they were designed by people that no longer created applications and only made frameworks.

In terms of a platform/SDK, then 100% Stripe. Their documentation experience, plus the TONS of examples and articles to read always leaves me super happy to work with them. I really wish most platforms/SDKs would put that type of effort in their documentation/examples.

 

For tools, CMake changed my life. Building a project, deploying it, running tests... has been made so easy. I'm now putting CMakeLists everywhere, the only downside is their documentation which I find very unhelpful.

For editors, I would say Visual Studio Code: so many great shortcuts, extensions, themes (thanks god, my eyes can finally rest on a nice dark theme).

For languages, even if it has downsides, I'm still in love with C++. Metaprogramming is really cool, a lot of things to look at to optimize your program (the best part, otherwise I would have been coding in Scheme for their fabulous macros/metaprogramming for a long time).

 

Golang. I just don't get enough of it atm. All most all the other ecosystems I have worked with Javascript, Node, PHP, Ruby etc there is a bit of everything you need to get started. Things to worry about ie. Code style, where to put the files, which style to choose etc. Go just simplifies a lot of these minor things. Making it just easy to get started.

 
 

Typescript. I mean just wow! 🦄

 

Redux Saga, the middleware that turns anarchy into dictatorship in Redux. I would put this first...

As for languages Javascript never ceised to amaze me, every ES proposals, releases, new features, you name it...

Preferred library, React.

 

Rust. They had me at comments being compiled and running inline example code. Among all the other nice things the language has to offer, this one stood out as a wow factor big time.

 

Svelte JavaScript Framework!

 

Gohugo

It's so good.

 

Rust + Cargo. I am simply floored by the thought that the Rust team has put into the tooling.

 

Ruby - pure simplicity.
Enough said.

 

I think that I'll always be enamored by Python. The ability to pull powerful scripts together in just a few lines of code is really amazing to me.

 

I'd say Ruby in terms of a simple and expressive language.

I'd say Meteor as a small, but awesome way to develop web applications.

 

Zeit Now + NextJS. Specially now with the latest release, its b e a utiful. From start project to CI in no time.