The Oracle Story

                              No one after lighting a lamp puts it under the bushel basket, but on the lampstand, and it gives light to all in the house
                                                                                                                                                             Mathew 5:15

Oracle corporation, initially called Software Development Laboratories, was founded in 1977 by Larry Elison and Bob Miner, computer programmers at Ampex Corporation, an American electronics company along with Ed Oates, Elison's supervisor at Ampex. The idea for the relational database was inspired by a paper by Edgar F Codd that outlined a relational model. They had the vison of making this data management concept commercial as it arranged large amounts of data efficiently and also enabled quick retrieval. Thus the trio started developing the program based on Codds theory and in 1979 the company released Oracle, the earliest commercial relational database program using structured query language. 

Once he learned the skills and concepts for relational databases Larry Ellison began to pursue his dream to start a data management company now know as Oracle. In the early years it was in competition with IBM which was also in the race to develop a relational database at that time. The IBM database is IBM DB2. But of the two Oracle is more widely used and popular.

Its first customer was the US Air Force which used the program at its air force base.

Oracle has grown from its humble beginnings as one of a number of databases available in the 1970s to the overwhelming market leader today.

In 1978 the first Oracle software was born, written in assembly language running on PDP-11 under RSX-11 in 128K memory. The first Oracle version was never released and the implementation separated oracle code from user code. The name Oracle came from the code name of a CIA project that the three original founders Elison, Bob and Ed had worked on in Amex Corporation.

In the year 1979,they offered the first commercial SQL relational database management system. The second version of Oracle released ran on PDP-11 hardware and they named it as Oracle v2 to capture more customers and they starting promoting it on the VAX platform.

In 1984 the database software was ported to the PC platform with the MS-DOS version 4.1.4 running on 512K memory.

In 1985 it was released to operate in client-server mode.

Initial funding was through personal funding of its founders and Venture Capitalists and it went public in 1986 and was then financed through its IPO and since then it has not raised any additional funds through Venture Capitalist or private investors.

In 1987 UNIX-based Oracle applications were introduced and a year later Oracle v6 was released with hot backups, embedded PL/SQL procedural engine within the database and support for row-level locking. In 1988 Oracle induced PL/SQL. The growth in the company led to relocation of the world headquarters to Redwood Shores, California in 1989 and revenues reaching $584 million.

In 1989, Oracle moved its headquarters to Redwood City, California. 

In 1995, Oracle Systems Corporation changes its name to Oracle Corporation and it became the first large software company to report an internet strategy and offered the first 64-bit RDBMS.

In June 1998 Oracle v8 was released with internet technology, support for terabytes of data and SQL object technology. 

In 1998 they announced integrating a JVM with the oracle database and in September of that year Oracle 8i was release, with i standing for internet. 

In 1999 Oracle offered its first DBMS with XML support.

In 2010 Oracle Corporation acquired Sun Microsystems After the merger Oracle owned Sun's hardware product lines as well as Sun's software product lines including the JAVA programming language.

My tryst with JAVA

Oracle Corporation has now diversified into a range of services like Oracle cloud services, Oracle middleware, Oracle Beehive, Financial services, hardware systems etc.

Middleware includes weblogic server which is a J2EE server and Oracle fusion middleware.

Oracle applications include ERP, CRM and Human Capital Management HCM.

Cloud services include SaaS Software as a service, PaaS Platform as a Service, IaaS  Infracture as a Service and DaaS Database as a Service.

More on the history and the growth of the relational database can be found in the articles below

Key Events and Milestones 

Secrets to 50 years of relational database success: innovation, evolution

References 

https://www.britannica.com/topic/Oracle-Corporation 

https://www.oreilly.com/library/view/database-systems-concepts/9788177585674/9788177585674_ch24lev1sec2.html https://en.wikipedia.org/wiki/Oracle_Corporation 

https://www.geeksforgeeks.org/oracle-company-overview-history-products/

https://content.dsp.co.uk/the-history-of-oracle-corporation-1977-2000

Thought for the day

Courage to continue matters more than success or failure.

--Winston Churchill

Java : Using Maven to build and compile your HelloWorld application

Install java, set the JAVA_HOME to the java installation path and 
PATH variable to existing PATH + %JAVA_HOME%\bin folder.

Install MAVEN and set MAVEN_HOME to the maven installation path and
PATH variable to existing PATH + %MAVEN_HOME%\bin folder.

If I want to create a java program, compile and run it following are the steps I will do.

(BASE_FOLDER)/com/example

App.java

package com.example;

