The Isomorphic Blog


First Batch of SmartClient 11 / Smart GWT 6 Features

We have been working hard on our next major release. It’s not ready yet, but check out the first batch of new features below. We hope you love them!

Grid Inline Operator Filters

With SmartClient 11 / Smart GWT 6, advanced search operations are available in any *grid that features inline filtering. Getting to important data couldn’t be easier:

  • Choose search operators such as “greater than”, “matches pattern”, “is not null” (see full list below)
  • Type a value in the existing inline filtering interface
  • Press <enter>

FilterTable2

The following operators are available:

GridFilterOperators

Note that this feature is enabled by default, so it’s an instant upgrade for your existing applications!

 

Try the Grid Operator Filter Live, Hands-on Demo >

 

Menu Embedded Components

Interactive components can now be embedded in menus to create a more streamlined, immediate user experience. This eliminates many cases where multiple steps or a modal dialog would be required to complete a menu-driven interaction. For example, see the images below:

MenuEmbeddedComponents

 In the above image:
  • The typical Cut/Copy/Paste menu items have been collapsed into a more compact row of buttons
  • The “Add Bookmark” item gives you the ability to override the default title for a new bookmark without leaving the menu.

Check out the Menu Embedded Component Live, Hands-on Demo >

 

Adaptive Layouts

The Adaptive Layout feature allows components to render in different ways according to available space.
Unlike crude “responsive design” approaches, where appearance changes based on the overall screen size, Adaptive Layout APIs allow a component to render at multiple discrete sizes based on the dynamic situation, such as:
  • How much space is needed to show dynamic data values (e.g. loaded from a database)
  • The size chosen by an end user for a re-sizable screen region
  • Labels that have different sizes in different locales

View the Adaptive Layouts API Reference >

For example, a Menu using the Adaptive Layout feature can show more or fewer menu items inline, responding on the fly as other elements on the screen require more or less space:

InlinedMenuMobile

In the image above, you can see:

  1. Menu with a candidates name and three menu items inline
  2. As available width is reduced, there is not enough space for the three menu items. The component automatically displays one of the menu item via a drop-down control
  3. With the same available width, a candidate with a longer name reduces the space available for menu items. The component reacts intelligently to the dynamic data and a second menu item is moved automatically to the dropdown control

Learn to write your own adaptive layouts >

 

Adaptive Menu Component

According to the available Space, the AdaptiveMenu component can either display menu items inline:

AdaptiveMenuInitial

or in a drop-down:

AdaptiveMenuLast

 

or mix the two modes according to available space:

AdaptiveMenuSecond

 

Go to the Adaptive Menu Live, Hands-on Demo >

Adaptive Width Button

A Button with adaptive width enabled will shrink to just an icon if there is too little space for its title, so your application will work on any size of screen.

See the example below and visit the SmartClient 11 / Smart GWT live samples to try it out.

 

ezgif.com-cropAdaptiveButton

Visit the Hands-on Demo for Adaptive Width Buttons >

 


Use our Pre-release Features Now

Download our cutting-edge development pre-releases to get started using our new features now!

As always, please send us any bug reports or feedback in the Forums. Please be clear about what product and version you’re using when reporting issues.

Look out for Part II of the SmartClient 11 / Smart GWT 6 release preview.

Best,

The Isomorphic Team

Three Problems with Agile

The essence of Agile is to ramp up communication between team members to an extreme degree. The idea behind this is to minimize the functionality gaps, design misses and rework so often encountered in waterfall development processes, with an end goal of maximizing the output of usable software.

Ramping up communication, however, has its own set of challenges. For starters, here are just three:

#1 Distributed team logistics

For a myriad of reasons (cost, morale, retention, etc.), the past ten years have seen more and more companies allow team members to work from home. However, coordinating sprints across dispersed teams is very difficult. There always seems to be someone missing or joining the conference call late and ‘catching-up’. This is causes disruption and irritation.

Now consider that the typical team these days has members spread across the world. The scrum may start at 9am in San Francisco, but it is lunchtime in New York, dinner time in London, and past bedtime in Bangalore. There is really no good compromise in this scenario. No matter what time the scrum starts, some or all of the team will not be happy.

