#DevExp
LightNews LightNews
lbroudoux.bsky.social
🥳 So glad to share that my #KubeCon NA talk has been picked this year! We’ll dive into @daprdev.bsky.social and @microcks.io combo for great DevExp.

See you in Atlanta! 👋
July 30, 2025 at 4:59 PM
eseidel.com
I'm considering writing my own Redux, since I think we could have a much cleaner devexp that I've seen from the ones on pub. Not sure yet if I will though. 🤔
December 3, 2024 at 8:49 PM
kheddache.me
Ready for Spring I/O 2026 🚀

Excited to dive into the latest in tech, connect with brilliant minds, and bring back fresh ideas. Let’s go! 🌱💡

#SpringIO #TechConference #DevExp
April 14, 2026 at 7:09 AM
dcvz.io
New godot-bevy release! 🚀 0.9.0

Some nice things in this one! A new plugin, performance boosts, new APIs and some devexp goodies. We've moved to using Bevy transforms meaning you can now make use of bevy physics plugins (Avian) ✨

Full changelog on Github 🎁

#bevyengine #godotengine #rustlang
Release v0.9.0 · bytemeadow/godot-bevy
Summary This release brings performance boosts, new APIs, and improved developer tools for smoother Godot-Bevy integration. It also adds a new plugin, enhanced transform syncing, and expanded utili...
github.com
August 12, 2025 at 8:06 PM
lbroudoux.bsky.social
Wow 🤩, I'm so happy to see this happening! Thanks to the @amadeusitgroup.bsky.social team for the trust and for your contribution to make @microcks.io thrive, and bring a better #DevExp with @quarkus.io 💪
microcks.io Microcks @microcks.io · Nov 20
✈️ Welcoming Amadeus as officially listed on Microcks' public adopter list!

Amadeus leverages Microcks to strengthen its shift-left strategy for mocking & contract testing. Among their use cases are using Microcks to mock OIDC, helping enforce and automate zero-trust policies...
November 20, 2025 at 3:30 PM
salaboy.com
A long overdue blog post about our new endeavour with @thomasvitale.com Developer Experience on Kubernetes www.salaboy.com/2025/07/26/d... #kubernetes #book #devexp #CloudNative
Developer Experience on Kubernetes
In November 2024, Thomas Vitale (author of Cloud Native Spring in Action, with Kubernetes) and I signed a contract with Manning Publishing to co-author a book on Developer Experience on Kubernetes.
www.salaboy.com
July 26, 2025 at 9:37 AM
nerder.bsky.social
Hey everyone,

Can you please point me to the smartest engineer you know? I'd love to chat about how to deal with #techdebt and #DevExp in early stage startups!
June 24, 2025 at 9:07 PM
jonathanberi.com
Playing around with @canonicalltd.bsky.social Multipass this weekend, should have tried it sooner. Great devexp, especially on macOS.
July 26, 2025 at 5:55 PM
lbroudoux.bsky.social
@springio.net here I am! Ready for 2 days of knowledge sharing with the spring community 🙌

Say hi if you’re around and don’t miss our workshop with @salaboy.com this afternoon! Exciting stuff around developing and testing AI and cloud native apps with enhanced #DevExp 👩🏻‍💻
April 14, 2026 at 7:09 AM
s0-and-s0.bsky.social
"This person" likely never cried so hard, nor so long, as when they were ghosted by y'all!

... But we can hope some solace may be had from the good news of your team switching to the superior DevExp of battling TypeScript configuration and output issues ;-)
December 24, 2024 at 5:15 PM
gridlockbrained.gay
interested in a referral? we've got:
- okayish pay
- great work/life balance
- very corporate but in a chill way
- stuff you make doesn't make the world worse
- (although the company as a whole certainly does)
- people actually care about and are encouraged to improve both product & devexp
October 31, 2023 at 9:45 PM
s0-and-s0.bsky.social
NodeJS has a built-in argument parser

Wrapping it with something that can handle type/value mutation is reasonably trivial

And cluing-in TypeScript to mutations makes development a little less annoying, and a little less error prone too :-]