public class App {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

On the command prompt, In BASE_FOLDER compile the App.java as below

javac com/example/App.java

Run the App.java file as below

java com.example.App

Hello, World!

But when I have a whole project will hundreds of .java files, dependent jar files and libraries, compiling the individual files and specifying the classpath for the various dependent objects becomes unmanageable. Tools such as Ant, Make and Maven are specifically for this purpose.

Apache Maven is a build tool for java projects. Using a project object model (POM), Maven manages a projects compilation, testing and documentation. It is developed by the Apache Software Foundation. (https://maven.apache.org/).  It automates the process of compiling code, managing external dependencies, running tests and packaging applications into distributable formats like JAR or WAR files.  It operates on the principle of "Convention over Configuration," meaning it provides standard layouts and lifecycles so you only specify exceptions.

The Core Blueprint: POM (pom.xml)

Every Maven project is driven by a pom.xml (Project Object Model) file located at the root directory. It holds the project's configurations, identity, and required plugins. [1, 2]

Project Coordinates: Every project defines its unique identity via three core coordinates:
• groupId: The organization or company domain name (e.g., com.example).
• artifactId: The unique name of the project or module (e.g., my-app).
• version: The current version of the project (e.g., 1.0.0-SNAPSHOT). [1, 2, 3]
Super POM: If a configuration is missing, Maven inherits default settings from a global "Super POM," which automatically maps standard directories and sets Maven Central as the default remote repository. [1, 2, 3, 4]

Automated Dependency Management

Maven eliminates the hassle of manually downloading and tracking third-party .jar files. [1]

Transitive Dependencies: When you add a library (e.g., Spring Boot), Maven automatically analyzes that library's dependencies and downloads them as well, preventing version conflicts. [1, 2]
The Layered Repository System:
1. Local Repository: A hidden folder on your machine (~/.m2/repository) that caches downloaded files to speed up subsequent builds.
2. Central Repository: An online community-maintained library where thousands of open-source components live.
3. Remote Repository: Private or company-internal servers used to host proprietary artifacts or proxy external traffic. [1, 2]

Standard Directory Structure

Maven dictates a specific structure out of the box, ensuring that any developer stepping into the project instantly knows where files live. [1, 2]

src/main/java: Houses the production Java source code.
src/main/resources: Contains configuration files, properties, and static assets.
src/test/java: Dedicated to test frameworks like JUnit or TestNG classes.
target/: The output directory where compiled .class files and final packaged binaries are generated. [1, 2, 3, 4, 5]

The Build Lifecycle and Phases

Maven functions through a sequence of steps known as Build Phases. When you execute a phase, Maven automatically runs every preceding phase in that sequence. [1, 2, 3]

The primary default lifecycle includes: [1, 2, 3, 4]

validate: Assures that the project structure is correct and all information is available.
compile: Converts Java source code into bytecode (.class files).
test: Runs unit tests within the project.
package: Packages the compiled code into a distributable format (like a .jar).
verify: Runs integration tests to ensure quality criteria are met.
install: Pushes the package into your local .m2 repository so other local projects can use it.
deploy: Pushes the final package to a remote repository to share with the production team or community. [1, 2, 3, 4, 5]

Commonly combined commands include mvn clean install, which wipes the target/ directory (clean lifecycle) and rebuilds/installs the application from scratch.

Below is an example for creating a MAVEN pom.xml file to compile and run App.java with a brief explanation for each of the maven tags.

<project xmlns="http://apache.org" xmlns:xsi="http://w3.org"
  xsi:schemaLocation="http://apache.org http://apache.org">
<modelVersion>4.0.0</modelVersion>  
 
	<groupId>com.example</groupId>
	<artifactId>myapp1</artifactId>
	<version>1.0-SNAPSHOT</version>
	<properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
    </properties>

	<build>
        <plugins>
            <plugin>
				<groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>3.1.0</version>
                <configuration>
                    <mainClass>com.example.App</mainClass>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

The Root and Metadata Elements

<project xmlns="http://apache.org" xmlns:xsi="http://w3.org" xsi:schemaLocation="http://apache.org http://apache.org">

<project>: The root tag that encloses the entire Maven configuration.

xmlns and xsi: These tell your code editor and Maven where to find the rules (schemas) for validating the XML structure. 

<modelVersion>4.0.0</modelVersion>

<modelVersion>: Defines the version of the POM structure layout. Version 4.0.0 is the mandatory standard for Maven 2 and Maven 3.

Project Coordinates (The GAV)

These three elements uniquely identify your project across the Java ecosystem.

<groupId>com.example</groupId>

<groupId>: The organization or package name. It usually follows reverse domain name rules (like com.companyname).

<artifactId>myapp1</artifactId>

<artifactId>: The specific name of your project. This becomes the actual name of your compiled JAR file.

<version>1.0-SNAPSHOT</version>

<version>: The current version of your app. -SNAPSHOT means it is a work-in-progress development version.

<properties>
    <maven.compiler.source>17</maven.compiler.source>
    <maven.compiler.target>17</maven.compiler.target>
</properties>

<properties>: A section used to define variables or settings.

source: Tells Maven your source code is written using Java 17 features.

target: Tells Maven to compile bytecode that is fully compatible with Java 17 runtimes.

<build>: Contains configurations that manage how your project compiles, runs, and bundles.

<plugins>: A wrapper tag holding the list of external tools/extensions Maven will use.      

<plugin>
	<groupId>org.codehaus.mojo</groupId>
	<artifactId>exec-maven-plugin</artifactId>
	<version>3.1.0</version>

• <plugin>: Declares an external tool to use.
• groupId & artifactId: Points Maven to download the official plugin that can execute Java programs.
• version: Locks down the version of the plugin so your build remains stable over time.        

<configuration>
	<mainClass>com.example.App</mainClass>
	</configuration>

• <configuration>: Passes custom settings directly to the plugin.
• <mainClass>: Tells the plugin exactly where your public static void main method lives so it knows what to run.

We can now build and run the App.java using maven on command line as follows

D:\java\HelloWorld\myapp1>mvn exec:java
[INFO] Scanning for projects...
[INFO]
[INFO] -------------------------< com.example:myapp1 >-------------------------
[INFO] Building myapp1 1.0-SNAPSHOT
[INFO]   from pom.xml
[INFO] --------------------------------[ jar ]---------------------------------
[INFO]
[INFO] --- exec:3.1.0:java (default-cli) @ myapp1 ---
Hello, World!
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  0.287 s
[INFO] Finished at: 2026-07-20T18:12:01+05:30
[INFO] ------------------------------------------------------------------------

See what below command does

mvn archetype:generate -DgroupId=com.example -DartifactId=my-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false