DEV Community: Stephen Omotto

Learning AWS Cloud Computing Practitioner - Cloud Concepts Overview

Stephen Omotto — Thu, 03 Jul 2025 21:18:47 +0000

Introduction to Cloud Computing
This is basically the on-demand delivery of computing power, database, storage, applications and other IT resources via the internet with pay-as-you-go pricing.

Cloud Service models

Infrastructure as a services(IaaS)
Platform as a Service(PaaS)
Software as a Service(SaaS)

IaaS

This is the basic building block for the cloud information technology
Provides access to networking features,computers whether its virtual or dedicated
Provide storage space
Provides highest level of flexibility and control over IT resources

PaaS
It removes the need to manage the underlying infrastructure(hardware and OS). It does it through automation and allows you to focus on the deployment and management of your applications as opposed to the provisioning.

SaaS

Provides a complete product that is run and managed by the service provider
Refers to end-user applications
You don't have to think about how the software is maintained or how your infrastructure is managed.You have less control over IT resources.
You only need to use that particular piece of software. Example of SaaS is web-base email application

Cloud Computing deployment models

Cloud
Hybrid
On-premises

Advantage of Cloud Computing
1. Trade capital expense for variable expense
Instead of buying expensive servers upfront, you only pay for the computing resources you actually use, like paying for electricity based on consumption rather than buying a power plant.

2. Benefits from massive economies of scale
Because of aggregate usage from all customers, AWS can achieve higher economies of scale and pass savings onto customers.

3. Stop guessing capacity
You don't have to guess how much server power you'll need - the cloud automatically adjusts up or down based on actual demand, so you never run out of resources or waste money on unused capacity.

4. Increase speed and agility
You can launch new applications and services in minutes instead of weeks, since cloud resources are instantly available without waiting for hardware procurement and setup.

5. Stop spending money on running and maintaining data centers
You eliminate the costs of building, powering, cooling, and staffing your own data centers by using someone else's infrastructure instead.

6. Go global in minutes
You can deploy your application in multiple AWS regions around the world with just a few clicks. As a result, you can provide lower lower latency and better experience for your customer simply and at a minimal cost.

Introduction to AWS

A web service is any piece of software that makes itself available over the internet and uses a standardized format- such as Extensible Markup Language(XML) or Javascript Object Notation(JSON)- for the request and response of an application programming interface(API) interaction. AWS is a secure cloud platform that offers a broad set of global cloud-based products.
AWS provides you with on demand access to compute, storage, network,database and other IT resources and management tools.
It offers flexibility - Its environment can be reconfigured, updated on demand, scaled up or down automatically to meet usage patterns and optimize spending. Its services becomes an operational expense instead of a capital expense. Its services also works as a building blocks.

Categories of AWS services

Analytics
Application Integration
AR and VR
Blockchain
Business Applications
Compute
Cost Management
Customer Engagement
Database
Developer Tools
End User Computing
Game Tech
Internet of Things
Machine Learning
Management and Governance
Media Services
Migration and Transfer
Mobile
Networking and Content Delivery
Robotics
Satellite
Security, Identity, and Compliance
Storage

Note:
Choosing a service will depend on your business goals and technology requirements.

Services that you'll cover at CCP level
Compute services

Amazon EC2
AWS Lambda
AWS Elastic Beanstalk
Amazon EC2 Auto Scaling
Amazon ECS
Amazon EKS
Amazon ECR
AWS Fargate

Storage services

Amazon S3
Amazon S3 Glacier
Amazon EFS
Amazon EBS

Security, Identity, and
Compliance services

AWS IAM
Amazon Cognito
AWS Shield
AWS Artifact
AWS KMS

Networking and Content
Delivery services

Amazon VPC
Amazon Route 53
Amazon CloudFront
Elastic Load Balancing

Database services

Amazon RDS
Amazon DynamoDB
Amazon Redshift
Amazon Aurora

Management and
Governance services

AWS Trusted Advisor
AWS CloudWatch
AWS CloudTrail
AWS Well-Architected Tool
AWS Auto Scaling
AWS Command Line Interface
AWS Config
AWS Management Console
AWS Organizations

AWS Cost Management
services

AWS Cost & Usage Report
AWS Budgets
AWS Cost Explorer

Three ways to interact with AWS Ecosystem

Aws management console - Easy-to-use graphical interface
Command line interface(AWS CLI) - Access services by discrete commands or scripts
Software Development Kits(SDKs) - Access services directly from your code such as java, python e.t.c

Moving to the AWS Cloud - The AWS Cloud Adoption Framework(AWS CAF)

