Next
Compile PL/SQL with VS Code using SSH - 27-Mar-2017 09:04 - Christoph Ruepprich

First of all thanks to Morten Braten’s blog post Using VS Code for PL/SQL development. I had been wanting to try this editor for a while but still felt loyal to Sublime.

Morten described how to use Visual Studio Code for PL/SQL development, and how to use its task runner to compile your code via SQL*Plus. I would like to expand on this aspect and show how I used the task runner to compile code through an SSH tunnel via SQLcl. I’m using a Mac, so you may have to do some adjustments for other operating systems.

Basic requirements:

  • SSH key to your database server
  • SQLcl
  • VS Code

First I created an SQL file (bmc_login.sql) that will log my SQLcl session into my remote database via SSH:

sshtunnel christoph@bmcdb -i /Users/cruepprich/bmc/bmc_key -L 8888:localhost:1521
connect scott/tiger@localhost:8888/orcl

For more information about how this works see OraOpenSource.

Then I needed a shell script (compile_bmc.sh) that the task runner can execute:

~/oracle/sqlcl/bin/sql -S /nolog @bmc_login <

This file calls the SQLcl executable in silent mode (-S) without logging in (/nolog), and runs the bmc_login.sql to connect to the remote database. Then it executes the first command line argument ($1) which it will get from the task runner. Finally it will display any compilation errors and exit.

The last thing to do is to configure the task runner in VS Code. Edit the tasks.json file and add the following task. Note that I’m showing an example with multiple tasks. The task of interest is the one named Compile in bmc.

{
    "version": "0.1.0",
    "tasks": [
        {
            "taskName": "print hello",
            "command": "echo",
            "args": ["Hello"],
            "isShellCommand": true
        },
        {
            "taskName": "Compile in bmc",
            "command": "/Users/cruepprich/sh/compile_bmc.sh",
            "isShellCommand": true,
            "args": ["${file}"]
        }
    ]
}
 The ${file} argument refers to the file you are currently editing. So you want to make sure that you are editing a PL/SQL program and then you can run this task now from the VS Code Command Pallete:
command Pallette
You can also add a keyboard shortcut (ctrl-c) to run this task.
 {
   "key": "ctrl+c",
   "command": "workbench.action.tasks.runTask",
   "args": "Compile in bmc"
 }

Now I can edit PL/SQL programs in VS Code and compile them directly on my remote database via SSH tunnel.


(My current) Atom editor Oracle plugins - 26-Mar-2017 20:46 - Trent Schafer
If you are an Oracle developer and use Atom text editor, here are some extensions that may make your development experience more pleasant.
  • language-oracle
  • build-oracle
  • autocomplete-oracle
  • (experimental/early) plsql-block

language-oracle

This extension aims to provide the syntax highlighting into Atom. It was converted from a text mate bundle back in October 2015, with a few little tweaks here and there since.

To install, open your settings dialog (ctrl+,), go to the Install node and search "language-oracle". The package should come up as the first result, so hit the install button.


(alternatively, from the command line, run: `apm install language-oracle`)

After it's installed, your favourite extensions for Oracle DDL should now be picked up as PL/SQL (Oracle) in the status bar and the keywords and package references should be appropriately styled.



build-oracle

You may recall I blogged about compiling Oracle code back in September 2015. This plugin essentially wraps all the scripts up nicely to get you going quickly.

First, you will want to have the scripting engine installed and available on your system, preferably on your path. For the purpose of this article, I'll just be looking at SQLcl, but SQL*Plus can just as easily be used (and is what I actually have my instance set up with). 

So, head over to the SQLcl downloads page and grab the lastest version: http://www.oracle.com/technetwork/developer-tools/sqlcl/downloads/index.html

The unzip and store in a convenient location (I store mine in /opt). 


unzip sqlcl-*.zip 
sudo mv sqlcl/ /opt/sqlcl/

The next part is to install the Atom plugin. To install, open your settings dialog (ctrl+,), go to the Install node and search "build-oracle". The package should come up as the first result, so hit the install button.



