<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
  <meta http-equiv="Content-Type"
 content="text/html; charset=windows-1252">
  <link rel="stylesheet" type="text/css"
 href="https://netbeans.org/netbeans.css" media="screen">
  <meta name="Tinuola Awopetu"
 content="NetBeans, NetBeans IDE, YasuTech">
  <title>NetBeans Day Partner Showcase - Yasu Technologies</title>
</head>
<body>
<h1><a
 href="https://netbeans.org/community/articles/javaone/2007/nb-day.html"><img
 alt="NetBeans Day Registration"
 src="../../../../images_www/javaone/2007/nb-day-200.jpg"
 style="border: 0px solid ; width: 200px; height: 99px;" align="right"
 hspace="5" vspace="5"></a>NetBeans
Day 2007 Partner Showcase</h1>
<div style="text-align: justify;"><span style="font-style: italic;">NetBeans
recognizes companies that have made significant contributions to the
NetBeans Project through its <a
 href="https://netbeans.org/community/partners/">Partner Program</a>
and with speaking invitations to NetBeans Day. Attend these Partner
sessions that showcase exciting and new plug-ins, and discover ways
to extend and get
the most out of the NetBeans IDE!</span><br>
<br>
</div>
<a href="http://www.yasutech.com"><img alt="Yasu Tech"
 src="../../../../images_www/partners/yasu.gif"
 style="border: 0px solid ; width: 115px; height: 70px;"></a><br>
<h4>Speaker: Vish Desai<br>
Session: <a href="http://www28.cplan.com/cc158/session_details.jsp?isid=288236&ilocation_id=158-1&ilanguage=english"><span
 style="text-decoration: underline;">Architecting Thin-BLL applications
using BRMS and Open-ESB</span> (S288236)</a><br>
</h4>
<br>
<img alt="Vish Desai, Yasu Tech"
 src="../../../../images_www/javaone/2007/yasutech-vish-desai.jpg"
 style="width: 175px; height: 184px;" align="left" hspace="5" vspace="5"><br>
<h4>What do you do at YASU Technologies?</h4>
Currently, I manage a large customer account in the Southern California
region for the YASU Professional Services Group. Before that, I was the
Business Development Manager, and before that, the architect and the
manager for the QuickRules product.
<br>
<br>
<h4>As a partner, how has your company contributed to the NetBeans
Project?</h4>
QuickRules is our primary product. It is a complete Business Rules
Management solution. We are now providing the main QuickRules rule
authoring environment on the NetBeans platform. The unique aspect is
the deep integration with the Open-ESB platform. Rules developed can be
directly integrated and deployed as composite applications enabling
faster application development, testing and deployment.
<br>
<br>
<h4>Tell us about your NetBeans Day Presentation.</h4>
The focus will be on how separation of the business logic results in
easier maintenance and faster application lifecycles. We will be
showing QuickRules (on NetBeans, of course) to enable easier business
rules management.
<br>
<br>
<h4>What's the top point that developers should know about your session?</h4>
A basic familiarity with the business rules paradigm would be useful.
The session will focus on driving business related application changes
using business rules.
<br>
<br>
<h4>What are the benefits to the community?</h4>
The main benefit is an understanding of how business rules fit into SOA
applications and how it helps in developing an agile line of business
applications.
<br>
<br>
<h4>What is the main message you want a developer to get after
attending your session?</h4>
That business logic so exposed will make it available to the business
analysts and domain experts, enabling the developers to concentrate
more on the core technical aspects. This would enable active
collaboration of ideas and business policy decisions which impact the
business and IT.
<br>
<br>
<h4>Why did you submit your session to be presented at NetBeans Day?
</h4>
We felt this would be a great opportunity to present the business rules
approach to a wide audience, especially to the people most involved with
it. We presented at NetBeans Tech Days in Hyderabad earlier this year. This
time, we will be focusing more on the benefits of using the Business
Rules approach and demonstrating the ease of building and integrating
with SOA applications.
<br>
<br>
<h4>What features do you enjoy working with in NetBeans?</h4>
The Platform by itself provides a lot of value for application
developers. The Java coding/refactoring capabilities are now getting
comparable to other vendors. The main thing I find very useful is the
integrated set of tooling which is provided. Everything, right from
visual development tools to core code level tooling is right there and
it works well.
<br>
<br>
<h4>How does working in Java compare with other technologies?</h4>
Better than anything else. A great VM, and the technology allows you to
integrate with almost anything out there.
<br>
<br>
</body>
</html>
