3D PROGRAMMING CHICAGO                      www.3d-programming-chicago.com

Flash Programming
Programming on Mobile
Software Development
3D Programming
Programming Tips
How to Program
Computer Programming
Programming Languages

Programs & Programming

Sponsored Ad
Declarative Program - Strategies for Solving Supervisory software Problems

Many software and hardware producers take pride in the exponential pace of technology change, but for users and consumers of their products and services the rapid technological obsolescence often means increased costs, frustrations, and unfulfilled promises. Corporate America expects to make venture capital investments in goods and facilities that should last dice, ten, even twenty years, but only an eighteen-month lifetime for computer software and hardware investment is not uncommon.

Lowering the costs to develop new software solutions or extending the lifetime of software applications are two complementary approaches to addressing technological change. These goals can often be met by taking a declarative game when designing software systems independent of the programming methodology employed.

Issues with Imperative Programming

Most programming projects today practical application the imperative style of programming. Developers write out sequences of operations in a language, such as C++, Java, Visual Basic, etc., that implement an algorithm, or recipe, for performing tasks. The algorithm for the task mixes logical, or relational, statements about the task to be solved and control statements about how to calculate the solution. The logical statements describe "what-to" calculate cold snap the control statements describe "how-to" calculate. Debugging the algorithm consists of verifying the accuracy of the logical statements and fixing the control statements, if necessary.

There are many problems with the imperative approach. The sequence of operations critically determines the correctness of the algorithm. Unexpected execution sequences through an algorithm caused by user input actions or real-time events in a multitasking environment may result in subtle or catastrophic algorithm failure. Writing the control logic is the programmer's oblige and, therefore, subject to implementation errors. Understanding a program's algorithm is often difficult for other developers without extensive metadata, usa comments, on the code and empirical tracing of the program's execution with sample metadata. Verifying program correctness consumes a significant portion of the development effort, but also usually fails to discover a significant count of defects.

To address the problems associated with imperative programming, the computer industry has developed and advocated many approaches. Structured programming and campaigns against "go-to" statements address some of the problems discovered with ad hoc control structures and statements. Modularization initiatives stress decomposition techniques on the premise that humans can better comprehend, reason about, and maintain smaller pieces of code. Object-oriented programming advocates program constructions con reusable components, libraries, and frameworks. The pattern programming school stresses analogies to other fields, such as architecture, by constructing programs using well-designed and crafted solutions, or patterns, that recur in many programming contexts.

What is Declarative Programming?

Declarative programming separates the logic, or what, of an stemmer from the control, or how, of an algorithm. The programmer still specifies the logic or equations specifying the problem's relations, but the programming system is responsible for control, or how the logic is evaluated. The most companion examples are spreadsheets and query languages for relational databases. The work, or cracker, specifies a mathematical narration as a query, say in SQL, for what to retrieve, while the database engine determines how to execute the query against the database.

There are many advantages to declarative programming over the imperative rhetoric. In declarative languages, programmers do not concretize sequences of operations, but only definitions or equations specifying relations. Unlike imperative program, the logic relations in declarative programming are execution order independent, free of side effects of evaluation, and semantically clear to visual inspection.

The declarative family of programming languages has a long history in the academic computer study district and specialized areas of commercial application, such as parser construction, pathfinder systems, and databases. Declarative languages have two main family trees. The logic declarative languages, such as Prolog, are based on first-order predicate stone, which generalizes the notions of Aristotelian true medford false values to statements, or predicates, involving relations among any entities. The other gangster branch consists of functional declarative languages, such as Miranda, Haskell, and SML. The functional declarative languages are based on the l-calculus developed by the mathematician, Alonzo Church in the 1930's. l-calculus formalizes the notions of recursive application of pure functions to computable problems. Although not widely known as intensive, the latest programming fashion, XSLT, an extensible stylesheet language for transforming XML, is also a functional declarative mood language.