(alternatively, from the command line, run: `apm install language-oracle`)

By default, the plugin looks for `sqlplus` in the path. Since this example we are going with SQLcl, we need to update the configuration. So go into the plugins settings and specify the path to the SQL interpreter:


Then, in the root of your project folder, you need a file named `.atom-build-oracle.json`, which will be an array of build targets. Each target should contain the fields "connectString" and "targetName".

[
{
"targetName" : "hr: dev",
"connectString" : "hr/hr@//example.com:1521/xe"
}
]

The first time you add this file into your project, you will need to reload Atom so it knows to read the file to find targets. Now, in the bottom left of the status bar, you will see all the the first target as defined in your build configuration.



So, I have created a query to test this out (sample.sql). I can hit the keyboard shortcut (ctrl+alt+b), or click on the target in the bottom left to trigger a build. This output then comes out like so:



Easy as!

If you want to use SQL*Plus as the engine, there are some notes on the projects README that you may want to review. See here: https://github.com/tschf/atom-build-oracle/blob/master/README.md

autocomplete-oracle


Atom has an API to add support for code completions. In this package, I've essentially taken a dump of certain bits from the data dictionary into a JSON file.

To install, open your settings dialog (ctrl+,), go to the Install node and search "autocomplete-oracle". The package should come up as the first result, so hit the install button.


(alternatively, from the command line, run: `apm install autocomplete-oracle`)

With this installed, as you type, certain oracle keywords and package references will appear.



(experimental/early) plsql-block


This is one I haven't really done a lot with, and is not technically my project, but borrowed from another language. A while ago, I came across a couple of Ruby packages that give visual indication of where a block starts and ends.