#2 Continuous sprints

With Agile, the team is always in a “sprint”. Anyone with even basic sports awareness knows that after a sprint there should be a period of rest. However, there is never a “rest week” on an Agile schedule. For some reason it is always just ‘sprint’, ‘sprint’, ‘sprint’. This can lead to burnout and management resentment.

#3 Availability conflicts

Very often, business requirements and design validation are sourced from actual business users. However, business users actually have a day job. They can’t be in a room in a scrum all the time. If they are only available intermittently, the process starts to fall apart.

With lack of business user input, teams often end up in an intense discussion of a problem, where no one really understands the problem clearly enough to meaningfully discuss it. And this can be yet another source of team friction.

What is the solution?

It would seem that these problems and others could be solved by technology, but there are surprisingly few (no?) options out there. What would the ideal solution look like?

One thing is for certain … since different team members (e.g. designer versus developer) have different skill sets and needs, any new tools will have to be role specific.

More thoughts to follow …

Available NOW: SmartClient 10.1 / Smart GWT 5.1

10-1-5-1-ReleaseV3

The SmartClient 10.1 | Smart GWT 5.1 release is here and it’s a good one!

 What’s in 10.1 | 5.1 ?

You can find lots of details in the blogs below:

 

Here’s How to Get It

New Customers

Existing License Holders

*** Upgrades from SmartClient 10.0 / Smart GWT 5.0 to 10.15.1 are FREE. ***

When upgrading from earlier versions, discounts are based upon the date of your previous purchase. Please contact us for upgrade pricing.
  • To order an upgrade from a previous version & for more options, contact sales.
  • For more information on how our licenses work, see the Product & Licensing FAQ.

Once you have purchased your upgrade, Download SmartClient 10.1 or SmartClient 5.1 to get started (don’t forget to log in first)!

As always, please send us any bug reports or feedback in the Forums. Please be clear about what product and version you’re using when reporting issues, including the exact date of the build.

Enjoy!

The Isomorphic Team

Next Release – Final batch of features

Our next release (SmartClient 10.1 / Smart GWT 5.1) is just days away. As you probably know, we already published two blogs listing several of the upcoming features:

Here is the final batch of features (excluding 1 or 2 stragglers) …

Two New Components: “Deck” and “NavPanel”, with Tool Support

The “Deckcomponent: manages the mutually exclusive display of a set of components (like a TabSet with no tabs). LearnMorebutton
The “NavPanelcomponent: manages list/tree navigation between a set of components displayed in a Deck. LearnMorebutton
Both components are very easy to build from existing components, but specialized support has been added to both the Dashboards & Tools framework and Visual Builder to make it easy for non-developers to build screens incorporating these common patterns. DeckandNavPanel

 

More Visual Builder Updates

  • Support for adding/editing FormItemIcon
  • Ability to attach multiple actions to an event

 

More Data Import Improvements

BatchUploader has a new mode which facilitates interactive fixing of errors. PartialCommitOption allows a specified action to be taken (allow, prevent, prompt, retain) if a user attempts to save the dataset produced by a BatchUploader whilst it still contains errors. LearnMorebutton
Data Import: support for automatically translating display values from related DataSources into correct foreign key values during data imports. ** Check back later for documentation

 

Messaging Support for JMS Queues

The Real-time Messaging module has been upgraded to support JMS (Java Message Service) Queues, as well as JMS selectors (which allow you to subscribe to a subset of available messages in a JMS Topic or Queue). LearnMorebutton

 

FileSource APIs for Saving and Loading Files to DataSources

The FileSource APIs allow saving and loading files to DataSources, including automatic versioning and per-user ownership. They are implemented by sending requests to the server with a special operationType. LearnMorebutton

 

SuperDevMode

In this release, SuperDevMode becomes even more super, with a setup guide and improvements to stack traces and other diagnostics. LearnMorebutton

 

Reload listGrid without a Loading Message

 

With 10.1 / 5.1, a listGrid.refreshData() API will be available for reloading data from the server without a loading message appearing. LearnMorebutton

 

 

 Getting the Server Details Right