AWS CAF provides guidance and best practices to help organizations build a comprehensive approach to cloud computing across the organization and throughout the IT lifecycle to accelerate successful cloud adoption.
It is organized into six perspectives, namely:-
- Business
- People
- Governance
- Platform
- Security
- Operations
These perspectives consist of sets of capabilities, ie,
- Business, People and Governance focus on business capabilities
- Platform, Security and Operations focus on technical capabilities

Understanding Java's WORA: Write Once, Run Anywhere

Stephen Omotto — Thu, 05 Jun 2025 07:30:30 +0000

A Deep Dive into Platform Independence and the Java Execution Model

Introduction

Java's "Write Once, Run Anywhere" (WORA) vision transformed my understanding of software portability. The principle behind the theory is that Java code written in one platform will execute seamlessly in another platform without modification or recompilation. But, How is this magic achieved?

The Traditional Programming Challenge

Before Java, developers had a severe issue: programs developed for an operating system could not be run on another with significant modifications. A Windows-executable program would not be run under Linux, and a Linux-executable program would not be run under Windows. This was because:

Direct Hardware Interaction: Programs communicated directly with the OS
Platform-Specific APIs: Every operating system used specific system calls and libraries
Architecture Dependencies: Programs were compiled into processor-native machine code
Binary Incompatibility: Executable programs for each platform

This would mean having several codebases per platform, which would contribute towards development expense and complexity.

Java's Revolutionary Solution: The Abstraction Layer
Java solved the problem by introducing an abstraction layer between the application and the operating system. Instead of compiling into native machine code, Java introduces an intermediate step that generates platform-independent bytecode.

The Java Execution Stack: From Hardware to Application

How Java works across the entire computing stack:
Layer 1: Hardware Foundation

┌─────────────────────────────────────┐
│           HARDWARE LAYER            │
│  CPU (x86, ARM, SPARC, PowerPC)     │
│  Memory (RAM, Cache)                │
│  Storage (HDD, SSD)                 │
│  I/O Devices                        │
└─────────────────────────────────────┘

Layer 2: Operating System

┌─────────────────────────────────────┐
│         OPERATING SYSTEM            │
│  Windows | Linux | macOS | Solaris │
│                                     │
│  • Process Management               │
│  • Memory Management                │
│  • File System                      │
│  • Device Drivers                   │
│  • System Calls                     │
└─────────────────────────────────────┘

Different operating systems provide different interfaces and system calls. Traditional languages must adapt to these differences, but Java applications remain isolated from these variations.
Layer 3: Java Runtime Environment (JRE)

┌─────────────────────────────────────┐
│      JAVA RUNTIME ENVIRONMENT       │
│                                     │
│  ┌─────────────────────────────┐    │
│  │     JAVA VIRTUAL MACHINE    │    │
│  │                             │    │
│  │  ┌─────────────────────┐    │    │
│  │  │   Execution Engine  │    │    │
│  │  │  • Interpreter      │    │    │
│  │  │  • JIT Compiler     │    │    │
│  │  └─────────────────────┘    │    │
│  │                             │    │
│  │  ┌─────────────────────┐    │    │
│  │  │   Memory Areas      │    │    │
│  │  │  • Heap             │    │    │
│  │  │  • Method Area      │    │    │
│  │  │  • Stack            │    │    │
│  │  │  • PC Registers     │    │    │
│  │  └─────────────────────┘    │    │
│  │                             │    │
│  │  ┌─────────────────────┐    │    │
│  │  │   Class Loader      │    │    │
│  │  └─────────────────────┘    │    │
│  └─────────────────────────────┘    │
│                                     │
│  ┌─────────────────────────────┐    │
│  │      JAVA API LIBRARIES     │    │
│  │  • java.lang.*              │    │
│  │  • java.util.*              │    │
│  │  • java.io.*                │    │
│  │  • javax.*                  │    │
│  └─────────────────────────────┘    │
└─────────────────────────────────────┘

The JRE is the crucial abstraction layer that enables WORA. It consists of:
Java Virtual Machine (JVM): The core runtime engine that executes Java bytecode
Java API Libraries: Standard libraries providing common functionality across all platforms

Layer 4: Java Application

┌─────────────────────────────────────┐
│        JAVA APPLICATION             │
│                                     │
│  ┌─────────────────────────────┐    │
│  │      BYTECODE FILES         │    │
│  │     (.class files)          │    │
│  │                             │    │
│  │  MyApp.class                │    │
│  │  Utils.class                │    │
│  │  DataProcessor.class        │    │
│  └─────────────────────────────┘    │
└─────────────────────────────────────┘

