What's Old Is New

So I was doing some surfing this week and I came across a product called Runtime Revolution. They claim to have some software that will:

Create outstanding applications yourself with a programming environment you can quickly understand. Achieve immediate results with a visual, drag-and-drop interface builder. Use English, the language you already know, to describe program logic. Deploy powerful cross-platform solutions without the huge learning curve of other development environments.

Well - being the geek that I am - I checked out their tutorials and videos, etc. I was looking at it and looking at it - and it seemed VERY familiar... turns out it is - it's HyperCard!!

Yeah, really, HyperCard! What the?!?

It seems that the passion for the product never died - and those Scottish coders (whomever they are) have been updating the products GUI capabilities while keeping all of the easy-to-use goodness and SmallTalk-based language basically intact.

The idea is that you can create extremely rich GUIs in a way that is MUCH easier than Flash, AIR, OpenLaszlo, etc. This thing runs (and can be edited) on Mac, Windows and Linux (Unix). It creates double-clickable applications for any platform - AND (using a browser plug-in) will work in the web - all with ZERO code changes!

Here's an overview of the features:

• Author on your favorite operating system - Studio is available for Windows, Mac, Linux or Unix.
• Create standalone applications for any platform with native appearance and behaviours
• Fully-featured, English-like programming language with 1596 commands and functions
• Extensible with code libraries and compiled externals you write yourself or obtain from third parties
• Ability to automate system functions and "office" applications
• Embedded web browsers.
• Powerful libraries for manipulating Internet protocols, XML, compression, encoding/decoding
• Your very own User Space with 10 MB free space to share your stacks online.
• Integrated connectivity for ODBC, MySQL, PostgreSQL SQLite and Valentina databases**
• Flexible chunk expressions, regular expressions, arrays, and sorting functions for manipulating data
• Complete printing and reporting facilities for professional output
• Ability to run as CGI process on web servers

At it's most basic: it's an IDE. You simply drag your control to the form ("card") and then attach code to any one of the 1,000,000 events that are exposed. There is a full even hierarchy - so while you can attach a script to an individual object - you don't have to. You can attach it to the card (form) or the "stack" (application).

You have 100% FULL control over EVERYTHING in the entire GUI:

• Windows including: modal, non-modal, palettes, stay on top, min size, max size, drag and drop events, title bar controls
• Transitions/effects
• Alpha masking
• Custom button appearance
• Geometry editor - for telling it how to resize individual elements when the form is resized
• Support for custom radio buttons (and checkboxes)
• Grid editor
• Rich text, inline html (WITH images), list boxes, data grids (with icon types, auto-sort, drag column order, etc),
• Graphics containers - including QuickTime containers and image containers that support multiple graphics formats as well as built-in graphs
• Native vector graphics that include gradients, splines, polygons, boxes, ovals, lines, text, etc.
• Full visual menu editor that works for popup menus as well as application menus
• Tab controls
• Scrollbar objects
• Web browser object
• Groups of objects that can be dragged, edited and moved at runtime - including nested groups that all work independently of each other
• Dialog "sheets" and slide-out "drawers" (Mac OS only)
• Main window can be a CUSTOM SHAPE - based on a background image(!)
• Named property "profiles" - for defining any (or all) of an object's properties and then switching them out (live) at runtime
• Etc

In short - it's an extremely rich GUI builder that exposes all the events and types of things that you could ever want when building an application.

Yeah, but what about the code?

The coding language is an offshoot of SmallTalk - and is English-based.

put the height of field "Text" into myVar

put the width of image "My Image" + 17 after field "Values"

if item 1 of the location of me > zero then beep

set the loc of button "OK" to 32,104

set the name of field "Old Name" to "New Name"

select after text of field "New Name"

Yeah, it's fairly verbose - but very straight forward. You can do anything you want - including working with arrays, calling external plug-ins (written in C), pass events to individual objects, create functions, etc.

Oh yeah, and it's object oriented (all the properties of objects inherit the properties of objects higher in the hierarchy). For example - if you don't specify a background color for a field - it will take the background color of the card, or stack.