Avoid Precision loss with stringInBrowser

The stringInBrowser server-side setting can be used to deliver numeric values as strings to the browser. It causes values for fields of type “integer” or “float” to be represented as Strings when delivered to a web browser, to avoid mangling values which cannot be represented faithfully in JavaScript (such as BigInteger, BigDecimal, Long, etc.)

LearnMorebutton

JodaTime Support

JodaTime Support will be in this release, including handling JPA/Hibernate beans with JodaTime properties. JodaTime classes will automatically be sent to the client as Date instances, and Date instances submitted by the client will automatically populate bean fields that use JodaTime types, including automatic handling of the difference between logical date, logical time, and full date+time fields.

Optional Millisecond Precision for datetime Fields in SQLDataSource

With trimMilliseconds, the millisecond portion of time and datetime values can be (optionally) trimmed off before before being sent from client to server or vice versa. By default, millisecond information is preserved (i.e. it is not trimmed). You only need to consider trimming millisecond values if their presence causes a problem – for example, a custom server that is not expecting that extra information and so fails parsing.

LearnMorebutton

DataSourceField.sortByField for Custom Server-driven Sorting

In release 10.1 / 5.1, getSortByField() can be used for server-side sorting of the values of a field according to values of another field.

LearnMorebutton

 

 Upgrades

 *** Remember: Upgrades to 10.1/5.1 are FREE to those who have already purchased 10.0 / 5.0. ***

For those not yet on 10.0/ 5.0, upgrade discounts are available and are based on the date of your last license purchase. View our License FAQs for more details. If you would like to upgrade, please contact us.

Thanks as always,

The Isomorphic Team!

 

 

 

Is ‘lightweight’ always a good thing?

Business applications are supposed to improve productivity.

That is why they exist. However, as developers, we sometimes get excited about a newly released technology and the benefits it claims. We can then end up adopting technology that actually degrades the final product – creating a less productive UI, and even ruining performance, despite promising performance claims.

At Isomorphic, we see this happening a lot with companies that get excited about new ‘lightweight’ technologies, like AngularBootstrapBackbone or Ember – or even JQuery, when new JQuery-based components are released.

So, what drives productivity in today’s web applications?

End user productivity – from a platform perspective – is driven by:
  • Advanced UI features (i.e. performing activities with fewer steps / clicks / screens / actions)
  • Performance & scalability (i.e. getting the result of each activity faster)

 

Can we build high-productivity applications with ‘lightweight’ technologies?

There are a number of areas where ‘lightweight’ technologies consistently fall short, or fail to understand the true enterprise requirements:

1. Wrong performance focus

People are excited about “lightweight” grids, which claim to be able to render 10,000 or more rows in a reasonable time in the latest browser.  Developers often think this means that they can skip implementing data paging, and can use client-side filtering and sorting to improve performance.  The reality:
a. the reason not to load 10,000 rows is the database, not the browser.  It’s not important that a grid can render a lot of rows all at once.  The purpose of loading rows incrementally was always to avoid unnecessary database and application server load, as well as avoid wasted bandwidth.
b. 10,000 rows is not a reasonable upper bound – nor is 100,000.  Business data sets routinely get much larger, especially when you consider administrative interfaces that look at data from many users at once.  If you ship an application that expects to load all data up front, it will break in production as data volumes go higher than you had assumed.
c. client-side filter & sort is achievable with Isomorphic grids – but not with lightweight grids.  Our Adaptive Filtering technology automatically switches to client-side sort & filter when data sets are smaller, so you can handle extremely large data sets and reduce server load and bandwidth use.  This capability is why Isomorphic grids dominate performance comparisons that simulate actual end-user behavior.
d. you can only render rows faster by removing features.  Isomorphic’s grid component uses a complex HTML structure because it supports a huge variety of productivity features like auto-sizing of both rows and columns, on-the-fly column freezing, row-spanning cells, components embedded in rows, on-the-fly grouping, as well as many developer override points that require particular HTML structures in order to work.  We know exactly what simplifications would result in rendering more rows per second.  We intentionally don’t apply those simplifications because they would remove productivity features, while not actually improving real-world scalability or performance.

 

