Since its foundation, HSG has been a leader in Business Rule Management Systems Training and Consulting services by way of the Blaze Advisor Rule Engine.  Over the years we have provided such services to many of the worlds largest corporations and government institutions whose respective backgrounds include credit card processing, banking, insurance, health and medicine and more, much more.  Such training and consulting services have included:

Create a wrapper object model in either Java, .NET or XML

Identify and catalog business rules

Develop a rule architecture within Blaze Advisor that isolates rule repositories as they relate to functionality and corporate policies

Configure, develop and implement a variety of interfaces to the rule engine from disparate systems ranging from mainframe applications written in Cobol to UNIX/Windows applications using Enterprise Java Beans, Windows Services, Web Services, Fat Clients, Java Messaging Services and Web Applications.

Review and update code to boost efficiency either by way of

    Removing functions calls within conditional statements

    Ensuring that database calls are essential or can be rearchitected in some other manner

    Employing the rete algorithm where necessary

    Paring down extensively large class models

    Deploying such appliations in multi-threaded systems

·         ...

Call us if you:

    are in need of Blaze Advisor Expertise
    are developing SMEs in Blaze
    want to speak directly with an expert (no placement agencies)
    want an affordable alternative to FICO
    want to work with an industry leader

Not too long ago, Apple added something phenomenal to the iPhone OS: a dashboard screen. If you have a Macintosh computer, you may be familiar with the dashboard that is available (regularly) by pressing F4. Otherwise, you can draw similarities to your Windows 7 Dashboard on the right hand side of your desktop, that shows you updates on your applications and widgets you add to it. Finding your dashboard on your iPhone is just as easy: just put your finger on the top of your iPhone screen, and drag down.

Here, in your dashboard, you will see all of the updates that has been pushed into such by your applications that desire to send you messages: things like new text messages, new updates to your subscribed magazines, your messages on payment applications. If you have reviewed a message set by an application by tapping on it, that message will automatically become deleted. However, if you don’t desire to go into the application to delete it, simply tap in the top right on the bar that categorizes that particular application, and tap again to clear all of the messages set by that application, and clear up your dashboard.

But, your dashboard isn’t all about your application. You not only get your messages, but you get important information set by default applications, such as the weather. If you don’t feel like scouting out your weather application amidst all your applications you have downloaded, simply go into your dashboard, and find out the forecast for the whole week, just by a simple swipe. Not only that, tickers for your stocks are displayed near the bottom of the dashboard.

It is said that spoken languages shape thoughts by their inclusion and exclusion of concepts, and by structuring them in different ways. Similarly, programming languages shape solutions by making some tasks easier and others less aesthetic. Using F# instead of C# reshapes software projects in ways that prefer certain development styles and outcomes, changing what is possible and how it is achieved.

F# is a functional language from Microsoft's research division. While once relegated to the land of impractical academia, the principles espoused by functional programming are beginning to garner mainstream appeal.

As its name implies, functions are first-class citizens in functional programming. Blocks of code can be stored in variables, passed to other functions, and infinitely composed into higher-order functions, encouraging cleaner abstractions and easier testing. While it has long been possible to store and pass code, F#'s clean syntax for higher-order functions encourages them as a solution to any problem seeking an abstraction.

F# also encourages immutability. Instead of maintaining state in variables, functional programming with F# models programs as a series of functions converting inputs to outputs. While this introduces complications for those used to imperative styles, the benefits of immutability mesh well with many current developments best practices.

For instance, if functions are pure, handling only immutable data and exhibiting no side effects, then testing is vastly simplified. It is very easy to test that a specific block of code always returns the same value given the same inputs, and by modeling code as a series of immutable functions, it becomes possible to gain a deep and highly precise set of guarantees that software will behave exactly as written.

Further, if execution flow is exclusively a matter of routing function inputs to outputs, then concurrency is vastly simplified. By shifting away from mutable state to immutable functions, the need for locks and semaphores is vastly reduced if not entirely eliminated, and multi-processor development is almost effortless in many cases.

Type inference is another powerful feature of many functional languages. It is often unnecessary to specify argument and return types, since any modern compiler can infer them automatically. F# brings this feature to most areas of the language, making F# feel less like a statically-typed language and more like Ruby or Python. F# also eliminates noise like braces, explicit returns, and other bits of ceremony that make languages feel cumbersome.

Functional programming with F# makes it possible to write concise, easily testable code that is simpler to parallelize and reason about. However, strict functional styles often require imperative developers to learn new ways of thinking that are not as intuitive. Fortunately, F# makes it possible to incrementally change habits over time. Thanks to its hybrid object-oriented and functional nature, and its clean interoperability with the .net platform, F# developers can gradually shift to a more functional mindset while still using the algorithms and libraries with which they are most familiar.

Related F# Resources:

F# Programming Essentials Training

When making a strategic cloud decision, organizations can follow either one of two ideologies: open or closed.

In the past, major software technologies have been widely accepted because an emerging market leader simplified the initial adoption.  After a technology comes of age, the industry spawns open alternatives that provide choice and flexibility, and the result is an open alternative that quickly gains traction and most often outstrips the capabilities of its proprietary predecessor.

After an organization invests significantly in a technology, the complexity and effort required steering a given workload onto a new system or platform is, in most cases, significant. Switching outlays, shifting to updated or new software/hardware platforms, and the accompanying risks may lead to the ubiquitousness of large, monolithic and complex ERP systems – reason not being that they offer the best value for an organization, but rather because shifting to anything else is simply – unthinkable.

There’s no denying that these are critical considerations today since a substantial number of organizations are making their first jump into the cloud and making preparations for the upsetting shift in how IT is delivered to both internal and external clientele. Early adopters are aware of the fact that the innovation brought about by open technologies can bring dramatic change, and hence are realizing how crucial it is to be able to chart their own destiny.