What is Reddit's opinion of Excalidraw?

From 3.5 billion Reddit comments

My player recently survived the Pillar of Autumn and hell-jumped feet-first onto Halo! That's where we ended the session and I decided to prep the broad strokes of the daring expedition to Alpha Base as a point crawl (if you're curious, I used Excalidraw).

When the countup(0) call returns [], what it returns that to is the countup(1) call. That then pushes 1 and returns [1] to the countup(2) call which pushes 2 and returns [1, 2] to the countup(3) call and so forth. Each call to the function is still there until its countup(n - 1) call returns something, then it pushes a number into the array and returns.

So what makes this work is the call stack. You can imagine a stack of function calls. The top one is currently executing. If it calls another function then that call gets added on top of it. When a call returns, it gets removed from the top. I once drew this picture for a very similar function: https://excalidraw.com/#json=4650498288254976,WlhIuGzRK0OSPRyBpnfylg

This topic comes up regularly. There are a few explanations linked here: https://www.reddit.com/r/learnjavascript/comments/ovflzm/recursion_in_javascript/

I agree with /u/YouCanAsk, to me this piece is in two parts (or voices if you prefer), one that is played by the LH and one by the RH. So, if you want to notate two separate parts in music you either write them on different staffs, one above the other of you write them on the same staff with something to differentiate them - e.g. the direction of the note stems.

I would write it something like this (apologies for the terrible drawing): https://excalidraw.com/#json=5114526181621760,rzc5lTTHVAZixYkIYOGp0g

I haven't seen any books other than Starer that are specifically on the topic. I would be interested if you find anything better.

(Edit to add: oops - I forgot the ties in the LH in my drawing, but hopefully you get the idea)

I'm really glad you think so! Thanks a lot.

Originally, I was under the impression that the rendering was something proprietary to Excalidraw, until I randomly happened upon this tweet. As soon as I saw that it was open source, I just had to get it into React Native. I remember so many times over the past couple of years where I would have loved to have had some hand-drawn effects, so better late than never!

Honestly, the real magic behind the integration is that Rough.js was designed extremely well.

I thought it would have been much harder, and require a lot more cherry picking, because usually libraries like this are very tightly coupled to the DOM.

But, we were lucky. Rough.js exposes an extremely useful class called RoughGenerator which is pure business logic, a high level interface, and just returns SVG parameters which are directly compatible react-native-svg. I believe this has come about because the original library offers a way to target either the DOM directly, or an svg node. I think this requirement introduced the perfect level of abstraction for us to hook into. :)

I've had the idea for this meme for years, finally got around to making it, don't know how to properly share it, feel free to copy it and share it around: https://excalidraw.com/#json=FlbOmMC3t87cNqMRjtZFt,z9RCkZqbjF5_cZAD00qWiQ

My process is to first walk around, I need to move to think deeply, then I usually talk to my colleague, or when I'm alone to my rubber duck or to myself, don't judge. Just play around with thoughts.

When the initial thoughts begin to gain form, I start writing them down immediately. Typically on a piece of paper or a markdown file. I also start drawing. Not a strict formula like UML. I just draw freely on a piece of paper, boxes and arrows, small lists, emphasis and so on.

After those first drafts I start typing things into a project management application or a nicely formatted markdown file. The drawings initially stayed on paper but now they go here.

Then I operationalise into small tasks and steps. Write that down.

Then I either go and do some online research or just start typing code and create a fast feedback loop (REPL / Unit tests / prototype script etc.)

You should look into personal knowledge management apps. This is mostly something you'll see used for academic research but it is the best notetaking solution I've found that I'm actually sticking to after trying out dozens of apps on PC and my phone.

I use Obsidian (You can check out r/ObsidianMD) which has a Windows app and is available on Android and iOS. You do need a Premium subscription for Sync but there are also other ways to set it up.

The notes on this app are markdown files so you can always export them to another platform with no trouble.

