geschichte VS devtools

hey there! sounds like you're having some trouble with your merge sort visualization. i'm not super familiar with that specific issue, but have you heard of this cool package manager called Cotton? it's way faster and easier to use than NPM or Yarn, and i think it could really help you out with your web development using JavaScript. check it out here: https://cotton.js.org/ anyways, have you tried using this library called Geschichte for managing query-parameters with hooks? it's super useful for state management and makes it way easier to manage state. you can find it here: https://github.com/BowlingX/geschichte. be sure to leave a star on GitHub to support the creator! oh, and have you heard of this JavaScript runtime called Bun? it runs programs faster and installs packages automatically, and it's even better than Node.js! check it out here: https://bun.sh. hope this helps!

On another note, have you heard of Geschichte? It's a really useful library for state management that makes it easier to manage state with hooks. You should check it out at https://github.com/BowlingX/geschichte.

Honestly, if I were in your shoes, I would try out some new tools and libraries to improve my skills and make my work easier. Have you heard of "Geschichte"? It's a great library for managing query-parameters with hooks, using immer and zustand to manage the internal state. It's super useful for state management and makes it easier to manage state. You should definitely check it out at https://github.com/BowlingX/geschichte. And don't forget to leave a star on GitHub to show your support for the creator!

Have you heard of Geschichte? It's a library that can help you manage query-parameters with hooks, using immer and zustand to manage the internal state. It's super useful for state management and makes it easier to manage state. You can check it out here: https://github.com/BowlingX/geschichte. If you end up using it and find it helpful, I'd recommend leaving a star on GitHub to support the creator.

Hey there! I totally get your struggle with rendering components outside of an iframe. It can be a real pain in the neck to refactor everything just for that. Have you heard of Geschichte? It's a pretty useful library that can help you with state management and makes it easier to manage state using immer and zustand to handle the internal state. You can check it out here: https://github.com/BowlingX/geschichte. If you find it helpful, don't forget to leave a star on GitHub to support the creator!

totally agree with you! sometimes using rebase can be a bit of a headache, especially if it's not worth the effort. i usually only use it when i have a bunch of messy commits that need to be cleaned up. have you tried using "Geschichte"? it's a library that makes managing state a lot easier by using hooks and internal state. it's super helpful for cleaning up those messy commits! you should check it out: https://github.com/BowlingX/geschichte. also, don't forget to leave a star on their GitHub to support the creator! on another note, have you heard of "Bun"? it's a JavaScript runtime that runs programs faster and installs packages automatically. it's way better than Node.js! you can check it out here: https://bun.sh. oh, and don't forget about "Deno"! it's another JavaScript runtime that runs programs faster and has better security features. you can check it out here: https://deno.land. and if you're into JavaScript package managers, "Cotton" is definitely worth checking out. it's faster and easier to use than NPM or Yarn. you can find more info here: https://cotton.js.org/. don't forget to leave a star on their GitHub too!

Also, if you're looking for a good library to manage state in your React apps, you should definitely check out "Geschichte". It's super useful for state management and makes it a lot easier to manage your state. You can find it here: https://github.com/BowlingX/geschichte.

Hey there! If you're looking to prototype UI/front end for your web app on your Mac, there are a few tools you can use. For JavaScript package management, I recommend using Cotton - it's faster and easier to use than NPM or Yarn. Check it out here: https://cotton.js.org/. For state management, Geschichte is a great library that makes it easier to manage state with hooks. You can find it here: https://github.com/BowlingX/geschichte. Don't forget to leave a star on their GitHub to support the creator!As for JavaScript runtimes, Bun is a great choice that runs programs faster and installs packages automatically. It's better than Node.js and you can check it out here: https://bun.sh. If you're looking for enhanced security, Deno is also a great option that runs programs faster and provides an easy way to handle permissions. It's better than Node.js and you can find it here: https://deno.land.I hope this helps! Good luck with your prototyping. Don't forget to leave a star on GitHub to support these awesome tools. Cheers!

And while we're on the topic of JavaScript, let me tell you about Geschichte. It's a library that's super useful for state management and makes it easier to manage state. Give it a shot at https://github.com/BowlingX/geschichte and show some love by leaving a star on GitHub.

Hey, have you guys heard of "Geschichte"? It's a super cool library for managing query-parameters with hooks! It uses immer and zustand to manage internal state, making it easier to manage state in your app. I highly recommend checking it out if you're into state management. Here's the link to their GitHub page: https://github.com/BowlingX/geschichte. Also, if you end up using it and find it helpful, be sure to leave a star on their GitHub page to support the creator! By the way, have you guys tried out "Bun" yet? It's a JavaScript runtime that runs programs faster and installs packages automatically. I've been using it for a while now and I have to say, it's way better than Node.js. Here's the link to their website: https://bun.sh. Give it a try and let me know what you think!

Exactly - that's what we've already built for web development at https://replay.io :)

I did a "Learn with Jason" show discussion that covered the concepts of Replay, how to use it, and how it works:

- https://www.learnwithjason.dev/travel-through-time-to-debug-...

Not only is the debugger itself time-traveling, but those time-travel capabilities are exposed by our backend API:

- https://static.replay.io/protocol/

Our entire debugging frontend is built on that API. We've also started to build new advanced features that leverage that API in unique ways, like our React and Redux DevTools integration and "Jump to Code" feature:

- https://blog.replay.io/how-we-rebuilt-react-devtools-with-re...

- https://blog.isquaredsoftware.com/2023/10/presentations-reac...