2. Productivity comes from feature-rich components, not “lightweight” ones.

Consider grid components. End users need capabilities like edit inline, freeze columns, grouping and sorting, formula columns, adaptive filtering, hiliting, export, drag & drop, etc. Without these and other features, performing simple tasks requires end users to complete multi-step processes. For example:
  • With edit inline: end users click a row or cell, edit the data, then move on.
  • Without edit inline: end users select a record, click an edit button, are taken to another screen, perform the desired update, save the record, and return back to the starting point – hopefully without losing context.
Without feature-rich components, your application can become a frustrating time sink rather than a productivity tool.

 

3. Forgetting something?  Server integration!

Some of the most powerful features in modern UI technologies span both the client and server.  Examples from Isomorphic’s technology include:
a. single source validation & security rules.  Validation rules declared in one place are enforced on the server (for security) and the client (for immediate feedback)
b. automatic UI generation.  Grids, forms and other components can be automatically configured from server-side artifacts such as Java beans and database tables, greatly reducing redundant declarations and making applications easier to maintain
c. exports.  Isomorphic’s UI components know to coordinate with our server framework to export themselves and their data to Excel, PDF and other formats.  Every application needs this; it can be a huge effort to build from scratch.
.. and this only scratches the surface of features that a modern client & server framework provides.
Starting from a ‘lightweight’, client-only framework puts you years behind the state of the art for UI technology, before you even consider which UI components to use.

 

4. Mixing components never worked, and still doesn’t

Most of the new crop of ‘lightweight’ frameworks emphasize the ability to plug in components from different sources, so you can get the best of each component type.  This should all work since they share a common data-binding system, right?
Wrong, unfortunately:
a. accessibility requires intensive coordination between components about tab order, modality, and ARIA markup.  Really trivial cases where just a few rudimentary components are combined will appear to work, however, when you have a lot of instances of dynamically change tab order, multi-level modality and the like, there’s no way to get components from different sources to work together and actually pass accessibility tests
b. skinning conflicts.  Each component has a slightly different look and feel, and it can take a lot of work to correct the mishmash of different fonts and styles so that an application looks reasonably consistent, especially since, when fonts are made consistent, the sizes of various controls and sub-controls used in the app may need to be adjusted to fit the adjusted fonts.  Also, some frameworks make conflicting assumptions about CSS they can globally apply to the whole page, breaking other frameworks or components on the same page (e.g. Bootstrap)
c. export and print support.  A rare feature among ‘lightweight’ components, yet most applications require it, and just one component lacking support can ruin the ability to print or export a particular screen or report.
d. internationalization and localization.  Pulling components from multiple sources typically means that localization work has to be repeated for each component, as every component needs the local word for “OK”, or to be told what date format to use
e. inconsistent quality and endless evaluation.  There is the practical consideration of whether it makes sense to constantly hunt for components.  One grid has inline filtering but no frozen columns.  Another has frozen columns, but no ARIA support for inline editing.  A third has a nice date filtering interface, but it looks and operates completely differently from a date filtering interface you’re using outside of the grid, which will surely lead to user confusion.
f. support.  Even if you succeed in finding a workable set of components, you may find later on that your bug reports are ignored by one team or another.  If support is even available for your chosen components, how many separate support agreements will you be purchasing?  What about the many bugs that are not quite just one vendor’s fault?  For the many single-component OSS projects, is there any reason to think the project will last as long as you need to maintain your application?

So, is ‘lightweight’ always a good thing?

No, it’s not … especially when you’re up against heavyweights. SmartClient has the richest set of UI components available, coupled with deep server integration to bring productivity and performance to your enterprise applications.

A Candid Opinion on the Threats to Java

Earlier this month, our very own CTO – Charles Kendrick – was interviewed by Marketing Strategist and Growth Hacker, Tom Smith. This interview was part of a series for DZone’s 2015 Guide to the Java Ecosystem, coming in October.

Tom’s article is below and the original can be found here. It is well worth a read!


A Candid Opinion on the Threats to Java