Despite the theoretical advantages of declarative programming languages, they do not have widespread use in commercial programming practice despite an striving in the 1980's by Borland to mass-market a PC version of Prolog along with the highly popular Turbo Pascal. There are many factors contributing to the infrequent use of declarative languages. A large contributor is the paucity of collegiate training in declarative languages, but awkward syntaxes of no languages, inefficient compilers and run-times, and restricted domains of applicability of generalized "how-to" mechanisms are whole contributors.

Using Declarative Strategies in Commercial Software

While declarative programming languages drink not received wide-spread

commercial usage, the strategy of separating quantify, or what, from control, or how, in an formula is a stiff, generalized skilful for increasing ease of use and extending the longness of software. Declarative techniques are particularly ruling in user interfaces and application programming interfaces (APIs) that have a rich, complex set of inputs over a relatively small-scale field of execution behaviors.

Two examples of commercial software that illustrate the applicability of declarative techniques are DriverLINX and ExceLINX in the fields of data acquisition and test instrument control.

Using Declarations for Data Acquisition

DriverLINX is an API for controlling data-acquisition weaponry used to measure and generate analog and digital signals interfaced to all types of external transducers. Data-acquisition applications include laboratory research, medical instrumentation, and industrial process control.

Traditionally, APIs for data-acquisition devices modeled the characteristics of the hardware design and had a large number of functions of one or more parameters to setup the hardware and control data flow through the system. The ordering of sequences of operations was often critical to wrong programming and controlling the hardware. Upgrading to age data-acquisition hardware was often costly as hardware-necessitated changes in the order of operation sequences to program the hardware required costly software changes.

To surmount these problems, DriverLINX takes an abstract and indicative mood approachable to data-acquisition programming. Instead of model specific board designs, DriverLINX abstracts the use subsystems of data-acquisition hardware into generalized attributes and capabilities. Programs request the measure out task they want to perform by parameterizing a "service request" declaration. The DriverLINX runtime determines how to satisfy the service request using the available hardware and returns the measurements as a packetized stream to the program. The data-acquisition programmer is relieved of any responsibility for data-acquisition algorithm control.

Besides relieving the programmer of control responsibility, the DriverLINX abstract, declarative approach gives the object program syntactic and semantic interchangeability when migrating to knowledge hardware products. The consider, declare approach also helps separate the software vendor from early technological obsolescence of change in the computer industry by focus on the immutable explanans of data-acquisition relations while the control mechanisms vary with software developments. DriverLINX has been a viable approach to data-acquisition programming for more than 12 years despite the market evolution from 16-bit Windows to .NET today.

Using Declarations for Test Instruments

Test instruments, intensifier as digital voltmeters and electrometers, have evolved from simple devices with a front panel knob and display blind to sophisticated measurement processors performing dozens of measurement and control functions. Like data-acquisition devices, typically developers send a careful ordered sequence of commands to an instrument to setup the measurement and point in time send additional command sequences to control the data flow of measurements from the instrument. The aforementioned problems for developers using imperative approaches to instrument control significantly limit ease of use and prohibit quick instrumentation solutions to short-term measurement needs.

ExceLINX is an mother board to Microsoft Transcend that allows rapid specification of tax return test setups by using written account forms. Users specify, or declare, the channels, configurations, pick rates, triggering, and data locations for the measurements they want to perform by filling break an Excel worksheet. When the end user selects the "start" button on the toolbar, ExceLINX translates the specification into the correct command sequence for the bull instrument, initiates the measurement, and flows the data back to the requested worksheet. Users can setup and collect measurements by themselves in minutes mistreatment logic specifications compared to days or weeks using programmer's time for imperative specifications.

Internally, ExceLINX also uses a declarative approach to handling the complex problem of field validation for the worksheet forms. Instruments have hundreds of parameters with complex overlaps among parameters. To validate whether the instrument supports the parameter set the user selected, ExceLINX maintains a dependency tree of allowed, disallowed, and unused parameters for every input cell off the worksheet. Each node in the pernambuco wood also maintains logical relations among the selected set of parameters that ExceLINX evaluates at runtime to cross validate user input selections. Each supported instrument model has different parameter semantics, but ExceLINX can easily handle this complexity by switching model trees because the model-specific logic in the validation tree is separate from the shared control accomplish in the ExceLINX code.