#DevExp #NodeJS #TypeScript
```typescript /** * @file NodeJS builtin argument parsing example with TypeScript enhanced callbacks * @author S0AndS0.eth * @license This is your problem now (-; */ import type { ParseArgsConfig } from "node:util"; import { parseArgs } from "node:util"; type Apply_Callbacks< T extends ParseArgsConfig, Values = ReturnType<typeof parseArgs<T>>["values"], Options = T["options"], > = { [Key in keyof Values]: Options[Key]["callback"] extends Function ? ReturnType<Options[Key]["callback"]> : Values[Key]; }; function parseArguments<T extends ParseArgsConfig>(config?: T) { const result = parseArgs(config); result.values = Object.entries(result.values).reduce( (accumulator, [key, value], _index, array) => { const callback = config?.options[key].callback; if (callback) { accumulator[key] = callback({ value, values: array }); } else { accumulator[key] = value; } return accumulator; }, {} as Apply_Callbacks<T> ); return result as Omit<ReturnType<typeof parseArgs<T>>, "values"> & { values: Apply_Callbacks<T>; }; } const options = { verbose: { type: "boolean", short: "v", description: "Output additional information during execution.", }, "as-number": { type: "string", description: "Throws error if given non-number during CLI argument parsing/conversion.", callback: ({ value }: { value: string }) => { const result = Number(value); if (Number.isNaN(result)) { throw new Error("Not a number given to: --as-number <value>"); } return result; }, }, } as const; const { values } = parseArguments({ options }); /* Should now resolve to; number | undefined */ type Test_as_number = (typeof values)["as-number"]; /* Should now resolve to; boolean | undefined */ type Test_verbose = (typeof values)["verbose"]; ```
September 17, 2026 at 12:45 AM
gon.cat
new 16' mbpro with matte screen is heavy but the extra pixels are enough for a good devexp when I'm away from my desk and external monitor, so very happy with the size change.
January 17, 2025 at 10:33 AM
s0-and-s0.bsky.social
> "React makes it easy to maintain big projects"

Really, okay, `useQuery` wraps `tanstack_useQuery` which wraps what ever else _needs_ another layer of abstraction just to get to a `fetch` while simultaneously breaking the whole `async`/`await` DevExp gains?!
February 26, 2025 at 5:06 AM
s0-and-s0.bsky.social
One of the definitions I use to figure out if something's Art is if I feel something from it

... I feel things when looking at this TypeScript

#backend #devexp #frontend #typescript #webdev
```typescript /** * Attributions; * - https://code.lol/post/programming/higher-kinded-types/ */ interface HKT { _T: unknown; result: unknown; } type Apply<F extends HKT, T> = (F & { _T: T })['result']; interface Prepend<T = 'PREPEND '> extends HKT { result: `${T}${this['_T']}`; } interface Append<T = ' APPEND'> extends HKT { result: `${this['_T']}${T}`; } interface Sandwich<L, R> extends HKT { result: `${L}${this['_T']}${R}`; } const value = 'some-thang' as const; type Value = typeof value; type Test_Prepend = Apply<Prepend, Value>; type Test_Append = Apply<Append<' woot?'>, Value>; type Test_Sandwich = Apply<Sandwich<'Left ', ' Right'>, Value>; ```
September 9, 2026 at 7:49 PM
sgoguen.bsky.social
👆This. Dafny is my favorite example of a language that uses SMT under the hood for model checking. Great DevExp!

What’s cooler is you can use the same toolkit (Boogie) if you had a language you wanted to verify.

Here’s a small example verifier:

github.com/boogie-org/f...
April 14, 2025 at 12:26 AM
s0-and-s0.bsky.social
Likely there are good reasons why this ain't default behavior, however, in this niche use-case I believe type/tab-hints are worth the computational performance hit to reduce cognitive load

#Backend #Frontend #TypeScript #devexp #webdev
`````typescript type ReplaceAll< S extends string, From extends string, To extends string, > = S extends `${infer Head}${From}${infer Tail}` ? `${Head}${To}${ReplaceAll<Tail, From, To>}` : S; /** * What will be given to; `new RegExp` */ type Expression_String<T> = `(?<=(<${T}>))(\n.*)*(?=(</${T}>))`; /** * What to expect from; `(new RegExp(...)).toString()` */ type Expression_toString<T> = `/${ReplaceAll< ReplaceAll< Expression_String<T>, '\n', '\\n'>, '/', '\\/' >}/`; /** * Put together some type-hint abominations */ type Expression_Entries<Type> = { [Key in keyof Type]: RegExp & { toString: () => Expression_toString<Type[Key]>; }; }; const xml_tags = { some_thang: "some-thang", other_tag: "other-tag", } as const; export type XML_Expressions = Expression_Entries<typeof xml_tags>; export const xml_expressions = Object.entries(xml_tags).reduce( (accumulator, [key, value]) => { try { const expression_string = `(?<=(<${value}>))(\n.*)*(?=(</${value}>))`; accumulator[key] = new RegExp(expression_string); } catch (error) { console.error({ key, value, error }); throw error; } return accumulator; }, {} as XML_Expressions ); /** * LSP now will show something like; * * ```typescript * (property) toString: () => "/(?<=(<other-tag>))(\\n.*)*(?=(<\\/other-tag>))/" * ``` */ xml_expressions.other_tag.toString() `````
September 8, 2026 at 5:35 PM
s0-and-s0.bsky.social
So after much fiddling about, and help from another dev, it seems this is the best that can be done in pure TypeScript to expose RegExp constructor(s) and flag(s)

