TensorFlow or Java First What Beginners Should Pick

# A tiny TensorFlow model — the building block of ML

import tensorflow as tf

model = tf.keras.Sequential([
    tf.keras.layers.Dense(64, activation="relu", input_shape=(10,)),
    tf.keras.layers.Dense(32, activation="relu"),
    tf.keras.layers.Dense(1, activation="sigmoid")
])

model.compile(
    optimizer="adam",
    loss="binary_crossentropy",
    metrics=["accuracy"]
)

model.fit(X_train, y_train, epochs=20, batch_size=32)

# What this does:
# - Builds a small neural network
# - Trains it on data (X_train, y_train)
# - Produces predictions from new data
#
# This is the whole point of TensorFlow:
# turning data into a trained model that can predict.
#
# It requires Python, and it's not a substitute
# for learning how to program — it sits on top
# of that knowledge.

// A tiny Java class — the building block of backend code

public class Order {

    private final String orderId;
    private final double amount;
    private final OrderStatus status;

    public Order(String orderId, double amount) {
        this.orderId = orderId;
        this.amount = amount;
        this.status = OrderStatus.PENDING;
    }

    public void markPaid() {
        if (this.status != OrderStatus.PENDING) {
            throw new IllegalStateException(
                "Only pending orders can be paid"
            );
        }
        this.status = OrderStatus.PAID;
    }

    public String getOrderId() { return orderId; }
    public double getAmount() { return amount; }
    public OrderStatus getStatus() { return status; }
}

// What this does:
// - Defines an object with state (id, amount, status)
// - Enforces rules (only pending orders can be paid)
// - Gives typed access to its fields
//
// This is the whole point of Java:
// writing clear, structured, reliable code
// that runs in real applications.
//
// It teaches you programming fundamentals —
// variables, types, objects, control flow —
// that every software career depends on.

// Java backend calling a TensorFlow model served via FastAPI
// A common pattern in production ML systems.

@RestController
@RequestMapping("/api/recommendations")
public class RecommendationController {

    private final RestTemplate http;
    private final String modelUrl;

    public RecommendationController(
        RestTemplate http,
        @Value("${ml.model.url}") String modelUrl
    ) {
        this.http = http;
        this.modelUrl = modelUrl;
    }

    @PostMapping
    public Recommendation recommend(@RequestBody UserProfile profile) {
        // Build the payload the model expects
        Map<String, Object> payload = Map.of(
            "age", profile.getAge(),
            "past_purchases", profile.getPurchaseCount(),
            "avg_order_value", profile.getAvgOrderValue()
        );

        // Call the model endpoint
        ResponseEntity<Recommendation> res =
            http.postForEntity(modelUrl, payload, Recommendation.class);

        if (!res.getStatusCode().is2xxSuccessful() || res.getBody() == null) {
            throw new ResponseStatusException(
                HttpStatus.SERVICE_UNAVAILABLE,
                "Model unavailable"
            );
        }

        return res.getBody();
    }
}

// Java owns the backend. The model owns the prediction.
// The two interact through a small, typed HTTP contract.

# A TensorFlow model served via FastAPI
# — the "model side" of the same system

from fastapi import FastAPI
from pydantic import BaseModel
import tensorflow as tf
import numpy as np

model = tf.keras.models.load_model("recommendation_model.h5")

app = FastAPI()

class UserProfile(BaseModel):
    age: int
    past_purchases: int
    avg_order_value: float

class Recommendation(BaseModel):
    product_id: str
    score: float

@app.post("/predict", response_model=Recommendation)
def predict(profile: UserProfile):
    x = np.array([[
        profile.age,
        profile.past_purchases,
        profile.avg_order_value,
    ]])

    score = float(model.predict(x, verbose=0)[0][0])
    product_id = "SKU_1042"  # sample output

    return Recommendation(product_id=product_id, score=score)

# Python + TensorFlow own the model.
# Java owns the rest of the product.
# That's how real teams ship ML features.