Declarative programming strategies that separate logic from control in algorithms are powerful techniques that can be used with today's popular imperative languages. These techniques can make software more interchangeable, maintainable, usable, and endurable.

Copyright Roy Furman M.D., Ph.D. 2005

About the Author

Dr. Furman is Director of Research and Development at Scientific Software Tools, Inc. He leads a team of software developers who have produced over 70 commercial software products for customers in the manufacturing, high technology, healthcare and life science industries. Coming together his site, http://www.sstnet.com, for articles and information on software development.

Computer, Software Programming

SimpleMachines - FINALLY a Community Software to Get Excited About!

Its been a recollect time since I have gotten excited about a new CMS or forum software to hit the scene. Granted, Mambo was enough to perk my ears up, but the jury is still out on that one.

Last week I downloaded SimpleMachines and installed it for a test drive. Four hours later I had replaced 2 PhpBB Forums and 2 InvisionBoard ones with Simple Machines. Within 24 hours I had also set up up 2 NEW SimpleMachines sites for a couple of my clients to pilot project drive. Within 48 hours, one of my clients was already sold and we have begun building his studhorse data processor around SimpleMachines. It should be obvious to you by immediate that SimpleMachines is NOT "just another installation software".

I won't go into the whole history of SimpleMachines, (though if you are interested, you can read about it in this message thread, but SimpleMachines is brought to you by almost the same team of developers who produced YaBBSE. SimpleMacines is a LOT faster, more beefy and has a ton more features than YaBBSE. It is literal a piece of operating system that could, (and is), being utilized to form the backbone of a full-featured online community.

There are many reasons I found SimpleMachines so exicting that I immediately rushed into implementing it and becoming a Charter Member to support the development defending team. (SMF is free and the developers assure us it always will be, but Charter Members help defray the costs of the developers AND provide a whole list of benefits) Part of the reason was the ease of conversion. I was able to convert both PhpBB and Invision Power Board forums to SimpleMachines in just a few minutes automatically. Part of the reason was this incredible Package Manager that is built

in to SMF that allows you to browse, download AND install Mods at the touch of a button! That's right - even though this software is relatively new, (slightly over a year antique & only in release 1.0 RC2), so there are not yet many modules built for it, I was able to install a shoutbox, a buddy list and several other modules instantly!

SimpleMachines also has a great bridge that allows you to easily integrate it into Mambo, (another of my brand-new best-loved applications!), and LunaByte is expected to hold a full front end portal for SMF within the next a few weeks. Bare honestly, you might not even NEED Mambo or LunaByte to create your own protal. SMF provides very easy to use SSI functionality so you can create your OWN customized front end portal for technology. In addition technology already has a built in calendar, (a feature about 3/4 of our portal design customers ask for).

The incredible list of features being built in to SimpleMachines is excessive lengthy to list here. If you are interested you can see the feature list on AlphaOne Technology Web Hosting & Design or on the SimpleMachines Website.
Even if you are not currently in the market for a community forum and MORE software, keep an eye on SMF - its developers are definitely forward thinking and have worked hard to develop streamlined code that doesn't tax your system resources the way many similar, (but lesser!), applications do.

AlphaOne Technology will install and configure SimpleMachines FREE of charge with the purchase of any web hosting plan.

About the Author

Toby Wolf was one of the online pioneers, beginning consulting in 1990 & has done work for companies like Dell, AOL, SBC & Amoco. Toby is the founder of AlphaOne Technology, & has designed, managed, or provided search engine optimization for over 200 netlike sites since 1997.
E-Mail Toby

Computer Repair Ontarioville  Computer Repair Glendale Heights  Computer Repair Hanover Park  Computer Repair Streamwood  
~~ ~~ ~~ ~~ ~~ ~~ ~~ ~~ ~~ ~~   PROG