Yeah, but what about SQL stuff?

It supports ODBC - but also has native (direct access) connect to: Oracle, MySQL, SQLite, PostgreSQL, Valentina. It has a built-in query editor and you can "bind" field objects directly to database columns - so you don't have to write your own SQL for inserts/updates/deletes - it's all handled automatically.

Of course, you can also run your own queries and get your own datasets and do stuff with it (like you can in any other coding environment) - and you can dynamically change the binding on a field object at any time (at runtime).

You can create databases and table (and alter their schema) ON-THE-FLY - and you can programatically create new objects and bind them to your new table(s) at runtime(!!).

OK - so what's missing?

• Automatic data broadcasting
• Native HTML/CSS browser implementation (you have to use a browser plug-in)
• Multi-developer (SVN/CVS) support
• Runtime fees (the "Media" edition is free, "Professional" is $249 and "Enterprise" [allows native connection to Oracle] is $499). There are ZERO other fees.

This thing sounds VERY cool - and sounds like it will be a welcome addition to my toolbox!

Bob's 2009 Crystal Ball

Well, I guess it's time for me to dust off the old crystal ball - and (again) publicly humiliate myself by making some predictions for what will happen in the upcoming year. I've been loath to do this in past years - but as part of my new "happy place" resolution - I'm going to put myself out there and predict some winners and losers in 2009.

The Winners:

SaaS-based Solutions. We have all seen that the rise in Software as a Service (SaaS) applications are on the rise this past year. I think this trend will only continue in 2009 as companies are still in a really "unsure" position and continue to turn the lights off at an astounding rate.

I think most of the "big" cuts will wrap up in early Q1. The problem (and opportunity) is that now businesses will be left with 20% to 50% less people to do 100% of the work that needs to get done. Since the cuts have been (in most cases) all across the board - there are now even less IT folks to go around and they've got their own problems to deal with - and chances are good that your project won't be one of them.

SaaS implementation won't just be the domain of some Web 2.0 software, but I think that companies will also want to be able to offer the packages that they've traditionally bought as on-premises apps as internal SaaS applications as well. This means that ISV's and software vendors better get a solid SaaS strategy - and get it NOW. ISVs and software vendors also should take a good, long look at being in the financing business - offer customers multiple, flexible ways to pay for their software. The more flexible, the better.

Truly Agile Development. A few years ago offshoring development was all the rage, but now some of the same companies that were early adopters of offshoring are bringing their development efforts back in-house. Why? Productivity. It's sort of the same model that I've seen with folks who are trying to re-develop their aging software in .NET. They throw a bunch of money and resources at it - and because .NET is so complex and has so many moving parts - almost 100% of the time these projects miss their deadlines and budgets by a mile.

While that may be somewhat acceptable during "flush" times - that kind of nonsense will come to a grinding halt. The needs of the business don't change - and I would even argue that as competition heats up - time frames compress and business needs even grow larger. The need to preserve market position, the need to grow the customer base, the need to be ever more responsive to the needs of the marketplace, etc.

The companies that figure out how to do agile development that actually delivers value in a timely fashion will thrive. Those that don't won't.

Projects With Measurable ROI. Gone are the days of "someday" ROI. Gone are the days of "squishy" ROI. Now, as in the last downturn, companies are struggling with budgeting decisions and only those projects that can demonstrate measurable ROI will get funded. By measurable ROI I mean - "How much will that project deliver to my Q1 profitability?" or "How much in hard dollar (yen, euro, pound) savings can we count on by June?"

It's even more important to have not only measurable targets for increased productivity, decreased staffing needs or other metrics - but software vendors and consultants will have to commit to the "when" question as well. "WHEN can we see those savings?" That's going to put pressure on developers and consultants to be able to actually deliver what they say - on time and on budget.

Apple. Even though their stock is down (along with the rest of the world) - they have a history of innovation and they just have the knack of giving people devices that work they way they should. Their hardware is "pretty" and fairly reliable. Their software - although limited only to their hardware - is pretty easy to use, while at the same time build on a robust Linux core.

