Category Archives: bheudek
From 8th to 10th October we’re going to be at The South Summit. The South Summit / Spain Startup Summit is a meeting point of the most promising startups with the leading international VCs, business angels and accelerators.
Spain Startup Summit connects the entrepreneurial talent facilitating the uprising of opportunities and potential agreements as well as fostering a network for knowledge sharing of the big corporations withan endless source of innovation: the startups.
It’s time for networking!
We are travelling to Barcelona to attend Next Bank Europe. Next Bank Europe is a collaborative conference that covers innovation, transformation and startup-driven disruption in financial services in Europe. Next Bank Europe recognizes that the new competitive environment resulting from exponential growth of new technologies, the rapid change in customer behavior and new business models presents a unique opportunity for players inside and outside the industry in an environment which is uncertain and volatile.
Next Bank Europe is an event for Europe where traditional players like banks, consultancies and technology vendors will share the stage with alternative players like startups, digital ecosystems and players from other industries. All of these players, the old and the new, from all over Europe will come together to create a new community of innovators in financial services who will together explore the real future of the financial services industry and the big ideas that will forever change the industry in the region.
It’s, definitely, a great showcase!
Given this scenario, automation is presented as the unified solution the problem requires. Features such as semantics and process automation can offer their benefits to the changes that will be performed in different areas: business services, online services and data management.
The FinTech phenomenon involves changes in many different areas with many different technologies. This leads to a complex scenario where the problem must be addressed from a global perspective, otherwise there is a risk of running into an operational and technological chaos.
New techniques in Software Automation suggest this methodology as a good solution to tackle the challenge.
Software automation raises the technical solution to the conceptual level where operates the business. This higher point of view provides the more comprehensive and unified approach required to address FinTech changes.
Working in a more abstract level allows not only the automation of technical process but also the automation of traditional business processes. Decision engines, risk based pricing, default prediction and fraud detection are examples of processes that can be improved under this perspective.
The new way of defining programming languages, based on the concepts that structure them, opens the door to Knowledge Representation. This discipline, a traditional field of artificial intelligence, is increasingly being applied to data processing (visualization, searching, analysis, decision making …) and in the future will be essential to any process of analysis and interaction, either with customers or with other systems. XBRL– eXtensible Business Reporting Language – and FIBO – Financial Industry Business Ontology – are examples of semantics applied to financial industry
3.Less technical complexity.
Again, the higher level of abstraction of the languages allows to solve, automatically, much of the technical details inherent to the different solutions. This automation of complexity results in quality, safety, standardization and other software features.
Having the control of programming languages, the same development can be translated into multiple platforms without having to perform a new project for each new device.
Once the programming languages are closer to the business, developers can focus on providing a solution from the business point of view and not from a technical perspective. It also breaks down the traditional communication barriers between the development areas and the rest of areas of the company.
FinTech is working on multiple areas in which the automation can provide advantages. We can group them into three main blocks: business services, online services and data management.
Meeting customers’ new demands and productivity improvement are objectives that are moving the industry to act over their more traditional structures. Automation provides advantages on:
Portfolio management. The automation of processes provides a more streamlined management. On the other hand, the semantics allows a unified management of heterogeneous portfolios and the integration of external ones.
Compliance. Semantics, along with the use of business-oriented languages facilitate audit analysis processes and the deployment of its documents. Beside this, process automation is the best way to solve compliance issues.
Legacy systems. The higher level of abstraction provides a straightforward way to design interfaces with legacy systems.
The emergence of new devices, the improvement of communications and a new digital culture have made institutions open their doors in order to supply a more interactive management to their customers. Again automation provides benefits in this area:
Financial education. Semantics gives the systems documentation and visualization capabilities facilitating its handling and understanding.
Personal Management. As a result of the previous points, the customer can perform a more personal management of their data and assets. As mentioned, the semantics play a major role in the interaction with the customer.
New Banking. Multi-platform, semantics and process automation enable new business lines such as personalized offers, payment platforms, crypto-currencies, proactive risk analysis and others.
A more interactive relation with the customer and the new methodologies to process that information have revolutionized traditional CRM techniques and the whole data management. Automation benefits next areas:
Reporting. Semantics is increasingly being a part of reporting. XBRL is a good example.
Security. Process automation enhances the security in data processing.
Big Data. We can summarize – this point would require an entire article – that semantics, process automation and a higher level of abstraction allows, on one hand, to handle the variability of the data and, on the other, mitigate the risks associated with the unstructured schemas of Big Data.
The financial sector is facing one of the greatest technological challenges in its history, involving changes in many different areas with many different technologies.
Software automation provides the global and unified approach required in this scenario, otherwise, individual approaches can lead the companies to a technological landscape very hard to manage.
Although the Web was not originally designed for a dynamic and bidirectional interaction, the emergence of new technologies and the improvements in modern browsers, allow us to design applications ever closer to traditional desktop applications.
These web applications are different from web pages and web applications (e-commerce, for example) because their users need a more continuous, long and agile interaction with the system. For example, a call center user (customer service, technical service, collection management and others).
Requirements for a desktop web application
- Keyboard. It is essential that the application can be governed by the keyboard and not only by the mouse. Tab, enter, arrows and others keys.
- Performance. An appropriate speed is required not only for a good user experience but also for productivity matters.
- Security. These applications deal with very sensitive data.
- No blinking effect. Content loading must be partial and dynamic. Continuous refreshment of the whole page produces an uncomfortable and unhealthy effect.
- Nice and standard layout. Content must be clean and never overloaded (kitsch).
- SPA pattern (Single Page Application). The app is a single initial page where further content is loaded dynamically. It allows us to implement policies such as: initial loading of files (js, css, images, etc), shared session control, increase processing on the client, etc..
- Standard layout across the whole application. The screens, buttons, tabs, data grids and other controls should have a common look&feel.
- JavaScrtipt Framework. Required to standardize the interface and provide it with the services to manage controls and windows. For security and adaptability reasons, the best choice for a framework is in-house development and single-object encapsulation.
- Handle keyboard events. The framework must provide this feature.
- AJAX. Dynamism.
- Minimize network traffic. Data transferred from the server should be as few as possible, even if it means more processing on the client side. Standards as JSON are recommended.
- Modal windows. They improve the user experience and the application dynamism.
- Use sprite images. Load all images on a single connection.
Whenever we deal with desktop applications, we must meet some strict requirements, as they are tools in which users will spend much of their time.
New devices may appear and also new ways to interact with systems, but when it comes to interaction, traditional requirements as keyboard, performance, safety and user experience are a must have.
View all Academic Posts.
- Software Automation. Introduction. . First approach to the technology.
- Why code generation? . Explains the reasons to choose code generation in order to improve the software development process.
- Best Practices in Code Generation . Once we know what it is, we show some tips to generate code properly.
- 10 Benefits of Code Generation . List of benefits.
- DSLs . Following the path of automation, we explain what are Domain Specific Languages (DSL) and their benefits. The DSLs are necessary if we want our automation process to reach the highest level.
- Language Workbench . In order to design and use DSLs we need tools that provide these services. These tools are technically known as Language Workbenches, and they can also provide us the entire development process integration and even open the door to knowledge representation.
- Knowledge Representation and Software Automation . A more in depth analysis about this subject.
- Language Designers . Requirements of this new profile in sotfware development.
- Frameworks: the Better Half of Code Generation . Introduction and benefits of Frameworks and collaboration with code generation.
- Automation: the Whole Process . Compilation of the development process.
We will use the Language Workbench, once the languages (DSLs) are defined, to perform the programming process, and along this process we will generate code to compile it and check the result in the final application.
Whenever we use languages that support partial classes, abstract classes, generic types, delegates, etc., we can generate code safely because we will do it in separate files without risk of overwriting other code such as manual or FW code. In other kind of languages we will need to use other strategies to mitigate this risk.
Merging with Frameworks
As in the previous case, depending on the final language in which we generate, this process will be more or less simple. In the case of FW-friendly languages (abstract and partial classes, delegates, etc.), this merging process it is provided by the syntax itself.
In other kind of languages we will need to adapt some functionalities or some configuration files, which can also be automated by the LW.
In most cases there will be certain features that may not be automated; otherwise our DSLs will be too complex, losing, as a result, their power.
In order to integrate the whole process on the LW, the best scenery is defining these extension languages on it, but, If this is not the case, we will program these extensions in the final language where we generate the code.
If we program the extensions in the final language, the most suitable way is to give the generated code a FW structure. With this extensible approach we avoid the risk of loss or replacement of the code.
Once we have all the code: FWs, generated, manual extensions, configuration files and other, an automatic process performs the merging -if necessary-, the compilation and the deployment.
Depending on the operating system will have different tools to do it, but normally we will use batch files to program all the steps of this process.
In order to conclude, we want to remark that we have explained the methodology the way is done nowadays, but it is worth noting that it is a constantly evolving technology that aims to integrate the whole process in the LW: languages, debug, merging, building, etc.
View all Academic Posts.
They can be mistaken with libraries but the approach is totally different. These are the FW key distinguishing features:
- Inversion of Control. The flow of control is dictated by the FW and not by the application using its services. This is also known as the Hollywood principle: “don’t call us, we’ll call you”.
- Extensibility. Certain functionalities of the FW are not “closed” – as it happens in libraries -, on the contrary they are designed to be extended in order to solve the particular problem.
- Default Behavior. FWs have a default behavior, which defines the flow of control. As seen before, the extensions allow us to adapt this default behavior to the particular problem that each application solves.
Technically, depending on the programming language, there are different ways to implement them. If it’s allowed by the language, abstract classes, partial classes, delegates and generic types are the best features to do it. Otherwise there are other strategies such as interpreters, intermediate functions – kind of visitor pattern- to solve the extensible call and others.
Benefits in code generation
These are some of the features that recommend the use of FWs:
- Extensible. The work is divided in two main parts, which makes easier the definition of the code generator.
- Structured. Designing the generic part on one side and extensions on the other, provides a more structured architecture.
- Security. Handmade code and generated code are in different files, and this mitigates the risk of loss or replacement.
- Reusable. Once the FW is defined it can be used in different projects, again making easier the development of the generator.
- Readability. The separation of the generic flow of control and the extensions facilitates code reading.
When code generation is approached for the first time, it is often thought that the system must be 100% generated. After that, we realize that this is not only a complex approach, but also a design error and an unbalanced distribution of work.
To achieve a well-designed architecture and a good distribution of work frameworks are the better half of our generated systems.
Finally, it’s important to remark that designing the generated code as a framework structure is also a good practice, because it allows us to implement – by extending – those manually features that we don’t want to automate and it provides systems that can be extended by a software ecosystem.
View all Academic Posts.
The designing of a good language is the main part of the process as it will be the tool of the developers and it will support the semantic intelligence of the system.
Furthermore, since the concepts of the language structure the model itself, before the design it is necessary to know deeply the domain being modeled.
Features of a good language
- High level of abstraction. The higher the level the more powerful will be the language and higher the semantic meaning of the concepts. Also, a high level of abstraction denotes a deep knowledge of the domain to be modeled.
- Simple. It should be easy to use and read. A simple language is often synonymous with a high level of abstraction.
- Different levels of complexity. While it should be simple, it should also allow ways to define deeply details by those who need it.
- Aesthetically pleasing.
- Semantically powerful. In order for a language to be productive, it is only required to provide its concepts with a graphical representation and translations to traditional languages, but if we really want it to be powerful, we must give the concepts other semantic interpretations: auto documentation, auto validation, inference rules, etc.
From the features of a good language we can derive the requirements:
- Business oriented. Getting a deep knowledge of the domain, in order to design the language, requires a high concern in all the processes that govern it.
- Abstraction skills. Once the domain is known, analytical skills are required in order to identify, with the highest possible level of abstraction, its purest essence.
- Focused on semantics. The language has to be designed under the perspective of finding concepts with a high capacity to represent knowledge.
- Qualities focused on simplicity and aesthetics.
This new development paradigm requires a particular profile to design languages, where not only the former analytical skills are important but also the capability to provide usability and knowledge-representation capacity to the language.
At first, it may seem a complex task but, after all, is part of the evolution of technology where the profiles that contribute most are those with greater capacity for abstraction.
View all Academic Posts.