by deanalevitt on 4/12/19, 2:53 PM with 79 comments
by doitLP on 4/12/19, 4:22 PM
The best designers I’ve worked with not only understand their own domain but the possibilities and limitations of how it will be executed, because they are also developers.
by golergka on 4/12/19, 3:59 PM
However, in my 12 years of experience in game development, many people who are world-class designers and artists don't have the same mental model as developers. There are a lot of "technical art" issues that in the end, you'd rather handle on a developer's side. I just don't think that a person who spends his time thinking about character's emotion, colour balance, human anatomy and other art-related issues is in the same mind space to think about technical issues like which UI containers should be scaled on what rules (full-screen or safe area? hugging the screen outside or inside?) for different screen sizes, how things should be composed from layers and animated, how assets can be converted from a static image to a resizable one, how a giant image can be cut into a 9-slice (or in a more complicated way) to save texture budget, how can we reuse already existing assets without importing another image that is very, very similar, how different kind of gradients behave with not-pixel-perfect scaling and crunch compression (and I didn't even go into 3d!). I tried empowering designers and artists so they would make these decisions, but they hated it and were miserable - so in the end I'd rather get a static, single-sized PSD and do all that work myself.
All of this, of course, are just my 2 cents from a specific industry and with a very specific kind of people in mind - I'm not trying to impose these views on any designers and artists who want to get into the technical art side and would be thrilled to see more and more individuals who can be productive and happy in this kind of hybrid role. But as a matter of fact, these people are very, very rare and we shouldn't expect most artists to be like that.
by matthewhager on 4/12/19, 7:07 PM
We will soon add the feature to expose your design system as an NPM package so that developers can install the system into their project and the component creation can be the domain of the designer with the application structure/creation being the domain of the developer.
This is a problem that can be solved but it can’t be half-baked solutions. It has to allow designers to fully create all states of a component and even work on components with live data flowing through.
We are in closed beta but you can view videos of how Shift works here: https://www.youtube.com/playlist?list=PLl4_DbGKML_Jb2Wq5pEGW...
by phaedryx on 4/12/19, 4:29 PM
Sure, things could be improved, but I love that we have Sketch and Figma now.
by comis on 4/12/19, 4:11 PM
We're no longer in the dark ages of waiting 5+ years for Adobe to implement some basic feature (like being able to round corners on a rectangle). Well, I guess if you're for some reason using xD you're still waiting a comically long amount of time between significant releases, but that's your own fault.
by anoffsinger on 4/12/19, 4:56 PM
by poof_he_is_gone on 4/12/19, 11:13 PM
by erikpukinskis on 4/12/19, 5:42 PM
> Design libraries are also limited in the type of things they share: just components or symbols. This works great if all your design work is just clicking together new screens with the same components, but anything new will see designers clicking into components and copying over things like colors, font variants and checking spacing just to copy that over into new components. When you copy over things, you’ll invariably make mistakes (we’re just human after all).
Ideally, a component system means you’re black boxing some function.
Unfortunately every component system I’ve ever seen has a hard boundary at some “material” transition:
A UI drawing that can be used inside a design program
A React component is bounded at the DOM and can’t handle server side concerns
A CSS component is bounded at styles and can’t handle HTML concerns
A middleware component that handles authentication, but can't reach outside the routing phase.
etc
Inevitably then, you end up having two or more tightly coupled components:
A front end component + the server API that it knows how to talk to
A little HTML widget + a microservice that it feeds with it’s own persistence
A container for wrapped content + a little middleware meant to be added to the app that serves the content
A button + a delayed job + an email template to get sent when it's done
etc
In order to do this, instead of just having one module with a tight set of concerns inside it, you have to implement some of your concerns in two places, and you also have to map data into the component interface, and then back out again. In some cases this can be 4x the complexity ("code" vs. "code + write to component interface + decode component interface + variant of code on other side of interface").
If the component could span both domains, it could just move the data exactly where it needed to go, as efficiently as possible, since the data is all internal to the component.
The conclusion I’ve come to is something like "components want to be free."
I.e. components want to have concerns that can span the entire stack, and implement procedures in arbitrarily disparate kinds of source locations.
This of course precludes ALL of the component systems which are confined to a specific material domain. It means the boundary of a component has to look something like arbitrary source code. Component interfaces can’t conform to a single template.
That raises the question “what is a component at all?” If the boundary of my component is just a set of function calls, it’s just a module. How is it a component?
And maybe it’s not. Maybe components are a local maximum in code cleanup, and I’m advocating people move past them and just write really excellent single-concern modules instead.
I don’t know. This is as far as I’ve thought it through.
(I do maintain an NPM module called browser-bridge that lets me build arbitrary client/server components, along an event sourcing library called a-wild-universe-appeared for doing persistence in an isomorohic way, and then something called bridge-module for getting dependencies in the browser... All of which let me experiment with what I'm describing, but those are all in a pre-1.0 mostly beta state. The basic interfaces are all stable though.)
by marcintreder on 4/13/19, 12:00 AM
This is exactly what still gets me going after nearly 10 years working on design tools (I co-founded UXPin back in 2010). I'm so glad that more people in the industry notice it!
Majority of the popular design tools (Sketch, Figma, InVision Studio, XD...) work in a 30 year old paradigm of image based–design tooling (originally created for early vector and raster "creative" tools that were never meant to be used to design software interfaces!). In this paradigm the output of a design tool is an illustration of the final product that has no relation to the reality of code. The rendering is different, the interactions are just slide-based simulations, the ability to describe states is nonexistent. To get more down to earth - those tools can't even render a simple text field or a checkbox!
And yes – they're getting better and better, but ultimately getting around the limitations of their paradigm is impossible. At the end of the day those tools are perfect for drawing icons and illustrations, but really bad at creating, for example, a working prototype of a form field with validation.
That's why a bunch of design tooling rebels (UXPin, Framer X, Modulz, Interplay, Shift...) started to work on code–based design tools. In this paradigm the output of a design tool is rendered from html/css/js code, but designers don't necessarily need to know how to code. Majority of UXPin users don't even know that they're prototyping interfaces with advanced JavaScript :).
Within code–based paradigm the limitations of image–based tools do not exists.
In reference to the article here are some features present in UXPin (and some others just to illustrate my point): - states of elements (every element can have multiple states and variants, originally we've built it in 2013. The new version was launched last year). - conditional interactions - javascript expression (from advanced math, regular expressions to operations on strings - in UXPin designers can build really advanced prototypes) - context awareness (prototype can be aware of the os/browser that is used for previewing or e.g. the size of the screen and conditionally render the right state of elements) - accessibility linters - import and synchronization of production React.js code (in beta, we're calling it UXPin Merge) - access to external APIs (you can, for example, build prototypes that can interact with smart devices)
None of that is possible in the old paradigm! Of course the giants of the design industry don't want you to know it, so they invest tens of millions of dollars into flashy marketing:)
Some things that Kilian mentioned are still missing, but we (and others!) are working on them.
Hope this is providing some context to the state of the design tooling industry.
Ps. Fun fact - Figma branded themselves as the first design tool with real time collaboration. We have it since 2011 and... it was also called multiplayer design :)
by tomger on 4/12/19, 11:45 PM