(FWIW, this is a fork of the project: https://github.com/samu/blocky. There was another project that does a similar thing, except only matched when on the ending block, so figured this would be better to base off)

I've done a slight tweak, and out of the box, it works with begin,end blocks. I think the current implementation doesn't work with if, loop statements, so I've disabled the if-block matching implementation for now. If someone has the time to look more into this project, that would be great - as I can this being supremely useful; or maybe stealing the idea's from this project and re-implementing for PL/SQL!

Because it's incomplete for PL/SQL code, I haven't published this - but you can get up and going with this by cloning the fork/repository I have in my GitHub account. Go into your package directory, and clone like so:

cd ~/.atom/packages/
git clone https://github.com/tschf/plsql-block.git
cd plsql-block
apm i

With that installed, you should see it under community packages in Atom:



And, in your PL/SQL code, you will find the opening and closing blocks highlighted like so:


Even without the if, loop, constructs matched, I can imagine this still being quite handy.

..

Enjoy!
I'm sure this has been covered a hundred times, but I couldn't find an easy solution without using a plugin.  This works without one:

Create a Dynamic Action:
  After Report Refresh
    True = Execute JavaScript Code (fire on page load):

        setTimeout(function(){
            $('#R47772796555758493_search_button').click();
        }, 6000);


 Where R47772796555758493 is the ID for you IR.

Oracle Apex 5.2 - Oracle Application Express - 24-Mar-2017 16:03 - RCI Informatique
 
Oracle a publié, début mars, une liste des principales évolutions prévues pour la prochaine version Oracle APEX 5.2.

Parmi les principaux points on peut citer les services web "REST", et l'intégration des versions les plus récentes d'Oracle JET et de JQuery.

Mais le point le plus important de ce document est l'engagement d'Oracle en ce qui concerne l'avenir d'Oracle APEX:

- Oracle APEX est un élément intégré en standard dans toutes les versions de la base de données Oracle, et non pas un produit séparé ou optionnel

- L'outil de développement Oracle APEX est qualifié de "compoosant clé", et de ce fait va continuer à évoluer, environ au rythme d'une nouvelle version chaque année

- Oracle APEX est le composant standard Oracle de développement pour le cloud

- Oracle estime à plus de 250 000 le nombre de développeurs Oracle APEX

- Enfin, l'éditeur Oracle prend acte de l'investissement très important de ses clients vis à vis de l'outil Oracle APEX, et de ce fait s'engage à un support à long terme de cet environnement de développement

 
Have you ever needed a Line graph with missing Data points.. The standard line graph included in APEX 5.1 does not handle the missing data in a nice way.  Examples are worth a thousand words so..
We have a table
create table temp
( s varchar2(20),  l varchar2(20),  n number ) tablespace db_info_ts;
 
insert into temp values ('L1','a',5); 
insert into temp values ('l1','c',10);
insert into temp values ('L1','e',15);
insert into temp values ('L2','b',5);
insert into temp values (' l2 ','d',10);
insert into temp values ('L3','B',3); 
insert into temp values ('L3','c',3); 
insert into temp values ('L3','d',3); 
insert into temp values ('l3','e',3);
insert into temp values ('L4','a',7); 
insert into temp values ('L4','f',7);  

commit; 

The S column here stands for my series, L stands for labels (x values) and n stand for the values.
Notice Series are missing some of the labels I want a report showing labels a-f
Also the series and labels must have been hand entered as there are spaces and upper/lower values.. In short we have a mess.

If I create a series line graph using this data with
select s,l,n from temp 

The results are disasterous!
But there is an easy way to fix it, using function returning sql 
declare
t_id number;
begin
   t_id := fill_graph_gaps('select s,l,n from temp','I');
   return 'select s,l,v from graph_data where graph_data_id = '||t_id||'order by l';
end;

And Poof! you have a beautiful graphs

The magic is in using a combination of a Global temporary table 
create global temporary table tmp_graph_align
( series_col varchar2(200), label_col varchar2(200), graph_value number) on commit delete rows;

and a permanent table
CREATE TABLE GRAPH_DATA
(
  GRAPH_DATA_ID  NUMBER,
  BUILD_DT       TIMESTAMP(6)                   DEFAULT systimestamp,
  S              VARCHAR2(200 BYTE),
  L              VARCHAR2(200 BYTE),
  V              NUMBER
);
create sequence graph_data_seq start with 1 nocache;

Finally, the function 
CREATE OR REPLACE function fill_graph_gaps 
( p_sql_stmt varchar2, p_format varchar2 default 'I') return varchar2 is
--   Fill_graph_gaps
--   Created by Jerry Sidler 3/23/2017
--   All rights reserved
--   Free to use as long as this notice is maintained.
-------------------------------------------
-- Parameters
-- p_sql_stmt is the select you wish to graph It must contain 3 columns
--  Column 1 Series
--  Column 2 Labels
--  Column 3 a number item
--
-- p_format attempts to cleanup inconsistent label data
--      N - No cleanup
--      L - Lower case Labels
--      U - Upper case labels
--      I - Initcap labels
t_cnt number;
t_seq number;
begin
    delete from graph_data where build_dt < sysdate-1;
    execute immediate 'insert into tmp_graph_align '||p_sql_stmt;
    if upper(p_format) <> 'N' then
        update tmp_graph_align set label_col = trim(label_col),
                                   series_col=trim(series_col);
        if upper(p_format) = 'I' then 
           update tmp_graph_align
              set label_col = initcap(label_col),
                  series_col = initcap(series_col);
        elsif upper(p_format) = 'U' then 
           update tmp_graph_align
              set label_col = upper(label_col),
                  series_col = upper(series_col);
        elsif upper(p_format) = 'L' then 
           update tmp_graph_align
              set label_col = lower(label_col),
                  series_col = lower(series_col);
        end if;
    end if;
    for c1Rec in (select distinct label_col from tmp_graph_align ) loop
        for c2Rec in (select distinct series_col from tmp_graph_align ) loop
            select count(*) into t_cnt from tmp_graph_align where label_col = c1Rec.label_col and series_col = c2Rec.series_col;
            if t_cnt = 0 then
               insert into tmp_graph_align
               values (c2Rec.series_col, c1Rec.label_col, 0);
            end if;
        end loop;
    end loop;
    select graph_data_seq.nextval into t_seq from dual;
    insert into graph_data
    ( graph_data_id, s, l, v ) 
      select t_seq, series_col, label_col, graph_value 
        from tmp_graph_align;
    commit;
    return t_seq;
    
end;
/

Notice I welcome comments and hope to present this at KScope 17.  Send me comments/suggestions so when I present it will have many new features to make our lives easier!

Enjoy
Jerry
#fakecode - 23-Mar-2017 11:03 - Scott Spendolini
Unless you've managed to somehow filter out everything about US politics over the last few months (and if you have, please let me know your secret), then you've likely heard about "fake news".  From a high level, my basic understanding of "fake news" is that it refers to stories or websites that are fabricated to advance the political beliefs and/or ideologies of one site or the other.  Your definition may differ.

So what is fake code?  That, I can at least try to explain in a bit more detail.

The other day, I saw this image posted on Kris Rice's twitter feed:



I thought it was a joke, but it's actually a real book. That made me laugh.  Then cry.  Then I read the book, mainly since it's only 4 pages.  Believe it or not,  there's actually some really good content packed in there.  Let me summarize:

If you choose to copy code from Stack Overflow, the OTN forum, or anywhere, really, there's a few things to keep in mind:


  1. Who owns the code.  It's more than likely perfectly legal to copy and use the code you find on these sites "as is", but keep in mind there may be exceptions to this rule.  The first page in the booklet offers some insight as to what they are.
  2. Who gets credit for the code.  While not required, it's a good idea to credit the author of the snippet that you used.  This is not just courteous, but also provides a reference back to the source of the code, so when it breaks, you know where to start looking.  Which brings me to the third and most important thing to consider:
  3. How good is the code. Unfortunately, there is no easy way to verify this.  You can look at the number of up votes for a specific response, but even that can be easily faked - or more likely, just be wrong because it is based on an older version.

The first two issues don't concern me all that much, as the first is rarely an issue and the second is simple to solve.  The third however, does concern me a lot.  FAKE code - where FAKE stands for Found Another Killer Example (yes, I made that up) - is fast becoming the way that we develop solutions.  Simply enter in some string of what you're trying to do into Google, and a set of possible solutions will magically appear on the page.

With very little effort, you can copy & paste that snippet into your application, run it, and if it works, then you're job is done and you're a hero.  If it doesn't, some more searching and some more tinkering is in order.  Maybe it's a 15 minute task instead of a 5 minute one.  But that doesn't matter, as what you were asked to do is done, and you can move on to the next problem.

There's definitely some problems with this approach.  If you don't understand what the code is doing, who is going to fix it when it breaks?  And it will break at some point.  As other libraries or components get upgraded and/or browser versions change, code will eventually break - usually at the worst possible time.

If you get lucky, and it doesn't break, then who is going to change how it works when the users come up with new requirements?  If you don't have a full grasp as to what it does or how it does it, then you'll have little success in changing how it works.

And just because there's a solution, does it mean that is the best, most secure, most performant solution?  It may work fine for a single user on a development environment, but what happens when its implemented in the real world?  This is especially a concern when you're implementing something in a language that you're not as proficient in, as you won't be able to readily spot bad practices.

In no way am I saying that any of these sites are bad, nor saying don't use them.  I use them all of the time to find solutions to problems and contribute solutions, as do many others.  They are all a valuable resource that makes our jobs a lot easier to do.

What I do want to emphasize is that when you do use any site that presents a solution or code snippet, be sure to not only vet the solution, but also ensure that you completely understand how it works, and be ready to fix it if it breaks.  If you can't do either of these things easily, then perhaps its best to find an alternate solution to your problem - one that you can understand and maintain

FAKE code is a real danger to any development project.  Sprinkle enough of it around, and you're essentially creating a ticking time bomb, that's just waiting to explode.  But FAKE code can be spotted and stopped fairly easily: Document the source of any snippet or blog you use.  Take the time to learn what it does line-by-line, and document that, too.  Be ready to support it if in the case it breaks.  And if you're not comfortable doing so, have alternative resources lined up or at least identified.

Together, with a little bit of work, we can stop the FAKEcode epidemic.
Bulk Updating Interactive Grid Records - 23-Mar-2017 10:36 - Christoph Ruepprich

After my previous post on Updating Interactive Grid Cells, I wanted to try bulk updating IG records.

In this example I want to bulk update the salaries and commissions for the employees. I created a new button called Double Salaries. When the button is clicked, the salaries of the selected employees get doubled. The employees with no salary get a salary of 1000. Sales people will get their commission updated to 10% of their new salary.

Employees are selected by clicking the row selector checkbox of the interactive grid. The interactive grid’s static ID is emps.

The work is done by the JavaScript action of a dynamic action on the Double Salaries button:

var record, sal;
//Identify the particular interactive grid
var ig$     = apex.region("emps").widget();

//Fetch the model for the interactive grid
var grid    = ig$.interactiveGrid("getViews","grid");

//Fetch the model for the interactive grid
var model   = ig$.interactiveGrid("getViews","grid").model;

//Fetch selected records
var selectedRecords = apex.region"emps").widget().interactiveGrid("getViews","grid").view$.grid("getSelectedRecords");