I love that you can have subheadings that collapse, you can interlink notes (including subheadings within a note) and add tags. You can have your typical folder structure too. There is plenty of customization available with plugins. You can make it do as little or as much as you want to.

I use Zotero to save webpages and take notes which are then added into Obsidian. There's an in-depth tutorial here. I like that it saves a copy of the page if possible so even if the website goes down, you'll have it with you.

It doesn't have digital whiteboards natively but you can get a plugin that integrates Excalidraw which serves the same purpose.

You can also use plugins for using it as a day planner, having all to-do lists in one place, a Pomodoro timer, creating mindmaps, and a lot more.

I think day 8 this year was my favourite puzzle ever, so I made this little explanation while messing around with Excalidraw

Hey, thanks for answering!

I think it should be installed in this way (it is a drawing): https://excalidraw.com/#json=CKG4wxnj-NxTkAkpzO30Q,7MqcNWSwKRIXg7W5K9mWBg

Image link: https://imgur.com/a/77VxboH

The fans would have the logo/sticker pointing to the outside of the case, so they would take air inside.

What do you think?

https://excalidraw.com/

Excalidraw is a free online drawing tool that has a hand drawn look which is nice and helps you not worry about the details.

Im also a fan of flowcharting user flows. Which is different from drawing screens. The flow a user goes through may include things outside your app, like manually fixing/verifying something, so it can help you to solve the higher level problem of giving your user value instead of just focusing on your app. Eg using miro, or a whiteboard, or excalidraw (disclosure: Im making a flowcharting tool).

https://excalidraw.com/#json=0CRB2ko0M4_7T_UAipyBe,2n5BBgndfBMVNCGWm234Sw

At some point I just looked at input and tried to understand what it does. Figured out a set of simple rules between digits and just wrote down smallest/largest.

I highly recommend https://excalidraw.com you can export your images (with scenes to be able to import them later if you have to update them), in notion you can insert them as an image.

So your object graph looks like this: https://excalidraw.com/#json=6135552583663616,bxy198eGbiRXq7vdrOoTwQ

I couldn't tell by your description if you want the end result of "reallocating 4 to 2" to be the first image or the second image:

First possibility (get rid of 4, make 4th pointer point to 2 itself): https://excalidraw.com/#json=4998925157138432,TI69fEbwNJjmtjgMP8z4fw

