Introduction

The terms business analytics and business intelligence are often used interchangeably. Though they may at first seem similar, each has unique objectives and approaches. Business intelligence (BI) uses transactional and historical data to determine trends, analyze what has happened in a business, and report on outcomes. Business analytics, in contrast, creates a performance management framework and then uses data to drive predictive assessment, often via data mining, statistical modelling, and scenario analysis. And while the need for business intelligence is usually recognized and addressed, few organizations have yet recognized the need to integrate analytics into the corporate culture.

The result, if analytics are considered at all, is too often a fragmented and disjointed processes like that illustrated in Figure 1. Here analytical applications and business processes fail to interact – leading to both data-management and cultural challenges throughout the BI environment.

Figure 1: Typical BI and advanced analytics architecture

Disadvantages of current analytic frameworks

Siloed applications and processes

Analytical applications are designed to answer specific questions, but often have scarce or tenuous links to other business areas – so output from an analytic application may not be reflected in financial forecasts or operations. For example, a campaign management application generates optimized campaigns for a particular product. The resulting increased demand, however, may not be linked to inventory management and forecasting applications – resulting in an out-of-stock situation on a particular promotional product.

And analytic insights may not link to a business’s strategic plan. For example, suppose an analytic application identifies a market opportunity for a new product, but that opportunity may not be incorporated into the strategic plan. Conversely, analysis might identify a promising new market opportunity for an existing product – at the same time the strategic plan is phasing out that very product.

Meanwhile, a lack of write-back mechanisms may mean that insights from analytic applications are not automatically captured in transactional systems, making it difficult to close the loop from insight to action.

Finally, with multiple, disjointed systems comes significant additional costs for maintenance, plus significant time and effort required to reconcile data.

Inconsistent data

A lack of consistent data definitions and business rules across BI and analytic applications – say from supply chain analytics to financial analytics – makes it difficult to compare and act on results. For example, a company’s sales and commercial departments may define “sales revenue” differently, compromising data aggregation and analysis.

In addition, analytical models and their results may not be consistently persisted in corporate data repositories, making it difficult to provide a historical record for auditing and corporate learning. When analytics are performed locally within a specific tool, models and results are not retained in the data warehouse for future reference.

Sceptical business users

Operating independently, siloed analytic teams can push insights to end users with little to no involvement from actual decision makers in the business. Without collaboration, such teams miss valuable input that could drive insight and generate buy-in. Meanwhile, business users are often sceptical of analytic results that they have not helped generate.

Figure 2 illustrates the impact of disjointed process on the business. BI provides answers to “what happened?” while advanced analytics suggests improvements and answers “what if” questions. Ideally, the two processes complement each other – but if disconnected, they could actually work against each other. To ensure smooth operational execution, a business needs an advanced analytic system built on, or in conjunction with, its BI framework.

Figure 2: Current business processes for using BI and advanced analytics

Benefits of an integrated framework

As a best practice, SAP recommends an integrated framework that combines analytical applications with traditional BI solutions, underpinned by a holistic performance analytics framework. As the example in Figure 3 shows, such an integrated architecture has several benefits – better strategic alignment, consistent data definitions and use, and business users who embrace analytics to accelerate performance.

Figure 3: Future state best-of-breed architecture for integrated BI and advanced analytics

Strategically aligned application architecture and business processes  

If you start with a strategic top-down blueprint, all your BI and analytics applications can be architected according to a coherent set of solution requirements, scope, and vision, factoring in all inter-dependencies. Such a blueprint could potentially enable drill down from a strategic KPI at the top level of a balanced scorecard to the lowest degree of operational detail – describing, for example, how KPIs relate to operational metrics at the user level. A top-down analytics environment permits close alignment of a company’s analytics architecture with its enterprise performance management and strategic planning processes. Adding advanced analytics to the mix could also potentially enable you to forecast your performance under a variety of business scenarios. 

The top-down approach also identifies and builds in interdependencies among business areas, helping to balance worthwhile, but often conflicting, objectives of different business functions. For example, a bank’s sales team may want to increase the number of new loan customers while its credit department works to increase loan portfolio quality – objectives that could easily conflict. An integrated suite of analytic applications can eliminate such conflicts by optimizing decision making across conflicting constraints, ensuring smooth operational execution.  

Meanwhile, an integrated feedback loop can ensure that insights derived from an analytic system are picked up by the transactional system, so those insights can be acted on. For example, customers identified as profitable with a promising future lifetime value can be tagged in customer service applications so they receive higher service levels, increasing satisfaction and leading to greater purchase and retention rates.

Consistent and more accurate data

In this model, all insights are acted upon – and all actions are analyzed. Unlike current analytical applications in which outputs and insights are not persisted, in an integrated approach, new analytic insights are written back to the data warehouse each time. This provides a historical base for past decisions, improving both traceability and auditability. New records also become assets to corporate memory, enabling future learning.

In an integrated environment, too, all BI and analytics applications use data from the same corporate data warehouse and operational data stores, ensuring consistent data definitions throughout the company. Data sourced from data warehouses also goes through standard cleansing and quality processes – improving data quality while drastically reducing both data inconsistency and lack of confidence in analytic outputs.

Collaborative culture 

The integrated approach enables a single umbrella team – such as an analytics competency center – to own all analytics and BI applications and initiatives within the organization, with sub-teams dedicated to specific business areas. This approach facilitates a culture that more closely integrates analytics into standard operational processes, while fostering collaboration between line of business users and the analytics team – to create analytics that truly improve performance.

In a best practice environment, business users interact with the analytics team to define the questions that need answers and validate analytic insights. Business users then feed the real-world results back to the analytics team, further fine-tuning the process. This culture change benefits both teams as well as the organization as a whole.

Figure 4 shows how insights from embedded analytics can be disseminated to transform a company into an effective learning organization.

Figure 4: An integrated framework for BI and advanced analytics supports best-of-breed business processes

Conclusion

If you have a portal which exposed to internet, you may want to use captcha for bots. So in this blog I will implement reCaptcha. Why do I choose reCaptcha? Because it is easy to implement and you dont need to implement a lot of things to work. Let's do it!

First you have to modify logon page. You can find it solution here: http://nwturk.com/blog/2011/06/06/changing-logon-page-on-netweaver-7-3/

You have to import jar files of reCaptcha (link). After importing files modify logonPage.jsp file for reCaptcha.

-Import reCaptcha:

<%@ page import="net.tanesha.recaptcha.ReCaptcha" %>
<%@ page import="net.tanesha.recaptcha.ReCaptchaFactory" %>

-Add reCaptcha code for displaying captcha. You can customize it for your need:

<%
	ReCaptcha c = ReCaptchaFactory.newReCaptcha("your public key", "your private key", false);
	out.print(c.createRecaptchaHtml(null, null));
%>

Be careful adding these code block between <sap:form type="logon"></sap:form>

We have done about this part. Now it is time to implement login module. You can get more information about login modules from this link. Now you have more information about login modules after link. Implement the class and add a new method to get response.

	private String getRequestValue(String parameterName)
		throws LoginException {

		HttpGetterCallback httpGetterCallback = new HttpGetterCallback();
		httpGetterCallback.setType(HttpCallback.REQUEST_PARAMETER);
		httpGetterCallback.setName((String) parameterName);

		String value = null;

		try {
			_callbackHandler.handle(new Callback[] { httpGetterCallback });

			String[] arrayRequestparam =
				(String[]) httpGetterCallback.getValue();

			if (_decodeRequestParameter) {
				value = URLDecoder.decode(arrayRequestparam[0], "UTF-8");
			} else {
				value = arrayRequestparam[0];
			}

		} catch (UnsupportedCallbackException e) {

			return null;

		} catch (IOException e) {
			throwUserLoginException(e, LoginExceptionDetails.IO_EXCEPTION);
		}

		return value;
	}

You can call method with these parameters. (example: String challengefield = getRequestValue("recaptcha_challenge_field");

And also you need client ip address. Here is the moethod to get ip address:

	private String getIPAddress(){
		String clientIp = "";
		try{
			HttpGetterCallback hgc = new HttpGetterCallback();
			_callbackHandler.handle(new Callback[] { hgc });
			hgc.setType(HttpCallback.CLIENT_IP);
			clientIp = (String)hgc.getValue();
		}catch(Exception ex){

		}
		return clientIp;
	}

If you have a reverse proxy you get ip address of it. So you have to configure it to get clients ip address.
After you get the parameters for reCaptcha check them:

import net.tanesha.recaptcha.ReCaptchaImpl;
import net.tanesha.recaptcha.ReCaptchaResponse;

ReCaptchaImpl reCaptcha = new ReCaptchaImpl();
reCaptcha.setPrivateKey("your_private_key");
String ipAdress = getIPAddress();
String challenge = getRequestValue("recaptcha_challenge_field");
String uresponse = getRequestValue("recaptcha_response_field");
ReCaptchaResponse reCaptchaResponse = reCaptcha.checkAnswer(ipAdress, challenge, uresponse);
if (reCaptchaResponse.isValid()) {
	// do your valid login work
}else{
    // do your invalid login work
}

Before NetWeaver 7.0 EHP2, it used to be difficult to analyze memory problems that were really specific to an ABAP Web Dynpro application and not just related to some mammoth internal table deep down in the application logic.

The problem was that it was hard to see the forest for the trees in the Memory Objects ranking lists:

• What objects belong to the ABAP Web Dynpro runtime?
• What objects belong to the Web Dynpro application?  
• What belongs to the backend infrastructure? 

The old memory analysis functions could not tell the difference between one type of object and another.   

Here’s an example:

In the New ABAP Debugger, the application-specific memory analysis tool for ABAP Web Dynpro brings some order to the situation and lets you analyze the memory consumption of your ABAP Web Dynpro application much more easily and efficiently.

There is also an extra filter option that lets you hide memory objects that do not pertain to the Web Dynpro application and runtime. In this case, that includes objects that belong to the ESI framework (web service infrastructure).  Here, you can see the effect of the filter – it lets you concentrate exclusively on memory objects that belong to ABAP Web Dynpro.

In the old R/3 days, ABAP programmers rarely needed to analyze memory consumption in their programs.  The simple and robust ABAP memory model made it very hard for anyone to program a serious ABAP memory leak.

With the addition of more types of dynamic memory objects – not just internal tables, but also strings, anonymous data objects, boxed components – and a trend toward transactions that live longer, it’s now possible to write an ABAP program that can run into memory problems.

Since ABAP programmers can no longer ignore memory consumption, the ABAP Workbench has greatly enhanced the memory analysis tools in the New ABAP Debugger and in the Memory Inspector (transaction SMI or S_MEMORY_INSPECTOR).

This weblog showcases the enhancements that come with EHP2:

• The Dominator Tree (or keep-alive tree) for containment hierarchies in memory objects – which runtime entity is keeping which memory object alive. This new analysis tool is offered in both the New ABAP Debugger and in the Memory Inspector. 
• The Memory Object Explorer in the New ABAP Debugger, for navigating up and down through the memory objects in the keep-alive hierarchy of objects. Starting from any memory object, you can navigate up to its parents or down to its children, and you can take a look at the contents of each memory object.
• A separate weblog shows you the new Application-specific memory analysis tools in the New ABAP Debugger – for looking at the memory consumption of ABAP Web Dynpro applications. There is also a similar tool for analyzing Web Service / HTTP applications.

You may also notice that doing memory analysis in the debugger is much more comfortable, and that we have made improvements in the user interface in the Memory Inspector as well. But we do not go into these UI changes in detail, nor will we look at the Memory Inspector transaction in this blog.

The New Features in Practice in the Debugger

You do memory analysis usually for one of two purposes:

• You want to see how big your program – or objects in it - are in terms of memory consumption. Is it bigger than you expect?  Usually you’re in the New ABAP Debugger when you do this.
• You want to see whether you have a memory leak. Does the memory consumption of your program change over time?  Or – how did it get so big that it dumped because of lack of memory – this question also sometimes comes up.

Usually, you’re comparing memory snapshots in the Memory Inspector (transaction SMI) when you’re doing this type of analysis.

Let’s see how the new memory analysis features work if you are in the debugger, just checking how much memory your program uses. Maybe you’re just being cautious in doing this checking – or maybe you’ve learned:  a long-running transaction or service with lots of dynamic memory objects means, you better check the memory consumption before your customers find out about it for you.  What you see here on the new memory analysis features applies just as well in the separate Memory Inspector transaction.

A Comfortable Quick Look at Memory Consumption – The Memory Analysis Tab

You don’t have to switch to a memory analysis tool anymore to see how much memory objects in your program are using.  There’s a new Memory Analysis tab in the new ABAP Debugger, on the Variable Fast Display. Just switch to the tab, click on a variable in your program, and you can see how much memory the object uses.

Here we have two tables that have the same number of rows, and we happen to know that they contain the same data - except that IT_CUSTOMERS contains extra data.  Even so, IT_CUSTOMERS is smaller in memory.  How is the difference explained?   Does IT_CUSTOMERS offer a more efficient way to organize the table?  A closer look shows that we don’t understand how IT_CUSTOMERS is organized. The table statistics don’t seem to match the memory size.

• The size of table IT_SCUSTOM is okay – 4637 rows of 16 fields with a row-length of 464 bytes is close to the Bound Used Memory (bound memory is the memory that would be freed if the table were cleared) plus some management overhead.   The table simply is that big.
• The size of IT_CUSTOMERS is puzzling. It has the same number of rows as IT_SCUSTOM but a row length of 32 bytes. No way that the table body itself comes close to 1.7 million bytes of bound memory.

Analyzing Table IT_CUSTOMERS with the Memory Analysis Tool

To study table IT_CUSTOMERS, you activate the Memory Analysis Tool by choosing the New Tool or Replace Tool button, opening the Memory Management folder, and clicking on Memory Analysis.

The tool that was available before EHP2 was the Memory Objects view, shown below in its form in NetWeaver 7.0 EHP2. This tool shows you the memory objects of the program (the representations of dynamic variables in the memory management system) ranked by size. 

Memory Objects also shows you which variables reference each memory object.  But the view does not help us to understand the differences between the IT_CUSTOMERS and IT_SCUSTOM tables. Essentially we just have an unstructured list of memory objects ranked by size.

Here’s where the new Dominator Tree view (below) shows how useful it is.  In this view, it’s immediately clear how IT_CUSTOMERS is structured. The rows are so short because they contain only an object reference. The CUSTOMER objects in the table contain, by the way, a further object, ACCOUNT.  The CUSTOMER objects are also keeping several strings – variables NAME, ADDRESS, and CITY - alive.  The bound storage of the table is so high because the table is keeping all of the customer object hierarchies alive.  (Without the references from IT_CUSTOMER, the ABAP garbage collector would clear the objects away and free the memory.)

The organization of the table is now clear. Where does the advantage in memory use of the IT_CUSTOMERS table come from, compared to table IT_SCUSTOM? 

To find the answer, you could copy the name of a CUSTOMER object into the clipboard, and start the Memory Object Explorer (available only in the debugger, not in the Memory Inspector). In the Memory Object Explorer (below), we can follow edges from the CUSTOMER object to its children, all of the objects that it references.

The Dominator Tree shows only strings and instances of classes that belong to the bound storage of each CUSTOMER class object. These are the objects that CUSTOMER keeps alive. The Memory Object Explorer, by contrast, also shows objects that are referenced by more than one CUSTOMER instance, memory objects that are in effect shared. Can it be that sharing of objects accounts for the reduced storage use?

We follow a CUSTOMER object to its referenced objects and then check some of the referenced objects themselves in the Explorer. COUNTRY looks like a good variable to check for sharing among multiple CUSTOMER objects. So we go from string {S:S9} ADDRESS-COUNTRY up the memory hierarchy – Higher-Level Memory Objects - to see the parents of this string, objects that reference this string.

And in fact, as you can see below, the more efficient storage use in table IT_CUSTOMERS than in IT_SCUSTOM could be due to massive sharing of string objects in memory.  There are many CUSTOMER objects from our table that reference the same COUNTRY string.

The IT_CUSTOMERS table design takes advantage of the fact that string variables that have the same content share a single memory object.  (See ‘value semantic’ in the ABAP Online Help (transaction ABAPHELP or at help.sap.com).  ABAP gives a string or other value-semantic object its own memory object only on an as-needed basis – if the string is changed.

In many applications, a table like this list of customers is rarely changed, but is used instead to guide processing. In this case, it may make sense to make use of memory object sharing to reduce storage consumption.  In this application, CUSTOMER attributes like the country-of-residence reference the same string, as long as the same country is being referenced.  You can check out whether the strategy is really worthwhile – when filling a table, when reading a table, in the event that object attributes are changed – by doing some testing of the alternatives in the ABAP Runtime Analysis, transaction SAT. (See the weblogs by Olga Dolinskaja on the new SAT.)

An advantage of doing memory analysis in the debugger is that you can see what the value of the variables is. This is something that you cannot do when you analyze memory snapshots in the Memory Inspector (transaction SMI).  A double click on string {S:S9} above shows us what country all of those customers inhabit:

But the Memory Inspector, in turn, has the advantage of being able to compare memory snapshots and show changes in memory use over time. That’s an invaluable capability for checking for leaks in a long-running ABAP application.

Seems there is no difference; at least as of BW 3.0 and above. According SAP Note 316329 - Master data table locked locks on master data were handled differently in BW versions 2.0 – 2.1C. The difference is that not standard SAP lock mechanism was used but there was BW specific locking mechanism used. This was however removed in version 3.0 and subsequent. Therefore transaction RS12 is still in BW just because of BW history. As you can see the same ABAP report (RSENQRR2) is called by both TAs.

SAP buzzword glossary released as iPhone App

During one of our technology evaluations we have created a SAP Glossary iPhone application containing several "SAP buzzwords" and corresponding explanations - nothing big but maybe useful for sales guys catching up some buzzwords during lunch and looking these up directly instead of talking about unknown technology...
If you want to provide additional content feel free to contact us, we are willing to extend contents, feedback is taken seriously!

You can download the application within the App Store, it's called "Resource Sales Glossar"

(iTunes Link)

Currently the glossary is base on German language we are planing to provide an English version as as soon as possible...

Cheers, Florian!