//Loop through selected records and update value of the salary column
for (idx=0; idx < selectedRecords.length; idx++) {
    //Get the record
    record = model.getRecord(selectedRecords[idx][0]);

    //Get the current salary and commision values
    sal  = model.getValue(record,"SAL");
    job  = model.getValue(record,"JOB");
    comm = model.getValue(record,"COMM");

    //If there is no salary, set it to 1000, else double it
    if (sal === '') {
        sal = 1000;
    } else {
        sal = sal * 2;
    }

    //Update the record with doubled salary and new commission
    model.setValue(record,"SAL", sal);


    //Set commission to 10% of salary for sales people
    if (job = 'SALESMAN') {
        comm = sal *.1;
        model.setValue(record,"COMM", comm);
    }

}

emps_bulk


Oracle APEX: Low Code, High Innovation - 21-Mar-2017 17:12 - Insum Solutions

Oracle APEX: Low Code, High Innovation

Several years ago, I came across a story that has remained one of my favorites:

A toothpaste factory had a problem: they sometimes shipped empty boxes, without the tube inside.

Those familiar with production lines know how difficult it is to have everything run perfectly in sync, and needless to say, empty toothpaste boxes in the supermarket move customer satisfaction scores in the wrong direction.

Understanding how important that was, the CEO got the top people in the company together and they decided to start a new project, in which they would hire an external engineering company to solve their empty boxes problem, as their engineering department was already too stretched.

