Automated UI Testing

Automated testing is a must in order to build a maintainable codebase and staying agile while writing code. Automated testing is a core procedure of a modern software factory where continuous builds and continuous integrations are widely used practices; testing your software manually every time a new build is prepared requires a lot of effort. Running automated tests will help developers to spot errors in the new build and correct them immediately. During this webinar we will show how automate testing for the Web Client by using Selenium. The automated UI script generated by Selenium will reproduce the user interactions with the browser and will validate the UI state.

How Can Customized Software Development be Successful?

I won’t deny that a customized software solution designed from scratch will cost you more money than your basic off-the-shelf software solution if the performance of the two is going to be identical. Having said that, software projects can end up costing you a bundle, even with standard solutions if the software needs to be optimized and tweaked and the user interface needs to be changed in order to meet the client’s requirements. Changes made to off-the-shelf software solutions tend to be more expensive than similar adjustments to customized solutions.
It’s also very common for the costs involved in implementing standard software applications to get out of hand, where a solution that appeared solid and competitively priced at the outset, ultimately ends up costing you a small fortune.

Why Customized Software?

Many standard solutions include additional, customized features that have been specifically added for an individual client. These add-ons can end up causing major aggravation if they are not compatible with the basic software. This is related, not only to the actual software technology used, but also, to a large extent, to the strategy, and processes and procedures of the manufacturer. Software companies with an international focus tend to have a highly complex organizational structure, including a strict division of duties.

The Developer’s Tools

The software development environment provides developers with the elements they need in order to be able do their job, including a programming editor to simplify the coding process, and a compiler – a program that takes source code and translates it into more basic language so as to create an executable program. The development environment typically also defines the programming language and, in some cases, the database. It also performs a large number of other duties, including version control. An essential part of the programming process is the documentation used. What are the ideas underlying the code? Here, too, users have access to powerful functionality. In some cases, specific development methods – such as Scrum – are supported or even required. This may lead to a situation where the people who locally implemented and developed the manufacturer’s basic development strategy are none the wiser and are caught by surprise when a new release comes out whose underlying technology may differ radically from the previous version of the software. Along with their client, they are then faced with the reality that the software add-ons no longer work in the new release and may have to be readjusted at great cost and effort – and in some cases even reprogrammed altogether. What you believed to be a one-off investment ends up weighing down your bottom line.

Tools Can be Customized Too

In addition to the actual development work, modern software development environments offer extensive libraries of functional software building blocks, where differences in basic functions – recognizable to users – are defined. Let me give you a simple example: if you open a file on a PC, the operating elements can look very different depending on the software used. They might be indicated with yellow folder icons, plus signs, or small triangles. Understandably, software developers don’t want to redefine the user interface for opening files each time they develop a new application. The development environment should enable them to define and store these parameters. Gartenmann Software AG requires that these seemingly minor details be managed identically on all the various devices – PCs, tablets, and smartphones – and that they look the same to users on each device. Like in the example above, this means that an additional layer is added to the development environment that transforms the manufacturer’s specific development strategy.

Frameworks Ensure Consistency

Today’s clients simply want to be able to launch a software application and use it anywhere, anytime and on any platform. Both the software and the user interface should always look the same, regardless of the basic technology (including the hardware and operating system) they’re using to access the application. In order to achieve this, special frameworks are used that are designed specifically for this purpose, including SERVOY.
Our new solutions are based on SERVOY technology and enhanced by an “intermediate layer,” if you will, which helps us ensure an identical look and identical use for the software.

The additional framework we developed is based on Java/JavaScript technology and enables us to efficiently offer our clients modules and software applications with identical graphical user interfaces across all platforms and devices. Based on what we refer to as our “core” – a central solution containing all the required basic software modules and functionalities – we can create client-specific, customized applications at a reasonable cost, without needing to reinvent the wheel each time. The main benefit is that we can continue to issue new releases without any problem, as the customized elements are developed outside the main “core.”

The Core Is Already in Place

Clients want to be able to use software anywhere, anytime and on any platform. To accommodate them, a specially designed framework is required – like the djooze.crm solution developed by Gartenmann AG.

Depending on clients’ needs and requirements, we can use the available core modules to cover 30 to 70% of the project. We can use these components right off the bat to develop a standard software solution. You know exactly how much it’s going to cost, and you can be secure in the knowledge that there’ll be no budget changes along the way. The focus in terms of project security is therefore on the customized part of the software.
How do we ensure that the solution will do the job at the agreed cost?

One essential condition for success is that the provider and the user(s) work closely together, and it is precisely this aspect that tends to be overlooked a lot of the time.

Can We Control the Success of a Project?
Clients are all too often driven by fear of failure and underlying distrust in the software development process, preventing them from achieving the desired result. They typically want to attempt to define the software parameters themselves by presenting a very narrow list of specifications and requirements to the developers and having it all laid down in a contract. This means that, while the features, price, and penalties are all pre-defined, no actual workable solution is available yet. More often than not, the underlying problem – that is, the actual solution part of the software – is not even described in a comprehensible (or even measurable) way.
The client actually sees themself as the developer in the project, which has at least two fundamental disadvantages:

  • It stifles any kind of creativity in the software development process, with the developer’s role being reduced to that of a mere operative, whose own input is only needed to a limited extent. However, the intellectual and creative process involved in software development can actually lead to elegant solutions, which could end up reducing rather than increasing cost.

  • It prevents developers from responding to external changes. Good business software is not a static product – its technology and functionality continues to evolve, and it must be adapted to clients’ needs. Particularly during long-term projects, various factors in the organizational environment tend to change, and these changes must be incorporated into the software. For example, changes in a company’s structure may also change the software requirements, or, alternatively, the focus of the software might change following a change of staff.
    Clients must grant developers a certain amount of freedom so as to be able to create genuinely effective solutions. To avoid any complaints that this way of working involves too much uncertainty, trust between the client and the developer is essential. Is a series of reliable references available? Are the methods used solid and effective?

Collaboration Determines Success

There’s always a chance of differences of opinion arising between developers and clients, particularly when it comes to project methods. At Gartenmann, we know from our many years of experience that there’s really no need for conflict if you do things right. We use Scrum and Agile Software Development to achieve our purpose in a series of small steps. However, tools and consistent procedures are most important when working closely with clients throughout the long development period. We have seen a lot of changes in this field in recent years. Gartenmann currently uses Cloud Blogs and Wikis to describe all the various facets of the project. In addition to ensuring transparency, this also includes the client in the development process. This is clearly illustrated by the following example: If you want to benefit from customized software solutions, you need to become involved in the process yourself. Your own resources are indispensable when it comes to defining the processes and requirements and continuously testing and challenging them, and you must make yourself available to the developer for discussion.
In order to gain an edge over the competition, it’s important to know that customized software is not bought and sold like so many crates of beer, and even airtight contracts won’t prove to be of much use in the end.
The increase in the supply of customized software solutions has also increased the number of “soft” factors involved, which must all be considered as well. All of this could definitely make the unbiased opinion of an independent consultant worth your while.

Author: