I've been trying to figure out a good Flutter process workflow for designer and developer interactions in order to iterate desktop/mobile/web application design. There isn't a very clear line of demarcation between the code and the design as there is in web dev. (for example, the developer would be focused on javascript and a little html, while the designer would be focused on the css and html.)
Some of this has been written about here: how developers and designers can collaborate using flutter
but the mechanics have been left out. (also, it seems like the average flutter designer needs to be more tech-savvy with git skills than designers of yore. Is this your experience?)
While there does seem to be good control of color/fonts/styles with the AppTheme widget, other design aspects are more difficult to enact. For example, if you wanted to change all of the div's (in html) / Containers() (in flutter) from square corners to rounded, you could set a class and apply it across the board in web dev. In flutter, I believe you have to visit every Container in the code and apply a BoxDecoration widget... and repeat if there are changes in the future.
Specifically, what design-dev processes/architectures are you using to facilitate design iterations between devs and designers?
Note: Additionally, I've seen that there are some tools like Adobe XD, and supernova.io that allow for design exporting to flutter code, however that seems like a one-time thing... and doesn't lend itself to well to iteration. Has anyone used this method in their design iterations?
After experimenting with a couple of different methods, it seems like the export features of different programs aren't far along enough to allow anything but the "mockup method" where the designer basically gives the flutter programmer access to some kind of mockup (axshare, adobeXD, zeplin, etc.)
HOWEVER, I did have the most success with exports using sketch -> SuperNova, but this required a tech-saavy designer that was able to probably classify all of the components such as buttons, etc, as well as create designs with responsiveness in mind. Otherwise the export is filled with absolute positioning, which makes the flutter coders job difficult since they need to correct all of those exported widgets and make them responsive.
Related
By 'web developer' I mean a software developer having a sound
understanding of web fundamentals (HTTP, HTML, CSS, JavaScript and
Ajax).
By 'successful GWT developer' I mean someone who can produce
high quality and polished looking GWT apps in timely fashion.
My department is gearing-up for a project that will require the development of a number of single screen RIA web apps. These will front enterprise server components implemented in Java. Our UI prototype was developed using ExtJS and was successful (in terms of speed of development and producing a professional, polished looking UI that integartes well with a service oriented API implemented using Spring-MVC + Jackson). However, in gearing-up to develop the actual product we have realised that our department's skills profile isn't ideal for ExtJS. We are strong on Java but relatively weak on web developers. The development of the UI prototype demonstrated that you really need fully feldged web developers to get to grips with ExtJS, since they will spend a significant amount of time grappling with CSS and JavaScript issues. As a result, the question has arisen as to whether we might be better off going with GWT (combined with a library that offers a level of polish comparable to ExtJS, such as SmartGWT). Obviously this assumes that GWT is significantly less demanding in terms of web development skills. To what extent would GWT + SmartGWT allow our Java developers to crank out high quality RIAs without them having to acquire anything more than a basic appreciation of the web fundamentals listed above?
If we decide to explore GWT further we'll do another prototype, but in the mean time it would be very interesting to hear the opinions of experienced GWT developers.
My experience is that you can get away with a lot without advanced web skills, but the end result is a pretty bland looking app, but even worse, you'll find yourself struggling to achieve all the dynamic effects you want.
As an example, my app has a DataGrid on the main tab. That could be done easily enough using pure GWT. But then I wanted to put a checkbox under the DataGrid widget that the user could use to select "single line mode", in which the rows are one line each -- any data in cells that would have word-wrapped just disappears at the edge of the cell. Hit the checkbox, and the rows collapse to one line each, then hit it again, and the row heights expand to whatever size is needed to display all the data in the cells. There isn't a method for that. What you have to do is adjust the row style of the DataGrid to add or remove the CSS element "white-space:nowrap;". So you add a ValueChangeHandler to a CheckBox widget (GWT skills) that modifies a CSS style of the DataGrid widget (web skills).
Without web skills, you'll find yourself hitting walls in trying to achieve the look-and-feel (and even dynamic behaviour) you want. Having said that, you can find these sorts of answers easily enough on the web. The key thing to remember is that just because GWT doesn't seem to have a method for something, that maybe it's really a web issue, not a GWT issue, and that you have to remember to think outside of the GWT box to solve your problem (instead of throwing up your hands, blaming GWT for lacking a feature, and hoping something like SmartGWT will solve all your problems).
The fact that every GWT widget has a plethora of methods for setting, adding, and removing styles, and the very rich integration via ClientBundles and UiBinder and the like, means that this was always the intent.
GWT is a very capable framework and can be used to produce great results such as Pictarine, but as the developers of Pictarine indicate:
Another thing that was not obvious to us when we started with GWT was that a java developer needs an intimate knowledge of HTML/CSS if he/she wants to go beyond the basic user interface provided by the GWT widgets.
I'm not quoting this to discourage anyone. Basic interfaces are indeed within reach with GWT without much HTML/CSS knowledge. GWT, however, leans on web languages and so in a non-trivial application familiarity with JavaScript, HTML, and CSS will come handy. Personally, using GWT has been continuously deepening my JS/HTML/CSS skills as I've been searching for ways to enhance my GWT projects, which in the end has been very rewarding.
I typically work on web apps that will only be used by a small group of well-controlled people, but now find that I'm writing something that has the potential to be used by a very large population. This means that the design and "look" will be very important to the success.
While I can certainly code up something functional, it ain't gonna look pretty, so I know that I'll need to get an outside designer to make things look good. Never having worked that way before I had a few questions about the mechanics of how this happens and how to try to make things easier.
We do Java, so when building a rich interface, we use GWT. I know that when working with designers, they typically provide images of what the interface should look like without any type of "useable" output. My question is how best to bridge that gap between a simple drawing of an interface to a fully functional realized one.
Any thoughts are appreciated.
Well, "it depends", as always.
Nowadays, I don't think you can work wit someone who simply provides PhotoShop mockups. At least not at your level. Mockups are simply too static, and translating those mockups to actual pages that actually work with different browsers properly is a skill set all its own.
So, you need someone beyond simply a designer, especially if you are planning any javascript wizardry, animations, or other dynamic elements that don't capture at all well on a static image.
What you really want is an "operational" mockup. Static HTML files that look and behave as best as can be done to what the UI designer wants to do, including transitions, work flow, etc. This artifact can be run through all of the stake holders as a live mockup, letting folks "Feel" the site.
Once you have these HTML files, you can then do your part of backfilling these pages with actual server side content. Obviously you can start early working on models and working with the designers so as to have services ready to support the site functionality, but you shouldn't be committing any real time in to actual pages for the site.
As for interacting with the designers, I talk more about that over here: How can I make my JSP project easier for a designer to work with
I worked on a project very much like this. We had "comps" which were pictures of what the interface would look like. We identified common objects and build modules. Then built pages (this was for a web app) from modules plus any elements that were unique to that "comp".
A couple things to keep in mind that will make life much easier: use the comps/drawings as more of a recommendation rather than set in stone design. Try to identify common pieces early on and reuse code.
Also, designers aren't user experience gods. They often have a good idea of how things should work, but if you are close to your product and have a lot of product knowledge, don't be afraid to tweak the design as you and your group see fit. One thing that designers typically lack is product knowledge. They know a lot about general user experience and how a site should work, but they often won't know the in's and out's of your use cases and products.
If you are working with GWT, you should look for designers who are expert in CSS. Apart from, may be, the main layout of the website, all the application components like form fields, dialogs, tabs and grids etc. will need to be styled using CSS.
If the designers are not experienced in working with GWT, share the GWT's documentation about styling with them. It's a good idea to read these yourself as well. Specifically explore the GWT's theme-ing system.
Also try to make use of UiBinder as much as possible. This would allow you to stay as close to traditional HTML based design while still enjoying the GWT high level object oriented interfaces (both widgets and DOM).
Optionally you might want to tell the designers that GWT image bundles will automatically do "CSS Sprites" so they don't need to worry about page load performance issues related to images.
What's the benefits if I am using Ext-GWT? Compare to GWT, What kind of benefits EXT-GWT could bring?
If you want your application to look like all the other Sencha applications, then go for it. Sencha comes with a set of tools and widgets that might help you make a faster start, but at the end of the day, you will need a deeper understanding anyhow, and climb that hill.
My 2 cents : go for GWT pur et dur.
for maximum flexibility
for better results
but probably a steeper start.
From the sencha site:
Sencha Ext GWT takes GWT to the next level, giving you high-performance widgets, feature-rich templates and layouts, advanced charting, data loaders and stores, and accessibility, and much more.
I was using the widgets in a project which is nice if you need something fancy not in GWT-only.
As someone who has used both extensively, I can attest to the amount of features added by GXT... ...but, at a price. Its deferred layout system is efficient, but it's a steep and sometimes frustrating learning curve, especially if you want to support IE<8.
Note that I haven't used GXT 3.0, but used 2.X for a large and successful enterprise application. If you do not write some kind of web-based unit tests (selenium recommended), you will eventually get to a point where you spend more time fixing layout bug regressions than you do creating new code.
GXT can kickstart your initial development because you can produce feature rich widget very quickly (Grid is especially nice), but when it comes time to start extending and augmenting the default widgets, you're going to hit brick walls with very little documentation.
Another big gotcha... GXT models internally serialize using a Map<String, Object>, which means that any types not explicitly serialized elsewhere in your RPC will give you errors when put in a GXT model. The workaround there is to put a private, unused field of the type you want serialized (enums were my biggest pain). Finally, gxt models are NOT default java serializable, so if you want to store them in sessions or pass them around on the server, it's not going to go well for you.
All that said, once you get the hang of GXT, and provided you don't dig too deeply into its guts, it is a great tool. The widget sets themselves are very nice...
Basically, if you intend to create a monolithic, feature rich, complex app where you need lots of control over how things are rendered, GXT will probably get in your way.
If you want to bang out a shiny app over the weekend, don't reinvent the wheel, and just use whatever works.
I have a friend who is a graphic designer & user experience designer who will be collaborating with me to develop an iPhone app. He does not have previous iPhone experience. What is the best way to work with him on developing the user interface, i.e. custom colors for UITableViews, UIButtons, etc? We've looked into Photoshop mock ups, but that depends on me (the developer) implementing what he drew in Photoshop, which might get tricky.
Most of the methods I've thought of have long turn around time, i.e. he uses Photoshop, sends me the image, I develop, send him a test build of the app, he doesn't like it, rinse, lather, repeat.
Do you think it's feasible to set him up with Interface Builder so he can modify XIB files? Potentially, he could build and run the app in the simulator...
Does anyone have experience doing this? Any suggestions?
Thanks much,
-dan
This goes for a developer or designer. The best way in my opinion is to mock up designs in photoshop, debate on what is good and what is bad, then send the final mock ups to the developer.
The reason you want to do it this way is because your designer can't do everything he wants to do by simply using the IB. You need to allow your designer to express his creative freedom without the burdeon of figuring out how to use a piece of software correctly.
You can find plenty of templates of iPhone and iPad components on the web. Having those components will make it very simple for your friend to put together concepts. It will also keep things consistent so you can have an easier time implementing them.
A Great Collection of iPad Resources
iPhone Materials
One suggestion is to start with the elements that do not need graphic design but you know they will be there, this will be things like table views, tab bars, any UI element provided by UIKit or even custom UI elements that you make...I would say you will probably have most of your app made by this approach and will look VERY plain...once you have that basis you should be able to work with the graphic designer and identify where and what he needs to make, it should also be pretty easy for you to integrate it since it will probably be mostly images or textures, things like animations and such will have to be handled by you anyway...just a suggestion, hope its helpful
Omnigraffle is your best bet for quickly mocking out UIs. It produces nearly photorealistic mockups. It's easy for non-artist to use but can also utilize imported images of arbitrary complexity if he needs to do something fancy.
If you want my advice, keep the graphic designers away from the app until it is fully functional logically. They should only be brought in at the end of the process to tweak the UI.
They cause train wrecks if they come into the process early. Everybody in that field has been trained first and foremost to create visuals that attract attention. In an UI, that always translates into flashy, non-standard elements that turn into annoyance with repeated use. A good UI is essentially invisible to the user. Ideally, they should notice it only because they notice that they don't notice it. (It's all very Zen.)
People trained to attract attention in the blizzard of competing images of a media saturated world don't make invisible interfaces. They make "in your face" and "look at me!" interfaces that get old in a hurry.
Don't get me wrong: a good graphics person can really enhance an interface by the skillful and subtle use of proportion and color. Unfortunately finding a good UI graphics person is a challenge. Be prepared for fights over what works transparently versus what looks cool and draws attention the first time you see it.
I have read that gwt-ext is slow and it seems too bulky. How does this compare with Ext-GWT? Are there any other libraries out that can easily handle dragging, resizing, minimizing?
In my opinion there are no real worthy GWT widget libraries that I want to even consider. If there is a widget missing you can always try to get one included in the incubator, this way it will maybe end up in the GWT distribution one day.
The bigger, impressive looking ones tend to be a wrapper for an existing JS widget library. Which means that you have to pass on many of the benefits of GWT.
Others like Rocket GWT are a complete rewrite of existing widgets which ties you to another abstraction. That means that if you need extra widgets outside of the Rocket ones you will need to use widgets that follow different design principles.
I tend to stick to the default ones and I use the incubator widgets but I always try to keep those dependencies to a minimum since these are still changing dramatically (changing classnames, packagenames, complete design changes, ...). You do not want to keep on modifying existing code.
In most cases I just create my own widgets that does what I need and nothing more. That takes a lot less time to create than if I have to implement a complete API that would cater a lot more usecases.
Have you looked at http://www.smartclient.com/smartgwt/showcase/
The controls are licensed as LGPL, but advanced server site libs are only included in the professional edition.
we're having some success with Mosaic from the GWT incubator. You'll wish for better documentation, but once you get past that you'll find useful widgets (split panels, etc.) that you can mix with gwt's basic widgets.