The project followed the usual process: budget and project sponsor allocated, RFP, third-parties selected, and six months (and $8 million) later, they had a fantastic solution — on time, on budget, high quality, and everyone in the project had a great time. They solved the problem by using high-tech precision scales that would sound a bell and flash lights whenever a toothpaste box weighed less than it should. The line would stop, someone would walk over and yank out the defective box, then press a button to restart everything.

A while later, the CEO decides to have a look at the ROI of the project: amazing results! No empty boxes ever shipped out of the factory. Very few customer complaints, and they were gaining market share. “That’s some money well spent!” – he says, before looking closely at the other statistics in the report.

It turns out, the number of defects picked up by the scales was 0. It should’ve been picking up at least a dozen a day, so maybe there was something wrong with the report? He filed a bug on the report, and after some investigation, the engineers came back saying the report was actually correct. The scales really weren’t picking up any defects, because all boxes that got to that point on the conveyor belt were good.

Puzzled, the CEO travels down to the factory, and walks up to the part of the line where the precision scales were installed. A few feet before it, there was a $20 desk fan blowing the empty boxes off the belt and into a bin.

“Oh, that — one of the guys put it there ’cause he was tired of walking over every time the bell rang”, said one of the workers.

The story appeared in a post entitled Networks are Smart Around the Edges, and dubious veracity aside, I love it since it highlights several things about corporations and people we all know to be true from experience. In fact, since it demonstrates so clearly how we can often overlook simple yet effective solutions due to a biased frame of reference, I’ve used it several times when introducing Oracle APEX.