They no-doubt will pimp the variations of iPod Touch models (think "nano" versions), and may even hint at a new iPhone model. Plus, with Apple, there's always the possibility of "one more thing" - something that no one has even thought about yet that they've been working on in secret for years on. That's the fun (and frustrating) thing about Apple - you just never know what they'll do next. One thing's for sure - they'll

The Losers:

Traditional Client-Server Applications. I don't mean ALL client-server applications - because, let's face it, the browser is one of the worst application delivery vehicles ever invented. The browser only solves one part of the problem - the one that has plagued companies since the dawn of time: deployment. Specifically, deployment of traditional client-server applications.

You know, the ones that has a client you have to install on every single separate client computer. The ones where you have a "dumb" server and a "heavy client" that does most of the heavy lifting... those things will become deader than a doornail.

Does this mean that native client applications (ones that run outside the browser) will die completely. No way in hell. There are applications that simply demand they be native client applications (ones that talk to the serial port for scanners, bar code readers, cash drawers, or that have to access local files or other shared resources).

"Thin" will be "in". Thin, native clients that load quickly but still have native user interface elements and that don't rely on the Internet to be "up" will always have a place in business. In 2009, IT managers, software vendors and ISVs will be looking for tools like Servoy that can deliver the best of both worlds - while at the same time meets their needs for on-time, on-budget development.

.NET Deployments. I know, it's sort of an oxymoron - but .NET is seen as a more agile technology especially with companies with large scale COBOL applications or who are struggling under the weight of proprietary C++ applications that are crying out for updates.

The sheer speed of the changes in business and the ever-increasing need for ISVs and software companies to meet the needs of their stressed-out, under-funded, over-worked customers will be the determining factor in their own survival. I've never personally seen any .NET deployment that is able to be adapted quickly and efficiently to the changing needs of business (if you have - please feel free to comment!).

Offshoring. If you've made it this far in this post - you'll know the reasons why. I do have some personal experience with this - and even though workers here "charge more" than programmers and companies in "developing nations" - the results speak for themselves. I've talked to several companies who are scrapping their entire offshore operations and bringing them back in-house.

One manager I know from a major company (who asked not to be named) summed it up pretty well: "I found out that adding 65 people to our project (for the price of 9 US-based folks) - wasn't all it was cracked up to be. They would say 'yes, yes, yes' to everything but nothing would ever get done. It looks like most of the stuff they've worked on for the past 2 years will have to be re-written from scratch here." DOH!

Sun. And, last but not least, I'm afraid Sun will have to take some drastic actions in 2009 in order to continue their operations. Their $1 billion purchase of MySQL this year (as well as the tanking market for high-end servers) has seemed to take a huge toll on the company's balance sheet, forcing them to layoff 6,000 workers.

They're still struggling with finding a business model for their open source initiatives, and I'm not sure they'll find the answers they need in 2009. They've already open-sourced most of their products (Solaris, Java, MySQL, Java FX, etc) and now that they've done that they are finding it hard to put the Genie back in the bottle and make money off of their technology. Short of becoming an uber consulting and support company - I'm not convinced they will be around to see 2010.

Well, there you have it - my predictions for 2009. This time next year I'll make sure to review them and also make some other BS predictions for 2010...

Step Away From The Waterfall

Ahhh, the joys of corporate development! The endless meetings. The endless PowerPoint presos. The endless charts and graphs in the endless PowerPoint preso in the endless meetings... it's heavenly - NOT.

The typical corporate "internal" application development cycle can be (and often is) a road into the deep reaches of hell - for both IT staff and the end users who are forced to use stupid, hard-to-use, useless software that took so long to build that it's totally irrelevant.

And yet, it continues to happen in company after company in application after application. Why?

I believe it's due to the archaic adherence to the waterfall method of development. What - you're asking yourself - is the waterfall method of development? In a nutshell - it's a process by which people who are really concerned about keeping their jobs can hide behind "implementation strategies" and "feasibility studies" and "systems analysis" for a couple of years before beginning a "technology review" and "requirements re-engineering" process before actually coding something.