Charles has an interesting take on the evolution of the Java Ecosystem. He’s certainly optimistic, but he says that Sun’s missteps and Oracle’s lawsuits still threaten the community.

I had the opportunity to interview Charles Kendrick the founder and CTO at Isomorphic Software about the state of the Java ecosystem today and moving forward. This was part of a series of interviews for our 2015 Guide to the Java Ecosystem, coming in October.

Charles had a more unique perspective than some of the other folks I interviewed and I thought the the followers of the Java Zone would like to see his perspective and let us know [here] how you would answer these questions.

Q: What type of Java projects have you worked on?

Isomorphic produces the SmartClient and SmartGWT HTML5/Ajax frameworks.  Both use a Java server, and SmartGWT uses Java on the client-side via GWT.

Q: What do you see as the most important parts of the Java ecosystem?

The tremendous breadth of useful libraries tends to mean that any enterprise project needs to be using the JVM, even if a language other than Java is chosen.

Q: Who are the most important players in the Java ecosystem?

Oracle and Google (Google because of Android).

Q: What sources do you use to stay abreast of industry trends?

DZone, StackExchange, SDTimes, and various TechTarget sites.

Q: Where is the greatest value being seen in Java today?

Server-side usage in the Enterprise, specifically large-scale, database-oriented systems involving integration between multiple services or platforms, and distributed transactions.

As a language for describing UI, Java is used because it’s popular and well-known, but its expressiveness is very poor, and other languages tend to be a better choice.

Q: Who’s in charge of different Java-related projects at your firm?

We have multiple teams implementing both framework features and customer projects in Java.

Q: What are the skills that make someone good at this?

We will not hire anyone who only knows Java, which we would consider a very bad sign.  We look instead for people who are smart and get things done.

Q: Which other programming languages and frameworks do you, or your firm, use?

Principally JavaScript, Perl, Ruby, PHP, Python, C# / .NET.

Q: How has the Java ecosystem evolved over the time that you’ve worked with it?

Poorly.  Sun’s lack of leadership and major missteps (eg JavaFX, JSF) have led to a plethora of conflicting approaches in basic areas of the Java platform like UI and data binding.

Q: What are the obstacles to the success of Java-based initiatives at a company?

The poor expressiveness of the Java language means that code takes longer to write, is harder to read, and tends to be rigid instead of flexible in the face of new requirements.

Java continues to struggle from the “jar hell” (in analogy with DLL hell) that .NET solved years ago with .NET assemblies, and the various solutions keep getting pushed out (“Project Jigsaw” is now planned for Java 9).

Q: Do you have any concerns regarding the Java ecosystem?

Oracle’s willingness to litigate innovation out of existence, specifically their lawsuit against Android, could easily cause many partners to jump ship to another platform, causing Java to stagnate.

Q: What’s the future for the Java ecosystem from your point of view – where do the greatest opportunities lie?

Better expressiveness in the core Java language.  We have literally hundreds of product samples with parallel implementation in JavaScript (SmartClient) and Java (SmartGWT).  Placing the code side-by-side shows how very, very far Java is from matching the expressiveness of other languages.  Oracle needs to show leadership in more aggressively pursuing and supporting JSRs that improve and simplify Java syntax.

Further  embracing non-Java languages in the JVM. Java 8 has made some strides in making JavaScript more part of the JVM, but it is still a struggle to use other languages, with lots of issues in the areas of error reporting and debugging.

Q: What do developers need to keep in mind when working with Java?

Java’s static type checking ability needs to be looked at as just another form of automated testing, and structuring code to allow more static type checking needs to be weighed against other forms of automated testing.

Specifically, we find that if a developer has spent too much time with Java to the exclusion of other languages, they tend to expend heroic efforts structuring code so that it’s possible for the Java compiler to check more error conditions.  This effort is usually better spent on automated tests, which can catch a much wider range of error conditions.

Even More 10.1 / 5.1 Features

Our next release – 10.1 / 5.1 – is getting close. We talked about some of the upcoming features in an earlier blogpost. Here are a few more to wet your appetite further …

 

Server-side Support for Relative Date