ray-ozzie-complexity-it

For the same reason, the story also works well to introduce the topic of this post, which is the growing popularity of low code platforms, or what some are calling the low code revolution.

Successful business and IT leaders alike recognize that “complexity kills”, and they look for simple solutions that both enable speed and agility (see my previous bimodal or two speed speed IT post). And, they also recognize the tremendous value in unleashing the collective knowledge and creativity of their teams. Since low code platforms hold promise on both fronts, it’s no wonder we are seeing more and more adoption.

What are low code platforms?

A low code platform is an application development framework typically consisting of visual based, “drag and drop”, type development tools, which enable technically inclined non-programmers, (aka “citizen developers”), to build surprisingly functional business applications without having to write a lot of complex code.

Forrester describes low-code platforms as “platforms that enable rapid delivery of business applications with a minimum of hand-coding and minimal upfront investment in setup, training, and deployment.”

Two good examples are IFFTT and Zapier, which are used to automate workflows by connecting services using pre-defined recipes. They enable non-programmers to develop quite involved workflows for everything from automating social media posts to managing email to building notifications and alerts when tickets go on sale or something is posted on craigslist.

In the enterprise space, Salesforce.com is a good example, as is Oracle Application Express (APEX).  In fact, Oracle has recently announced a push towards low code tools, and has ramped up efforts to make it as easy as possible for organizations to get started with Oracle APEX. To see the low code features of Oracle APEX, see a demo by Mike Hichwa, VP of Software Development at Oracle.

Low Code Platforms – Why Now?

First, it’s worth noting that the adoption of low code tools is really just part of a larger trend we’ve been experiencing, which is the “democratization of IT”.  Simply put, advancements in technology and user interface design are making powerful tools accessible to more and more people, meaning they are no longer restricted to specialized, highly trained experts.

Aided and abetted by the democratization of IT, the primary reason for the low code revolution is rooted in the ever-increasing technology demands of modern businesses, combined with a general shortage of IT talent. In short, IT has become a major bottleneck in many organizations, and business leaders are scrambling for solutions. After all, today’s markets are not kind to those who move slowly with technology adoption – just ask Blockbuster.

This of course is not surprising.  In this age of rapid digital transformation where it’s said that “every company is a technology company whether they want to be or not”, new initiatives typically have a technology component, resulting in a steadily rising demand for software developers. And, as highlighted in a recent Forbes article entitled “Wal-Mart, Target and CVS Need Software Talent; Where Will it come From?”, not only are universities not churning out enough new grads, but the competition for software talent is becoming more fierce, especially from well funded Silicon Valley companies with highly sought-after workplaces. Oh, and did I mention the need to go fast?

How Low Code Platforms Help

More Hands on Deck

Easily the biggest benefit of low code platforms is that they increase the number people who can be involved in delivering technical solutions. A recent article by Salesforce explains that “the ‘low-code revolution’ opens up an enormous opportunity to empower employees to get involved in the app-development process” and means that “the ability to build apps (and the responsibility for innovating) for a business becomes decentralized: anyone in any department can create software to solve a problem or address a need. Not only are problems being solved at the source, but coders are freed up to solve higher-order problems.

A key point not to be missed here is “problems being solved at the source”.

Intuitively, the closer someone is to the problem domain and solution context, the easier it will be for them to see and understand the types of optimizations required to improve efficiencies, and the more invested they will be in finding solutions. With their unique perspective and access to low code platforms, technically savvy business users can start servicing their own needs. This reduces dependency on overworked and potentially unsympathetic IT departments who are not only several steps removed from the problem, but who all too often deliver applications through a long, meandering process that begins with uninspired requirements gathering interviews and ends with “thanks, but that’s not really what we wanted.”