It's one of the oldest methods - and is linear in fashion. This means that the outputs of one process become the inputs of the next. Here's the basic set of steps:

• Project planning, feasibility study: Establishes a high-level view of the intended project and determines its goals.
• Systems analysis, requirements definition: Refines project goals into defined functions and operation of the intended application. Analyzes end-user information needs.
• Systems design: Describes desired features and operations in detail, including screen layouts, business rules, process diagrams, pseudocode and other documentation.
• Implementation: The real code is written here.
• Integration and testing: Brings all the pieces together into a special testing environment, then checks for errors, bugs and interoperability.
• Acceptance, installation, deployment: The final stage of initial development, where the software is put into production and runs actual business.
• Maintenance: What happens during the rest of the software's life: changes, correction, additions, moves to a different computing platform and more. This, the least glamorous and perhaps most important step of all, goes on seemingly forever.

(source: ComputerWorld)

This is the process was created about the time, and is as about as efficient as, using slide rules and drafting tables to create a capsule to take humans to the moon.

Technology wasn't always "instant" or "good." People used to have to meet (and fly around the country) to make sure everyone was on the same page. There was no "speakerphone", no email, no cell phone, no fax machine, no PDF, no online collaboration tools, no Internet, no nothing.

Just elbow grease, manual labor, and dedicated IT folks who "knew better" than the "lowly" end-user.

The frightening thing is - most internal development at corporations (and even big ISVs) is the same. The developers are in their own development "silo" safely tucked away from those pesky "users." After all, they know what's best, what's cool - and what the user is bound to "just love" - right?

Wrong.

There are several keys to making the process work better - and it's not rocket science - it's common sense. Yes, there are tons of so-call "agile" development methologies and hundreds of books and sites dedicated to the "how" of the process (Scrum, Crystal Clear, Extreme Programming, Adaptive Software Development, Feature Driven Development, Dynamic Systems Development Method, etc.) - but there are key elements the are common within all of them:

Let the developers interact with end users and get end users to help in the QA process. You need to know what the people using the software (and their managers) need the software to do. While it's true that most end users just want to do their one piece of the puzzle and go home (known as the "tab-tab-enter" crowd) - most developers will actually over-engineer software to do things they think the end user wants to do - rather than what it actually has to do.

Keep it simple. This follows the above rule. 99 times out of 100 - the user just wants to do something simple. 99 times out of 100 developers want to do something "cool." Only 1 time in 100 do these objectives match. So, when in doubt - build it the most simple, basic way that will work according to the way the end user says they'll use it. Don't assume the developer "knows better" than the end user. They usually don't - and if they don't listen - the end user will be pissed and not use the software after it's done.

Use better tools. Java and .NET are powerful languages - they are also a bear to code - but provide a great desktop experience. Scripting languages (Python, PHP, Perl, Ruby, etc.) are lighter weight (and limited to the browser). RAD tools like Servoy give you the best of both worlds - and are easy to deploy to either a browser or the deskop.

Build it - and release it - NOW. Don't wait for the completion of the entire application ("alpha") to get the user's input. Build a screen, a section of the application, deploy it and get feedback. Change it - and then repeat. As you build - get the feedback. Don't stress out about "scope creep" - there will be things that the end user will come up with late in the game that are important to them, to the company - and quite possibly to the bottom line of the company. Use common sense. There will be a 2.0 - so you don't need to put everything in there but the kitchen sink in 1.0 - but make sure end users are happy (even thrilled!) about what will be initially released.

Let the users determine the feature set - not the developers. Developers are often not the end users of the application. Unless they are, do NOT let them determine what the features will be. Let the people who actually use the features be the judge. Keep in mind - users will usually change their mind - or ask for things may require some re-architecting of what was created initially - but remember - the goal isn't to "finish" the software - it's to create software that will help the end users be more efficient and help the business to be more nimble, and hopefully, more profitable.

Think I'm blowing smoke? Give it a try on a small project. Once you do - you'll never go back. That, I can promise.