The RelativeDate system allows end users to express criteria as relative to the current date, which is very useful for saved searches and other applications.  New support for server-side decoding of RelativeDates allows automated processes that don’t involve a browser to execute saved criteria that involve RelativeDates.

LearnMorebutton

 

 

Snap to Align

While dragging, snap to coordinates aligns the edge or center of the dragged widget with the edge or center of other widgets in the same container.

AlignFull

LearnMorebutton

 

 

Client-driven Transaction Chaining

Transaction chaining enables the values of a request to be determined by the results of a previous request.  A new client-driven mode of Transaction Chaining allows client-side code to drive this process instead of requiring server-side declarations, so that existing server-side operations can be re-used in novel ways without requiring server-side developers to add new features.

 

API for Doing Transactions Outside of HTTP Request Lifecycle

This enhancement allows the Automatic Transactions feature to be used for scheduled tasks (such as Quartz timers) and standalone applications (not running within a servlet engine). 

Scheduled Tasks
DSTransaction tracks a queue of requests and provides APIs for commiting, rolling back, managing error status, freeing resources, and enabling features like “Transaction Chaining”.

LearnMorebutton

 

Standalone Applications
The DataSource layer can be used in a standalone application separate from a servlet engine, for use cases like offline batch data processing, sending emails based on database state, or integration of Smart GWT Server logic into a standalone Java Swing application.
LearnMorebutton

 

 

Floating Titles for Drawing Shapes

All shapes now support the ability to have a text title drawn on top of them, with various options for how text is placed for rotatable shapes.  For example, as a shape is rotated, the title can stay in place, rotate with the shape, rotate with the shape but flip so as to always remain upright, etc.

TitleShapes

tryitout

 

 

The Dashboards & Tools framework now has built-in support for editing titles – just start typing when a shape is selected to add or change a title.

EditTitle

tryitout

 

 

Improved Data Import

We’ve added XML and JSON formats …

  • BatchUploader now allows XML or JSON uploads (in addition to CSV) and has the ability to auto-detect the format used.
  • Server-side APIs parsing XML, JSON or CSV data as DataSource records make custom importers easier to write.
  • The Admin Console and Visual Builder now support upload of sample data files right in the tool.

importData_json

LearnMorebutton

 

 

Upgrades

 *** Remember: Upgrades to 10.1/5.1 are FREE to those who have already purchased 10.0 / 5.0. ***

For those not yet on 10.0/ 5.0, upgrade discounts are available and are based on the date of your last license purchase. View our License FAQs for more details. If you would like to upgrade, please contact us.

Thanks as always,

The Isomorphic Team!

Outdated performance perceptions driving your mobile strategy?

Looking back, there was a time when mobile specific apps were necessary. Browser technology wasn’t quite there, and the first smartphones just didn’t have enough oomph. But we have come a long way since then …

 

Let’s look at the iPhone. Since the first release in 2007 to the release of the iPhone6 last year, according to Apple, speed has increased 50x. Most independent reports say this is more or less correct. If we consider just this improvement, something that used to take 15 second would now take 0.3 seconds. Just that alone makes a huge difference.
 applePerf

 

Browsers have improved too. It turns out also by a pretty huge amount. In less than two years from Jan 2010, Kraken javascript benchmarks shows improvement from 29,000 to 2000 ms. The rate of improvement was less dramatic in the last couple of years, but it is currently around 1000ms, making it overall about 30x faster since 2010. Again, considering this improvement in insolation, something that used to take 15 seconds would now take 0.5 seconds.

 

Kraken

 

These two improvements however are additive. They collectively provide an overall speed improvement of 1500x. To put that in perspective, if something used to take an unacceptable 15 seconds back in 2007, it would now take a delightful 0.01 seconds.

But let’s play devil’s advocate and consider that Apple could be exaggerating a little, and maybe the javascript benchmark conditions were too ideal. Let’s say the improvement was only 1000x. That 15 seconds would still now be a lightening fast 0.015 seconds.

Do you still want to create a desktop application, then rewrite for iOS and again for Android?

 

SmartClient allows you to write just once for all devices:
  • Much less coding and maintenance
  • Lightning fast
  • No UX compromise