ed-catmull-creativitiy

 

Breaking the Requirements Gathering Challenge

Speaking of requirements gathering, nailing down user requirements is one of the most challenging aspects of application development projects. Although the blame is often placed on dithering users who don’t know what they want, to be fair, it’s not easy or even always possible for users to specify everything they’ll need upfront. People don’t always know exactly what they want until they start to see something take shape, and requirements can also shift since projects are not completed in a vacuum. Low code platforms can be a big help as they enable power users to iterate on solutions in an exploratory manner, and constantly refine until they have something suited to their needs.

Additionally, platforms like Oracle APEX not only enable low code development, they also support “full control” development, which means experienced developers can get under the hood and write as much code as they need. So, much initial work can be done by citizen developers using the low code features, and professional developers can step in where necessary to complete the more complex features using the full power of HTML, CSS, JavaScript, and PL/SQL. At the very least, applications built by the citizen developers can act as a prototypes that help flush out requirements.

 

Turbo Charging Professional Developers

Finally, it’s not just non-coders that can benefit for low code platforms – there are benefits for professional developers as well.

First, with pre-built packages and components that can be assembled via “drag and drop” configured with “point and click” interfaces, low code platforms help reduce the time and complexity involved with building and deploying applications. This, of course, is a welcomed outcome given the relentless pressure to produce more in less time.

Second, low code platforms also enable back end developers to “move up the stack” and build actual end user applications.  In the past, given the complexity of front-end application development platforms and the associated learning curves (see ADF and .Net), back end developers were effectively “locked out” of application development and were forced to defer to experienced front-end programmers.  However, with low code platforms, that changes.  Using Oracle APEX as an example again, back end database developers can leverage their existing SQL and PL/SQL skills and build robust and professional looking applications without having to dedicate hours and hours to learning front-end programming.  So again, low code platforms can broaden the number of people who can deliver applications, and especially those with existing systems knowledge.

Sounds good. What’s the catch?

The criticisms of low code platforms seem to fall into two areas.

The first is the claim that low code platforms “over promise and under deliver”, meaning they are not yet mature enough to be deemed useful beyond simple applications. As a result, the argument is that citizen developers will quickly hit a ceiling or get in over their heads. They’ll then have to be bailed out by professionals who’ll need to rebuild everything from scratch, and who will no doubt do so with no shortage of colorful “tsk tsks” and “who the heck built this” type exclamations, muttered under their breath while madly posting submissions to codinghorror.com.

Although it may be true that the low code platforms are not yet fully mature, (see Forrester’s study entitled “Vendor Landscape: The Fractured, Fertile Terrain of Low-Code Application Platforms”), it’s important to note they are steadily getting better all the time.

For example, consider how advances in word processors and desktop publishing tools completely disrupted the graphic design and publishing industries. With tools like Preszi, an amateur with an eye for design can create professional looking presentations quickly and cost effectively, which not too long ago would have been significant undertakings involving graphic design and/or video production agencies.  Or, for those familiar with Oracle APEX, consider the difference between APEX 4.0 and 5.1, and then imagine where things will be in another 3 to 5 years.

Also, it’s important to note that what I’m discussing here are “low code” and not “no code” platforms. It’s still necessary for citizen developers to have a high level understanding of how systems are built, as well as the ability to string together at least a few lines of code. The point is that they do to not have to be professional programmers who’ve dedicated months or years to learning how to write software. Think of people who might have built complex Excel and Word macros in the past – these are the types of people who will “take flight” with low code platforms.

Risks of Shadow IT?

The second area of criticism is that low code platforms can make it easy for someone who “knows enough to be dangerous” to, well, do something dangerous. Yes, this is true too, and much has been written about “shadow IT” and business users adopting tools not sanctioned or supported by the IT department.