Second possibility (add 2's items to 4): https://excalidraw.com/#json=6028642693939200,8zxJ8MfYwXIV9yFq_GeSMw

Which of these do you want?

If you want the first, you can just do my_vecs[3] = my_vecs[1];.

If you want the second, you want something like

for (auto string_from_2 : my_vecs[1].data) my_vecs[3].push_back(string_from_2);

set up a conceptual overview on an excalidraw session, you're more than welcome to give it a look over. Can look at getting a repo set up this week if that's something you think the community would find useful.

Happy Monday.

> My question is, can the EightGrader object and it's prototype property EighthGrader.prototype both have their own [[prototype]]?

EighthGrader is a function, so it already has a [[prototype]], namely Function.prototype. That is why you can use things like EighthGrader.call(something) or EighthGrader.name if you want to. So the constructor function has its own prototype chain but that chain is irrelevant to the prototype chain of the instances that you create with new EighthGrader().

If the engine is currently looking at EighthGrader.prototype then all it sees is an object. It doesn't even have a reference back to EighthGrader and theoretically many constructor functions could share the same prototype object. So it will look at EighthGrader.prototype.[[prototype]] and then EighthGrader.prototype.[[prototype]].[[prototype]] and so on.

Maybe this drawing helps: https://excalidraw.com/#json=5123123196198912,OrUvdCDq54aIovIAw3Syfw

Hi u/Samluke697

I'm not sure if you're familiar with David Parnas's paper On the Criteria To Be Used in Decomposing Systems into Modules. In case you aren't, I recommend you give it a read as it gives a good explanation of the idea. The Modular Structure of Complex Systems is another paper that you might find useful.

I mainly use this principle as a tool for giving flexibility to a software design. When designing a new module or a new system, I usually think about decisions I might want to change later. I then proceed to hide those volatile decisions in modules, preferably one module for each decision, and I make sure that no other module knows about the decisions made inside other modules. This approach means that whenever a volatile decision changes, I only have to change the code of the module that hides the decision. The rest of the system remains unchanged.

To give a concrete example, some months ago I contributed to an open-source whiteboard app called excalidraw. I added support for zoom to cursor. Before I started, the app already allowed zooming, but only to the center of the screen. This was a really hard change to make since 12 different parts of the system assumed zoom always happened on the center of the screen. This is an example of a design that didn't follow the information hiding principle since the decision of where the app zoomed to wasn't encapsulated in any module, but spread across the app.

Excalidraw is a handy online open-source whiteboard / drawing tool: https://excalidraw.com/
You can even collaborate, share the link and it has a dark mode (so it's a digital blackboard too :) ).

Under rule 4, I want to say that I'm the author of this post, but also a CNCF Ambassador and I see my community work as helping folks understand how to migrate workloads to the cloud.

There's a very specific blog post for Kubernetes towards the end, which I think you'll also enjoy, but this post was about keeping this high level - IT / CIO level.

Hope you enjoy the diagrams which I created with https://excalidraw.com/ - definitely check it out for your next blog post or design document.

What else have you tried for federating individual services, how did you find it? What were the limitations you faced?

Excalidraw A totally free Web Tool I use for all kind of sketches whenever I have to sketch something technical for papers or other schoolwork or also if I just want to visualize something. :)

Do you like Excalidraw? I do a lot, and I thought it would be nice to use it to create slideshows, so I created Excalidraw Slides. It embeds Excalidraws using the component they provide and adds a layer to let you create several slides.

It is very basic for now, and there are a lot of features that could be added. I only spent a few hours working on it and wanted to have some feedback before spending more time.

The source code is available on GitHub, and it’s very open to contributions 😉

If it's Hackerrank, they're probably using this feature: https://blog.hackerrank.com/virtual-whiteboarding-for-system-design-interviews/

They built the feature on top of Excalidraw, an open-source whiteboard tool.

You can play with the tool at https://excalidraw.com/ or get the source code off github: https://github.com/excalidraw/excalidraw

I usually did the wireframes like these, but currently in my company we use Rapid App Development and I don’t really have time to go into details even with wireframes. The dev team needs me to do quick sketches of functionalities and it needs to be fast. I found out about Excalidraw and it’s definitely the tool that I use the most now! ☺️🙈

> The function range of numbers with the parameters 1 and 5 is in the first line. startNum and endNum are not equal to each other in the second line so we move to the else statement in line 4. Now the variable numbers is declared which is I think should be the rangeOfNumbers(1, 4). This is because end number is 5 and 5 minus 1 is four.

All of that is correct.

> Then in line 6 number.push(end number); is written which is 4.

No, endNum is still 5. We didn't change its value. We just made another call to rangeOfNumbers where we passed 4.

There will be multiple calls to rangeOfNumbers happening at the same time. The first one, rangeOfNumber(1, 5), starts another call, rangeOfNumber(1, 4) and it has to wait for that one to do its whole thing and return an array, which it will then assign to numbers, add 5 at the end and return the result of that.

So to figure out what numbers will be at first, we have to ask ourselves what rangeOfNumber(1, 4) returns. So we have to go through this whole logic again but this time we pass 4 instead of 5. And figuring that out will involve figuring out what rangeOfNumber(1, 3) returns and so on.

I can't find a good picture for this so I had to make my own. https://excalidraw.com/#json=4650498288254976,WlhIuGzRK0OSPRyBpnfylg

Thanks! Indeed, storing encryption keys in fragments is not that common and may not be the wisest thing to do for most e2ee applications... However, when no user account is required and some temporary data needs to be shared easily between users without complex key management, this is a pretty nifty solution! I'm a big fan of Firefox Send and Excalidraw, both services using this very technique to share e2ee data between users.