With the SmartClient strategy, you can even afford to do the unthinkable and build a rest week into your sprint schedule! 😉

A Better User Experience (and a Sneak Peek at the Next Release)

sadtohappyBlogOur next release  (SmartClient 10.1 / Smart GWT 5.1) is still a little way off, but we would like to share some details. We also want to give you the opportunity to play with some of the BETA (pre-release) features. This blog will focus on user experience. However, there will be more blogs about other aspects of the 10.1 /5.1 content, so please look out for them.

 *** One important point … upgrades to 10.1 and 5.1 are FREE to those who have already purchased 10.0 / 5.0. ***

So, without further adieu, let’s talk about user experience …

Building an application that users love needs a great understanding of the business requirements / problems you are trying to solve; translating these into a functional design … then of course developing, testing, releasing and maintaining the application. This all takes a long time and there is often little time left to focus on making the user experience as good as it needs to be. In addition, some things that seem small and insignificant require big workarounds / hacks that outweigh the perceived benefits.

The problem with this is things that seem independently insignificant can collectively make the end user’s life miserable. The end result being that they don’t want to use your application. At Isomorphic, we are therefore trying to make it easier and faster for you to go the extra mile from a user experience perspective.

Below are a few BETA features that you can start playing with right now.

Visual Changed State

In SmartClient 10.1 / Smart GWT 5.1, FormItems will support a pending visual state that can be used to style the item differently when the user changes the value from the last-saved value. This includes showing strikethrough appearance for values in multiple-select controls. Try the live sample now!

Visual Changed State

Visual Changed State let’s you control the appearance of changed values, and display the original value.

Try Now Button

 

 

Inline Icons

It’s now easy to place icons inside of editable text fields such as ComboBoxItems, for decoration or to provide functionality when clicked.  Icons support left or right alignment, and multiple icons are allowed on each side. Try the live sample now!

TextBoxIcons

Try Now Button

 

 

Nav Bar Animations

Our NavigationBar component has been given subtle, built in animations / transitions that not only look cool, but help users keep their sense of place. Notice how the clicked button glides in to be the new heading, while the new buttons fade in to place.

Spriting

A CheckboxItem’s checkbox can be sprited by setting a custom boolean Base Style and writing the CSS to apply the appropriate background-position for the checkbox’ current state. Try the live sample now!

Spiriting
Try Now Button

 

 

Hints, Tips and Format Masks Improved Placeholder Behavior

When filling out a form, it helps to guide the user as to what data and format is expected. The behavior has been improved such that hint / tips persist even when the user places their cursor in the field. The hints / tips only disappear once the user starts typing. See the example below and try the live sample now.

jvhe9
Try Now Button

 

The above are just some quick insights into a couple of the user experience enhancements we are providing in 10.1 / 5.1. There’s a lot more to come besides this, so check back here for more updates.

As always, thank you from all the Isomorphic Team!

P.S. Thanks for reading our blog. If you would like us to cover any specific topics or have any feedback, please let us know by emailing jason@isomorphic.com.

A single codebase for all devices

Isomorphic_banner15_Twitter_1500x500[4]

With smartphones, tablets and other mobile devices becoming more and more prevalent in Enterprises, development organizations are often advised to design, build, test and maintain applications for the desktop, and repeat these tasks for every operating system (iOS, Windows, Android, etc.) and individual devices (iPhone 6, iPad, etc.). However, this rapidly becomes unsustainable.

Our last customer survey confirmed that the enterprise web applications you build are mostly accessed via desktop. The drivers for this are the tasks being performed, the volume of data involved, and the types of end users (mostly in the office / occasionally in the field).  We outlined a mobile strategy that supports these findings.

We also introduced capabilities like Adaptive UI, Responsive Layouts, and Intelligent Auto-Fitting. With the SmartClient platform, developers can create powerful, beautiful, single codebase web applications that run on any device (desktop, mobile, tablet). Since development need only be done once, the overall effort is radically reduced. The end result?:

  • Solutions to market faster
  • Higher quality
  • Lower development costs

What’s not to like? Try out some more live samples here.

 

Page 2 of 9«12345»...Last »