oracle apex built in features

However, much has also been written about the need to embrace shadow IT. While there certainly are risks to manage, low code platforms often provide guardrails and can in fact encapsulate and enforce “best practices”.  For example, Oracle APEX includes built-in features to help citizen developers make good design choices and be mindful of application security. And, since APEX runs entirely in the database, any applications developed by citizen developers can be carefully monitored by experienced DBAs using tools like Oracle Enterprise Manager, and disabled if problems arise.

Incidentally, this is also where you’ll hear critics bring up tools like Microsoft Access or FoxPro, along with amusing anecdotes about a monstrosity someone built that blew up and almost ended the world. Yes, this has happened, and in fact, I’ve built a few of those monstrosities myself. However, for every MS Access horror story out there, there also exists a story about how an MS Access application built by a citizen developer was of enormous benefit to a business (I’ve built a few of those too).

Clearly, the net gain from tools like MS Access and FoxPro has been very positive for businesses overall, and I believe the same will prove to be true for low code platforms.

Being Left Behind

The biggest risk with low code platforms is that overly cautious IT managers will ban them altogether, and in doing so throw the proverbial baby out with the bath water. In banning such tools, they reduce their organization’s “solutions surface area”, and limit their ability to innovate and keep pace with more forward thinking competitors. (In fact, overly restrictive IT policies that kill innovation is the subject of my next post.)

low code it managers

The truth is, more and more organizations are seeing the benefit of low code platforms. Not only do they reduce complexity and improve delivery speed, but they also act as a “force multiplier” by unlocking the creativity and ingenuity of a broader group of people. If the history of companies who are slow to adopt new technology is our guide, not exploring the possibilities of low code platforms will prove to be a costly mistake.

The post Oracle APEX: Low Code, High Innovation appeared first on Insum.

So what are my experiences using EECS doing some APEX work?

First of all, it is not blazing fast. Probably caused by the latency (as mentioned in my previous post). It is not slow, it is just ok('ish). 

Second, and way more important, it runs APEX 5.0.4! So whatever Oracle advertises about "Cloud first" ... it doesn't seem to apply to APEX (or APEX on EECS). So this fact alone makes this environment useless for demo, development and presentation purposes at this moment. I heard through the grapevine that 5.1 will be available from April 25 - but that's still a month away. And that rumour could be false.

Third, because you don't have access to a SYS account, you can't install something like APEX-SERT. Maybe the install scripts can be adapted for the PDB_ADMIN account - I haven't looked into that yet.

Four : As mentioned in an earlier post, within an EECS PDB instance you get one and only one APEX Workspace. You can't add one (nor delete). You can create as much schema's as you wish, but you have to assign them all to that same Workspace. Thus if you need more Workspaces, you either buy multiple EECS instances or look into another - more expensive - Database Cloud offering.

Five : The default Authentication Scheme is the new "Oracle Cloud Identity Management" scheme. If you have admin rights for the Service you can add users in that layer. If you would like to use "APEX Users" as an Authentication Scheme, you need admin rights as well to create those users. Or create your own scheme if you like that better.

And finally, when you buy an EECS, you get a Customer Support (CSI) number. You should be able to use this number to access My Oracle Support (MOS) to get information, ask questions etc. But the first few weeks that number was not recognised by MOS. But as I tried it again today, it seems to "know" the number and registration is in progress.

Reading the points above and the previous post, you might think EECS is not that good. But that all depends on what you expect to get for your money. Compared with other Oracle Cloud products, EECS is rather cheap. At some points it could do better, but especially when the service is upgraded to APEX 5.1, I will use it more for demo / development and presentations. Multiple Workspaces would be second on my wish list. 

And also Oracle announced a free APEX development environment a while ago - comparable to apex.oracle.com, but with that major difference that you are officially allowed to develop applications in that new environment (apex.oracle.com is targeted as a playground - despite all the development that is probably happening there....). 
Next