What a development machine needs¶

Practical 5.9 what-a-development-machine-needs-annex.pdf · PDF

An Android app runs happily on a phone with a few GB of RAM. For the computer where that same app is built, Google recommends 32 GB. Why does making an app cost so much more than using it?

Until today you looked after machines for other people. From today the customer is you: next year you will write apps. The question is simple: is this machine good enough, and how do you prove it? "It is a good computer" means nothing until you say: good for what?

The test kitchen¶

Since Unit 1 our kitchen has served dishes: the CPU is the chef, RAM the countertop, the disk the pantry. A development machine is a test kitchen: recipes are written, tried, thrown away and tried again. It needs everything a normal kitchen has, plus the tools to invent.

Reading the bill: official requirements¶

Every tool says what it needs on its vendor's page. These are the numbers from Microsoft, JetBrains and Google, read in October 2026 (they change: always check the current page).

Two words in that table need a definition:

• VT-x (Intel) and AMD-V (AMD) are the CPU features for hardware virtualisation, the same ones that let your PC run deb-lab at near full speed (Unit 2).
• glibc is the GNU C library: the basic library almost every Linux program uses to talk to the kernel. A tool built for a newer glibc will not start on an older system.

Why the emulator is so expensive¶

An emulator is not just another app: it is a virtual machine running a full Android system with its own RAM. Google's figure is about 4 GB of memory for each virtual device that is running. And, like any VM, it needs VT-x or AMD-V. That is the answer to the hook: building the app means running the phone inside your computer, next to the IDE.

flowchart TB
    subgraph PC ["Your development PC: the RAM bill"]
        OS["<b>Operating system</b><br>the kitchen manager"]
        IDE["<b>IDE</b><br>Android Studio: the workbench"]
        EMU["<b>Emulator</b><br>a whole phone: ~4 GB each"]
        BUILD["<b>Compiler and build tools</b><br>the cooks, at full speed"]
    end
    OS --- IDE
    IDE -->|"builds the app"| BUILD
    BUILD -->|"installs it on"| EMU

Measure the machine¶

Before you compare, measure. Five commands, run in deb-lab and then in a terminal on the Ubuntu host:

nproc                                # processor threads
free -h                              # line Mem, column total: the RAM
df -h /                              # column Avail: free disk
ldd --version | head -1              # glibc version
grep -Ec '(vmx|svm)' /proc/cpuinfo   # 0 = no hardware virtualisation

The last command counts the lines of /proc/cpuinfo that mention vmx (Intel's VT-x flag) or svm (AMD-V). Any number above 0 means "yes". On the host you will see a number like 8 or 12, one per thread.

Your VM is a perfectly good server and a bad Android workstation. Good for what?

Runtimes: write once, run anywhere¶

In 1995 Sun Microsystems presented Java with a promise: write once, run anywhere. The trick: the Java compiler does not produce a program for one kind of CPU. It produces bytecode for an imaginary machine, the Java Virtual Machine (JVM). Any real computer with a JVM can run it. The price: the JVM, the runtime, has to be installed first. Kotlin, the language you will use for Android, is built on the same idea.

flowchart LR
    SRC["<b>Hello.java</b><br>source code: the recipe"] -->|"javac<br>compiler, in the JDK"| BC["<b>Hello.class</b><br>bytecode"]
    BC -->|"java<br>the JVM, the runtime"| RUN["<b>The program runs</b><br>on Linux, Windows, macOS"]

Versions and LTS¶

A new Java version comes out every six months. Some are LTS (Long-Term Support): companies stay on them for years. Today 21 (2023) and 25 (September 2025) are LTS. Debian 13 installs OpenJDK 21 by default.

Install a toolchain in deb-lab¶

A toolchain is the set of tools you need to build a program: here, the JDK and Git.

$ java -version
bash: java: command not found
$ sudo apt update
$ sudo apt install default-jdk-headless git

Before you press Y, read the line "After this operation, ... of additional disk space will be used." On a minimal Debian the download is about 136 MB and it takes 341 MB on disk. Then check the three tools:

java -version      # openjdk version "21.0.x"
javac -version     # javac 21.0.x
git --version      # git version 2.47.3

Where does it live?¶

After apt install, why does java just work? The answer is PATH, the list of directories the shell searches when you type a command (you set it in Configuring the system by command).

$ which java
/usr/bin/java
$ readlink -f /usr/bin/java
/usr/lib/jvm/java-21-openjdk-amd64/bin/java

/usr/bin is in PATH, and /usr/bin/java is a symbolic link: a signpost that points to the real JDK in /usr/lib/jvm. With two JDKs installed, the signpost decides which one answers.

Many tools do not use PATH for this: they read the environment variable JAVA_HOME, which tells them where the JDK is. It is empty until somebody sets it. You, in ~/.bashrc:

echo 'export JAVA_HOME=/usr/lib/jvm/default-java' >> ~/.bashrc
source ~/.bashrc
echo $JAVA_HOME
$JAVA_HOME/bin/java -version     # the same version as before

Your first Java program¶

mkdir ~/hello-java
cd ~/hello-java
nano Hello.java

Type exactly:

public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello from Java " + System.getProperty("java.version")
            + " on " + System.getProperty("os.name"));
    }
}

$ javac Hello.java
$ ls
Hello.class  Hello.java
$ java Hello
Hello from Java 21.0.x on Linux

javac prints nothing when it works: silence is success. It creates Hello.class, the bytecode. Then java runs it on the JVM.

Finally, run df -h / again: the toolchain cost a few hundred MB of disk, close to what apt announced.

Sizing the laptop for a new developer¶

Tramuntana Apps hires an Android developer. Which laptop do you ask for? Every line must be argued with a number from the requirements table.

If the budget only allows one upgrade, RAM or CPU? RAM: below 16 GB the emulator does not fit at all.

Now do it all yourself, measure, install, compile and decide, on the Practical 5.9 sheet (button at the top of the page).

Key takeaways¶

• A developer's toolchain has a compiler (source code to something runnable), a runtime (needed to run it, like the JVM), an SDK (the full kit, like the JDK), an IDE (the workbench) and often an emulator (a whole device as a VM).
• Requirements come in minimum (it starts) and recommended (it works for a day). Read the recommended one.
• The Android emulator is a virtual machine: about 4 GB of RAM per running device, and it needs VT-x / AMD-V.
• Measure before you decide: nproc, free -h, df -h /, ldd --version, grep -Ec '(vmx|svm)' /proc/cpuinfo.
• java is found because /usr/bin is in PATH and /usr/bin/java is a symbolic link to the JDK; many tools read JAVA_HOME instead.
• Java (1995) compiles to bytecode with javac and runs it on the JVM with java. Pick the version the project asks for, usually an LTS.

Quick check¶

Next: two projects that need two different versions of the same library on one machine — Dependencies and isolated environments.