The Java Compilation and Execution Process

Step 1: Source Code Creation

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

Developers write Java source code in .java files using human-readable Java syntax.
Step 2: Compilation to Bytecode

javac HelloWorld.java

The Java compiler (javac) translates source code into bytecode:

Source Code (.java)  →  Java Compiler (javac)  →  Bytecode (.class)

What is Bytecode? Bytecode is an intermediate representation that's:

Platform-independent: Not tied to any specific hardware or OS
Compact: More efficient than source code
Secure: Can be verified before execution
Optimizable: Can be further optimized at runtime

Step 3: JVM Execution Process
When you run java HelloWorld, the following happens:
3.1 Class Loading

┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│   .class file   │ → │   Class Loader   │ → │   Method Area   │
│   (Bytecode)    │    │                  │    │   (Memory)      │
└─────────────────┘    └──────────────────┘    └─────────────────┘

The Class Loader subsystem:

1. Loading: Reads .class files and creates binary data in memory
2. Linking: Verifies bytecode integrity and resolves symbolic references
3. Initialization: Executes static initializers and initializes static variables

3.2 Bytecode Verification
The JVM verifies bytecode to ensure:

Type safety
No stack overflow/underflow
Valid bytecode instructions
Proper access control

3.3 Execution Engine Processing
The Execution Engine converts bytecode to native machine code through two methods:
Interpretation:

Bytecode → Interpreter → Native Machine Code → Execution

Reads bytecode line by line
Converts each instruction to native code
Slower but uses less memory Just-In-Time (JIT) Compilation:

Bytecode → JIT Compiler → Optimized Native Code → Execution

Compiles frequently used bytecode to native code
Stores compiled code for reuse
Faster execution after initial compilation

The Abstraction Magic

┌─────────────────────────────────────────────┐
│                APPLICATION                  │
│           (Same Everywhere)                 │
├─────────────────────────────────────────────┤
│                 BYTECODE                    │
│           (Same Everywhere)                 │
├─────────────────────────────────────────────┤
│                   JVM                       │
│         (Platform Specific)                 │
├─────────────────────────────────────────────┤
│              OPERATING SYSTEM               │ 
│         (Platform Specific)                 │
├─────────────────────────────────────────────┤
│                 HARDWARE                    │
│         (Platform Specific)                 │
└─────────────────────────────────────────────┘

Memory Management in the JVM
Heap Memory Structure

┌─────────────────────────────────────────┐
│                 HEAP                    │
│                                         │
│  ┌─────────────┐  ┌─────────────────┐   │
│  │   Young     │  │      Old        │   │
│  │ Generation  │  │   Generation    │   │
│  │             │  │                 │   │
│  │ ┌─────────┐ │  │                 │   │
│  │ │  Eden   │ │  │                 │   │
│  │ └─────────┘ │  │                 │   │
│  │ ┌─────────┐ │  │                 │   │
│  │ │Survivor │ │  │                 │   │
│  │ │   S0    │ │  │                 │   │
│  │ └─────────┘ │  │                 │   │
│  │ ┌─────────┐ │  │                 │   │
│  │ │Survivor │ │  │                 │   │
│  │ │   S1    │ │  │                 │   │
│  │ └─────────┘ │  │                 │   │
│  └─────────────┘  └─────────────────┘   │
└─────────────────────────────────────────┘

┌─────────────────────────────────────────┐
│              METHOD AREA                │
│  • Class metadata                       │
│  • Method information                   │
│  • Constant pool                        │
│  • Static variables                     │
└─────────────────────────────────────────┘

Performance Implications of WORA
Initial Execution Overhead

Traditional Compiled Language:
Source → Native Code → Execute (Fast)

Java:
Source → Bytecode → JVM → Native Code → Execute (Initial Overhead)

Runtime Performance Benefits

JIT Optimization: Hot code paths get optimized beyond static compilation
Garbage Collection: Automatic memory management
Runtime Profiling: JVM learns application behavior and optimizes accordingly

Real-World WORA Examples
Enterprise Application Deployment

Development Environment (Windows):
MyApp.java → MyApp.class

Production Environment (Linux):
Same MyApp.class → Runs without modification

Microservices Architecture

Container 1 (Alpine Linux): Java App A
Container 2 (Ubuntu): Java App B  
Container 3 (CentOS): Java App C
All running identical JAR files

Limitations and Considerations
When WORA Might Not Apply