Not happy that it be incomplete, but am satisfied enough that it'll cover most normal use-cases

#devexp #regexp #typescript #webdev
````typescript /** * Thanks to @GucciMAANG for showing `\d` and others are treated as `d` */ export type Escape_Entries = { '\n': '\\n'; '\r': '\\r'; '/': '\\/'; /* WARNING: Following auto-expand when input, but no easy way to detect here */ // '\b': '\u0008'; // '\f': '\u000c'; // '\v': '\u000b'; /* WARNING: Following expect two to four more characters, and no easy way to detect here */ // '\u': '\u0000'; // '\x': '\u00'; }; /* When uncommented resolves to; "\b \f \v \\u \\x" */ // type Test = Escape_All<'\b \f \v \u \x'>; export type Maybe_Escape_Character<T extends string> = T extends keyof Escape_Entries ? Escape_Entries[T] : T; export type Escape_All<S extends string> = S extends `${infer Head}${infer Tail}` ? `${Maybe_Escape_Character<Head>}${Escape_All<Tail>}` : S; export type Format_Expression<Type extends string> = `((\\b|\\s)(${Type})(\\b|\\s))`; export type RegExp_With_Hints< Type extends string, Flags extends string = '', _Formatted = Format_Expression<Escape_All<Type>>, > = RegExp & { source: _Formatted; toString(): `/${_Formatted}/${Flags}`; }; export type Expression_Entries< Type extends Record<string, string>, Flags extends string = '', > = { [Key in keyof Type]: RegExp_With_Hints<Type[Key], Flags>; }; const constructors = { some_thang_simple: 'some\\s+thang\\s+simple', other_thang: 'woot\nnew\rlines?', } as const; const flags = 'gi' as const; export const expressions = Object.entries(constructors).reduce((accumulator, [key, value]) => { try { const expression = `((\\b|\\s)(${value})(\\b|\\s))`; accumulator[key] = new RegExp(expression, flags); } catch (error) { console.error({ key, value, error }); throw error; } return accumulator; }, {} as Expression_Entries<typeof constructors, typeof flags>) as const; /* Is; "((\\b|\\s)(woot\\nnew\\rlines?)(\\b|\\s))" */ // expressions.other_thang.source /* Is; "/((\\b|\\s)(some\\s+thang\\s+simple)(\\b|\\s))/gi" */ // expressions.some_thang_simple.toString() ```
September 9, 2026 at 11:44 PM
geeknews.mercur.ing
**AI라는 소행성이 강타한 프론트엔드 웹 개발**
- AI 에이전트가 숙련자도 어려워하던 **브라우저 성능 분석** 까지 수행하는 가운데, 프런트엔드 지식과 교육에 투자할 유인이 약해지고 주요 교육자들도 활동을 중단하거나 축소하고 있음
- 프론트엔드는 데이터베이스 마이그레이션 같은 백엔드 작업보다 일시적이고 교체하기 쉬워 에이전트에 맡길 위험이 상대적으로 낮지만, **접근성 훼손** 이나 무한 루프 같은 피해는 여전히 가능함
- 학습 데이터에 풍부한 React를 에이전트가 더 잘 다루면서 **개발자 경험(DevExp)** […]
Original post on mercur.ing
mercur.ing
September 5, 2026 at 12:52 AM
hackernewsbot.bsky.social
Nango (YC W23) is hiring across eng, product and GTM (SF and remote) | Discussion
Careers | Nango
From DevExp to high scale to API fragmentation, we work on hard problems.
nango.dev
September 2, 2026 at 9:40 PM
andresalmiray.com
I kid you not, developer experience is their least of priorities no matter what they say.

Speed first, devexp last. That’s been the driving force for years.

</rant>
August 2, 2025 at 12:50 PM
hackernewsbot.bsky.social
Nango (YC W23, dev infra) is hiring staff back end engineers | Discussion
Careers | Nango
From DevExp to high scale to API fragmentation, we work on hard problems.
nango.dev
June 5, 2026 at 12:40 PM
news.karthihegde.dev
Nango (YC W23, dev infra) is hiring staff back end engineers
Discussion | hackernews | Author: bastienbeurier
Nango (YC W23, dev infra) is hiring staff back end engineers
From DevExp to high scale to API fragmentation, we work on hard problems.
nango.dev
June 5, 2026 at 12:06 PM