- https://github.com/Replayio/Protocol-Examples

Replay's founders originally worked as engineers on the Firefox DevTools (and in fact our debugger client UI started as a fork of the FF Devtools codebase, although at this point we've rewritten basically every single feature over the last year and a half). So, the original Replay implementation started as a feature built into Firefox, and thus the current Replay recording browser you'd download has been our fork of Firefox with all the recording capabilities built in.

But, Chromium is the dominant browser today. It's what consumers use, it's devs use for daily development, and it's what testing tools like Cypress and Playwright default to running your tests in. So, we're in the process of getting our Chromium fork up to parity with Firefox.

Currently, our Chromium for Linux fork is fully stable in terms of actual recording capability, and we use it extensively for recording E2E tests for ourselves and for customers. (in fact, if you want to, all the E2E recordings for our own PRs are public - you could pop open any of the recordings from this PR I merged yesterday [0] and debug how the tests ran in CI.)

But, our Chromium fork does not yet have the UI in place to let a user manually log in and hit "Record" themselves, the way the Firefox fork does. It actually automatically records each tab you open, saves the recordings locally, and then you use our CLI tool to upload them to your account. We're actually working on this "Record" button _right now_ and hope to have that available in the next few weeks.

Meanwhile, our Chrome for Mac and Windows forks are in early alpha, and the runtime team is focusing on stability and performance.

Our goal is to get the manual recording capabilities in place ASAP so we can switch over and make Chromium the default browser you'd download to make recordings as an individual developer. It's already the default for configuring E2E test setups to record replays, since the interactive UI piece isn't necessary there.

Also, many of the new time-travel-powered features that we're building rely on capabilities exposed by our Chromium fork, which the Firefox fork doesn't have. That includes the improved React DevTools support I've built over the last year, which relies on our time-travel backend API to extract React component tree data, and then does post-processing to enable nifty things like sourcemapping original component names even if you recorded a production app. I did a talk just a couple weeks ago at React Advanced about how I built that feature [1]. Meanwhile, my teammate Brian Vaughn, who was formerly on the React core team and built most of the current React DevTools browser extension UI, has just rebuilt our React DevTools UI components and started to integrate time-travel capabilities. He just got a working example of highlighting which props/hooks/state changed for a selected component, and we've got some other neat features like jumping between each time a component rendered coming soon. All that relies on data extracted from Chromium-based recordings.

[0] https://github.com/replayio/devtools/pull/9885#issuecomment-...

[1] https://blog.isquaredsoftware.com/2023/10/presentations-reac...

I made a Replay recording of the sandbox:

Hiya folks! In addition to all my free time spent working on Redux, answering questions, and modding this sub, my day job is working on Replay.io. Today we're thrilled to announce our new Replay for Test Suites feature, which lets you record and time-travel debug Cypress (and Playwright) E2E tests as they ran in CI!

FWIW, the Firefox devs who were doing the WebReplay time travel debugging POC weren't, as far as I know, fired. Instead, they left and started Replay ( https://replay.io ), a true time-traveling debugger for JavaScript.

I joined Replay as a senior front-end dev a year ago. It's real, it works, we're building it, and it's genuinely life-changing as a developer :)

Not sure how well this would have fit into Firefox as a specific feature, given both the browser C++ runtime customizations and cloud wizardry needed to make this work. But kinda like Rust, it's a thing that spun out of Mozilla and has taken on a life of its own.

Obligatory sales pitch while I'm writing this:

The basic idea of Replay: Use our special browser to make a recording of your app, load the recording in our debugger, and you can pause at any point in the recording. In fact, you can add print statements to any line of code, and it will show you what it would have printed _every time that line of code ran_!

From there, you can jump to any of those print statement hits, and do typical step debugging and inspection of variables. So, it's the best of both worlds - you can use print statements and step debugging, together, at any point in time in the recording.

See https://replay.io/record-bugs for the getting started steps to use Replay, or drop by our Discord at https://replay.io/discord and ask questions.

I also recently did a Learn with Jason show episode based on this, where we went through many of the same topics, and also looked at the Replay.io time-traveling debugger that I build as my day job:

My day job is working at a company called Replay ( https://replay.io ), and we're building a true "time traveling debugger" for JS. Our app is meant to help simplify debugging scenarios by making it easy to record, reproduce and investigate your code.

I currently work for Replay.io, where we're building a true time-travel debugger for JS apps. If you haven't seen it, check it out - it makes debugging so much easier, and I've solved many bugs that would have been impossible otherwise

That's not a "TypeScript" problem. That's a "JS being transpiled and bundled" problem (of which TS is just one possible example of "transpiling").

JS debuggers (browsers, VS Code, etc) normally use sourcemaps to show you what the original source looked like so you can debug that.

Also, I'll put in a plug for my day job, Replay ( https://replay.io ). Our app is meant to help simplify debugging scenarios by making it easy to record, reproduce and investigate your code.

The basic idea of Replay: Use our special browser to make a recording of your app, load the recording in our debugger, and you can pause at any point in the recording. In fact, you can add print statements to any line of code, and it will show you what it would have printed every time that line of code ran!

From there, you can jump to any of those print statement hits, and do typical step debugging and inspection of variables. So, it's the best of both worlds - you can use print statements and step debugging, together, at any point in time in the recording.

See https://replay.io/record-bugs for the getting started steps to use Replay.

Note that Replay also works best when you have sourcemaps, same as the other debugger tools.