Native Code Integration: JNI calls to platform-specific libraries
File System Differences: Path separators, case sensitivity
Environment Variables: Platform-specific configurations
Hardware-Specific Features: Direct hardware access requirements

Best Practices for True WORA

Use Java Standard APIs: Avoid platform-specific libraries
Abstract File Operations: Use File.separator instead of hardcoded paths
Configuration Management: Externalize environment-specific settings
Testing Across Platforms: Verify behavior on target platforms

Conclusion

Java's WORA principle is a fundamental shift in software development philosophy. Through the JVM as an abstraction layer, Java provides for the ability to write once and run anywhere, reducing development and maintenance costs by a tremendous amount.
Magic is enabled by the careful orchestration of:

Compilation to bytecode instead of machine-native code
JVM as a platform-specific interpreter that translates bytecode to native instructions
Standardized APIs that have uniform interfaces between platforms
Runtime optimization that can compete with conventional compiled language performance.

Understanding this architecture is crucial for Java programmers, as it not only explains how Java works, but also why certain design decisions were taken and how to really write portable programs.

The journey from source code to run time via hardware, operating systems, the JRE, bytecode, and ultimately the running program demonstrates the elegance of the engineering that makes Java's "Write Once, Run Anywhere" vision a reality in software today.

Unlocking Agile: Beyond the framework

Stephen Omotto — Fri, 04 Oct 2024 07:01:32 +0000

AGILE is a collection of techniques and approaches that improves decision-making, productivity, and thinking skills within your team.
All aspects of traditional software engineering, such as project management, software design and architecture, and process optimization, are covered by these techniques. To make them as simple to implement as feasible, they are composed of procedures that have been streamlined and optimized.

Because an appropriate mindset can significantly impact how well a team applies the techniques, AGILE is also a mindset. This mindset facilitates information sharing among team members so that important project choices can be made collectively rather than by a manager acting as the decision-maker in isolation. Embracing an agile mentality involves including the entire team in planning, design, and process optimization. Every member of an agile team participates in the application of the techniques and shares the same information as the group as a whole.

For many teams that have not experienced as much success, agile has turned out to be very different from what it promised, and a big part of that variance is frequently the attitude the team brings to every project. Most software development businesses have dabbled in agile, and while many of them have found success, some teams have produced less-than-ideal outcomes. They’ve made some progress in how they run their projects—enough to make the effort to embrace agile worth it—but they haven’t seen the major changes that they feel agile promised them. This is the main idea behind the mentality shift: "going agile" refers to assisting the team in developing a productive mindset.
However, what exactly does "mindset shift" mean? Working on a software team entails planning, designing, developing, and releasing software on a daily basis. What connection does "mindset" have to that? It turns out that how you and your teammates approach them affects a lot of the procedures you employ in your day-to-day work.
Here's an illustration. The daily standup, a gathering when team members discuss their goals and issues, is one of the most popular agile methods used by teams. We keep the meeting brief by having everyone stand the entire time. Adding a daily standup to a project has shown to be quite successful for numerous teams.

Understanding Agile values(Agile manifesto)

Individual and interactions over processes and tools
Working software over comprehensive documentation
Customer collaboration over contract negotiation
Responding to change over following a plan

KEY POINTS ON AGILE VALUES

• The Agile Manifesto contains common values and ideas that lead to effective teams.
• “Individuals and interactions over processes and tools” means the team should focus on the people on the team and how they communicate first, and the tools and practices that they use second.
• “Working software over comprehensive documentation” means that delivering software that does what users need is more important than delivering a specification that describes it.
• Working software means software that delivers value to the company.
• “Customer collaboration over contract negotiation” means treating everyone like they’re on the same team.
• Many effective agile teams treat the product owner as a member of the project team to collaborate with, rather than a client or customer to negotiate with.
• “Responding to change over following a plan” means recognizing that plans become inaccurate, and that it’s more important to deliver the software than it is to work the plan.
• A task board is an agile planning tool in which user stories are attached to a board and categorized into columns based on their status in the current project or iteration.

The 12 Principles of Agile Software

