I never really used Excalidraw until I discovered the Obsidian plugin. Now I have tons of markdown notes with embedded Excalidraw doodles. It's good stuff.
Skeuomorphism goes in the other extreme direction though. One doesn't need flat design or skeuomorphism. There's a nice balance of UI elements that sit in the middle. I think Windows 7 was probably a good example of just straight up boring buttons and controls.
I hate it too. I understand what people had against it though because Apple (led by Scott Forstall) took it wayyyy too far at one point. The notepad, the game center, it was a joke. It became its own objective.
I think the current bland flatness is a kneejerk reaction to that (kicked off by Jony Ive who was probably angered by Forstall's design).
Well we used to use "sketchy" looking mockups so that users would understand that this wasn't a finished, working interface. I guess that's out the window now.
Yes, was about to say the same, then saw your comment.
IIRC, Peldi, Balsamiq founder, had blogged about it at the time. I like it too. Also reminds me vaguely of the Comic Sans font, which was the rage even earlier.
Maybe someone here can help me remember. I had a PalmOS app that I loved, back in the day, and I can't remember what it was called. It was a shareware clock app, with hand-drawn time that animated from one numeral to the next. I used to use it as an alarm clock, in my Sony Clie dock, by my bed. Would love to see it again.
"I read this code and then reimplemented it from scratch in a different language" does not release you from licensing obligations. If that were the case then brb while I go reimplement unreal engine in rust.
You should consult a lawyer. It's one thing if it's a clean-room implementation but every IP attorney I have ever interacted with would disagree with you.
It doesn't take much for a court to consider something a derivative work.
You cannot copyright algorithms. Ergo, the expression of an algorithm in one language is not a copyright violation of an expression of the same algorithm in a different language.
Of course, there's a gray zone: what about a reimplementation in the same language, but with different variable names? Those cases are why we have courts.
But ... if you figure out how to solve Rathbone's conjecture[0] and reveal the source code for it in C++, my reimplementation of that in Rust or Lua does not constitute a derivative work.
One exception would be if you managed to patent some feature of the algorithm (RSA comes to mind, or frequency-based colors for drawing waveforms). That's a different story.
To be clear the origin of the derivative work is not the reimplementation of the algorithm but instead the fact that the copyrightable atom of work can be considered a variant with insufficient originality because you are familiar with the source material. If you were able to claim and prove ignorance of the source material then there is less of an argument to be made, but that's not what we're discussing, to be clear.
This looks nice and oddly nostalgic. One bit of feedback: each time I toggled the checkbox I expected the checkmark to look slightly different, as if it were being redrawn by hand each time. Adding some "noise" might be a neat feature for a version 2.0.
I personally like the look of this kind of thing enough I would want to use it for a real product, or maybe for the beta version of the product and then switch it up when official release.
If the product looks done then the feedback you will get assumes that it is done.
I made the mistake of using a nice looking header (it looked better than the existing ones that were used which were stretched gifs and I had a CSS gradient) while working on the innards of some JavaScript. While I was trying to get feedback on the "is this workflow the right sequence of pages? Are these the UI elements that need to be on the page for this functionality? For that matter, am I missing some functionality?" .... and I got feedback about the color blue and if it should go from dark to light or light to dark in the gradient.
Early in my design career, I ran a user test of a lo-fi prototype with some members of a customer success team, the visual presentation intended to convey the mutability of what we were presenting. I got a comment that “the sketch look was really nice” and since then have never relied on that as a signifier of where a concept was in the design process.
I liked the font myself, but as with every such "handwriting" font it sits in an uncanny valley of "sketchy but regular": a given glyph, however sketchy in isolation, always looks exactly the same!
I'm asking myself if this might be a good application for a WebGL shader?
The issue with "theming to look sketched" is the same as with "hand drawn looking components" - it has to be integrated for your specific DOM or App, totally defying the purpose of "making someone understand this is a quick sketch". Because by now, it's far beyond being a sketch.
but that's the point, it's not a sketch, it's a prototype.
Consider building a calendar app. You build part of the thing, but you have not handled error conditions and edge cases, the back-end supports only a single user and you don't have authentication working.
It's enough to validate some of the flows and how UX actually works, but if you show it to a customer with the actual proper designs they will subconsciously asume that the work is finished.
If the look and feel is "this is not real" it sets their mind in a different configuration.
Exactly, I have been in too many meetings when they get shown a click dummy in the technology stack, we get the reaction, a couple of days more and it is done.
Love Balsamiq. The style of wireframe is so useful for conveying to people that this is just a sketch and to avoid the ‘I’m not sure about the font’ questions
Absolutely love Balsamiq. So quick and easy. IIRC there used to be a post-processing tool by a 3rd party that would turn Balsamiq Mockups into code - wonder if it's still kicking around.
Edit: it was called napkee. looks like it was open sourced but hasn't been touched in almost a decade
I wish more designers used these, precisely because it blocks them from prematurely adding too much detail.
When they start doing things like exact-padding and font-size and whatnot, it either (A) front-loads implementation into the development process when the UX hasn't really been tested or at least (B) making developers spend time guessing how precisely the beta needs to look like the design.
122 comments
[ 49.0 ms ] story [ 4590 ms ] threadThe same author also made rough.js.
So it looks like the commenter you replied to has more context than you.
Show HN: Wired-elements – UI web components with a hand drawn, sketchy look - https://news.ycombinator.com/item?id=17146451 - May 2018 (120 comments)
I feel like there were other threads, either about this or something very similar. If anyone finds them, we can add to the list.
I think the current bland flatness is a kneejerk reaction to that (kicked off by Jony Ive who was probably angered by Forstall's design).
https://napkinlaf.sourceforge.net/#Snapshots
><link rel="preload" href="fonts/font.woff2" as="font">
>@font-face { font-family: 'Gloria Hallelujah'; ... src: local('Gloria Hallelujah'), local('GloriaHallelujah'), url(fonts/font.woff2) format('woff2'); ... }
>body { ... font-family: 'Gloria Hallelujah', sans-serif; ... }
So yes, the choice of font looks to be quite deliberate.
IIRC, Peldi, Balsamiq founder, had blogged about it at the time. I like it too. Also reminds me vaguely of the Comic Sans font, which was the rage even earlier.
> Some of the core algorithms were adapted from handy processing lib.
handy is LGPLv3, but rough.js is MIT. This line makes me think parts of rough.js are actually LGPLv3, as those parts are derivative works.
In practice this is unlikely to negatively impact me but I'm not super pleased by the uncertainty.
And yes, it does release you from licensing obligations (unless the license included specific clauses).
It doesn't take much for a court to consider something a derivative work.
Of course, there's a gray zone: what about a reimplementation in the same language, but with different variable names? Those cases are why we have courts.
But ... if you figure out how to solve Rathbone's conjecture[0] and reveal the source code for it in C++, my reimplementation of that in Rust or Lua does not constitute a derivative work.
One exception would be if you managed to patent some feature of the algorithm (RSA comes to mind, or frequency-based colors for drawing waveforms). That's a different story.
[0] invented :)
Your advice is dangerous. Consult an attorney.
Turning that off though and things seem to load ok, even with UBlock Origin and Privacy Badger running.
Probably too much extra work though.
While my google-fu is failing me as I write this, there was a blog post I read long ago about a making things look not done (I want to say it was in the context of an AWT look and feel). Related: xkcd-style Plots https://mathematica.stackexchange.com/questions/11350/xkcd-s... ( https://news.ycombinator.com/item?id=4597977 ) and https://www.chrisstucchio.com/blog/2014/why_xkcd_style_graph...
If the product looks done then the feedback you will get assumes that it is done.
I made the mistake of using a nice looking header (it looked better than the existing ones that were used which were stretched gifs and I had a CSS gradient) while working on the innards of some JavaScript. While I was trying to get feedback on the "is this workflow the right sequence of pages? Are these the UI elements that need to be on the page for this functionality? For that matter, am I missing some functionality?" .... and I got feedback about the color blue and if it should go from dark to light or light to dark in the gradient.
...
And with some digging I remembered the look and feel - https://napkinlaf.sourceforge.net
Which has the links to the blog post:
Don't make the Demo look Done - https://headrush.typepad.com/creating_passionate_users/2006/...
Having to write code loses the point of quick and dirty.
No cloud dependencies, and a lifetime license for $99. These are becoming rarer and rarer
This works if you can switch out The design as in the old "napkin look&feel" for Swing.[0]
Sadly I think "change design by switching out a theme" has long died as an idea in the web space.
[0] https://napkinlaf.sourceforge.net/
The issue with "theming to look sketched" is the same as with "hand drawn looking components" - it has to be integrated for your specific DOM or App, totally defying the purpose of "making someone understand this is a quick sketch". Because by now, it's far beyond being a sketch.
Consider building a calendar app. You build part of the thing, but you have not handled error conditions and edge cases, the back-end supports only a single user and you don't have authentication working.
It's enough to validate some of the flows and how UX actually works, but if you show it to a customer with the actual proper designs they will subconsciously asume that the work is finished.
If the look and feel is "this is not real" it sets their mind in a different configuration.
It has a non-standard ux, since I didn't want drag-drop on a small touch screen.
Edit: it was called napkee. looks like it was open sourced but hasn't been touched in almost a decade
It finally became too bloated and now we just use draw.io.
When they start doing things like exact-padding and font-size and whatnot, it either (A) front-loads implementation into the development process when the UX hasn't really been tested or at least (B) making developers spend time guessing how precisely the beta needs to look like the design.
https://gitlab.com/saxion.nl/42/wiretext-code/-/blob/main/RE...
There's a screenshot in the carousel here:
https://www.macintoshrepository.org/2549-appearance-manager-...
Implemented using Appearance Manager, not via Kaleidoscope or one of the other add-ons.
https://en.wikipedia.org/wiki/Appearance_Manager