Our highest priority is to satisfy the customer through early and continuous delivery of valuable software- The customer is always right.
Welcome changing requirements, even late in development. Agile processes harness change for the customer’s competitive advantage. It means:
a. Nobody gets in "trouble" when there's a change.
b. We're all in this together.Everybody is collaborating.
c. We don't sit on change until it's too late.
d. We stop thinking of change as mistakes.
e. We learn from the changes. This is the most effective way for a team to grow and get better at building software together.
Deliver working software frequently, from a couple of weeks to a couple of months, with a preference to the shorter timescale. By using time-boxed iteration to deliver working software frequently, agile teams constantly adjust the project so that it delivers the most value to the customer
The most efficient and effective method of conveying information to and within a development team is face-to-face conversation. When people on the team don't communicate on a face to face basis, they may agree on the broad strokes, but end up working toward different goals. Comprehensive documentation can make this worse by making it easy to introduce ambiguity.
Collaboration between business analysts and developers on a daily basis throughout the project yields greater efficiency. This is due to the fact that business professionals must wait until the very end of the project to review and provide input on the team's performance, and finalizing modifications at this point in the project is far more costly.
Build projects around motivated individuals. Give them the environment and support they need, and trust them to get the job done.
Working software is the primary measure of progress.It is better than progress reports for giving everyone the latest update on the project’s status, because it’s the most effective way for the team to communicate what they’ve accomplished. This is one reason why agile teams use iterative development. By delivering working software at the end of each iteration, and by doing a real product demonstration that shows everyone exactly what the team did, they keep everyone up to date on the progress of the software in a way that is almost impossible to misread.
Agile processes promote sustainable development. The sponsors, developers, and users should be able to maintain a constant pace indefinitely.
Continuous attention to technical excellence and good design enhances agility.
Simplicity—the art of maximizing the amount of work not done—is essential.Agile teams keep their solutions as simple as possible by avoiding building unnecessary features or overly complex software.
The best architectures, requirements, and designs emerge from self-organizing teams.Self-organizing teams share responsibility for all aspects of the project, from conceiving the product to project management to design and implementation.
At regular intervals, the team reflects on how to become more effective, then tunes and adjusts its behavior accordingly.By taking the time to look back and talk about lessons they learned after each iteration and also at the end of the project, agile teams constantly get better at building software.

POPULAR AGILE METHODOLOGIES

Just a brief definitions of them:
Scrum,extreme programing(XP), Lean and Kanban

1. Scrum and Self-organizing teams
Scrum is a potent framework that emphasizes incremental progress, continuous improvement, and cooperation in Agile project management. Scrum assists organizations in navigating the complexity and uncertainty of product development by emphasizing the delivery of value in small increments and cultivating a strong team dynamic.

2. Extreme programing(XP)
A strong Agile methodology, Extreme Programming places a strong emphasis on close client and developer cooperation as well as technical quality. Through the use of techniques like pair programming, TDD, and continuous integration, XP supports teams in producing high-caliber software that satisfies user needs in a setting that is changing quickly. With its emphasis on feedback, simplicity, and communication, it works especially well for projects whose requirements change often.

3. Lean
Within Agile, the Lean methodology emphasizes efficiency, continuous improvement, and customer satisfaction while delivering maximum value with little waste. Teams can improve their ability to collaborate, respond more quickly to changing needs, and streamline their operations by implementing Lean concepts and practices. This method works well with the Agile principles of flexibility and customer-focused development, which makes it a potent tactic in contemporary software development.

4. Kanban
Effective Agile methodology Kanban places a strong emphasis on efficiency, visual management, and ongoing development. Through the implementation of Kanban boards and concepts, teams may improve workflow management, foster collaboration, and increase customer value delivery. Because of its adaptability and emphasis on flow, it works especially effectively in settings where priorities and requirements shift regularly.

The figure above shows how Scrum, XP, and Lean all have the agile values at their core, and share some values, ideas, and practices with each other.

The Agile Software Development Life Cycle

The Agile SDLC is the structured series of stages that a product goes through as it moves from beginning to end. It contains six phases:
1. Concept: Define the project scope and priorities
2. Inception: Build the Agile team according to project requirements
3. Iteration: Create code factoring in customer feedback
4. Release: Test the code and troubleshoot any issues. When all of this is complete, the product’s final iteration can then be released into production.
5. Maintenance: Provide ongoing tech support to ensure the product remains serviceable
6. Retirement: The end of the product lifespan, which often coincides with the beginning of a new one. The product will enter this phase if it is being replaced with new software, or the system itself has become obsolete or incompatible with the organization over time.The software development team will first notify users that the software is being retired. If there is a replacement, the users will be migrated to the new system.

Depending on the project management approach a team chooses, the Agile life cycle will differ slightly. Scrum teams, for instance, operate in brief intervals called sprints, which are comparable to iterations. Additionally, they have distinctly defined roles—like Scrum master. Kanban teams, on the other hand, operate more like continuous flows without roles that are necessary. Extreme Programming is another example, where teams prioritize engineering techniques and work in shorter iterations. However, the goal of all software development teams is the same: to deliver working software to users on time.