Mahmoud Abas, Full-Stack Software Engineer & AI

Software Construction - Software Construction Week 1

In the print dialog, choose "Save as PDF" as the destination.

Software Construction Week 1

Foundations: goals, tools, and the Java environment

Agenda

Goals of Software Construction
Tools for this course
Why we use Java
Understanding the Java environment
Types of memory (Stack, Heap)
Value type vs Reference type
Static checking and static typing

Goals of Software Construction

Safe from bugs - correctness (right behavior now) and defensiveness (right behavior in the future)
Easy to understand - code communicates to future programmers (maybe future you) who must fix or extend it
Ready for change - software always changes; good design makes change easy instead of forcing a rewrite

Two Goals When Writing Programs

Communicating with the computer - first satisfy the compiler (syntax and type correctness), then get the logic right so it produces correct results at runtime
Communicating with other people - write code that is easy to understand, so future maintainers can fix, improve, or adapt it

Tools & Why Java

We use Java as the course language and set up its environment
Eclipse is the recommended IDE (any preferred IDE works)
Safety - static type checking catches many errors before runtime; a good language for learning solid engineering practices
Ubiquity - used widely in research, education, and industry; runs on many platforms; huge library ecosystem; excellent free tools (IDEs, compilers, test frameworks, profilers, style checkers)

Understanding the Java Environment

Java was created by Sun Microsystems in 1991 (James Gosling, Patrick Naughton), later acquired by Oracle
Simple to write, compile, and debug
JVM - Java Virtual Machine
JDK - Java Development Kit
JRE - Java Runtime Environment

Compilation & Execution Pipeline

Write

.java source file

Compile

javac turns source into bytecode

Run

the JVM executes the bytecode

JDK, JRE, and Bytecode

Bytecode: javac compiles source into bytecode, saved as a .class file, executed by the JVM

JDK: the full development kit: JRE + compilers + tools (JavaDoc, debugger, etc.) - needed to create, compile, and run Java programs

JRE: a subset of the JDK (JVM + browser plugin/applet support); enough to run a compiled program, but not to compile one

Static Checking Topics

Types
Static checking vs Dynamic checking
Arrays and Collections
Iterating
Methods
Mutating variables vs Reassigning variables

Types in Java

The key semantic difference between Python and Java: Java variables declare a type
Object types, e.g. String - a sequence of characters, like a Python string
Convention: primitive types are lowercase; object types start with a capital letter

Type	Meaning
`int`	integers, roughly ±2^31
`long`	larger integers, roughly ±2^63
`boolean`	true or false
`double`	floating-point numbers
`char`	single characters, e.g. `A` and `$`

Static Typing

Java is statically typed - all variable types are known at compile time, so the compiler deduces the type of every expression
Example: if a and b are int, the compiler knows a + b is also int
Eclipse checks this as you type, catching many errors before you even run the program
Python is dynamically typed - this kind of checking is deferred until runtime

Static, Dynamic, and No Checking

Static checking: the bug is found automatically before the program runs (syntax errors, wrong names like Math.sine(2), wrong argument count/types, wrong return type)

Dynamic checking: the bug is found automatically when the code executes (illegal argument values like divide-by-zero, out-of-range indexes)

No checking: the language doesn't catch it at all; you must watch for it yourself or get a silently wrong answer

Watch Out

Primitives Are Not True Numbers

Integer division: 5/2 truncates to an integer, it does not return a fraction

Integer overflow: int and long are finite ranges; a computation that overflows quietly wraps around to the wrong answer instead of erroring

Special floating-point values: double has NaN, POSITIVE_INFINITY, NEGATIVE_INFINITY instead of raising a dynamic error (e.g. divide by zero, sqrt of a negative number)

Arrays, Mutation, and Immutability

Arrays vs Lists: arrays are fixed-length sequences; lists are not fixed-length

Mutating vs Reassigning: mutating a value (array/list contents) changes references inside it; reassigning a variable points it at something new

Change is a necessary evil - good programmers avoid unnecessary change because it can happen unexpectedly
Immutability is a major design principle: an immutable type's value can never change once created

java

final int num;

Java gives immutable references too - declare with final

Key Takeaways

Software construction aims for code that is safe from bugs, easy to understand, and ready for change
Java is statically typed and statically checked, catching many errors before runtime
The pipeline is: write .java source, compile with javac to bytecode, run on the JVM (platform independent)
JDK = JRE + development tools; JRE alone can only run compiled programs
Static checking catches errors before running; dynamic checking catches them at runtime; some errors slip through as silently wrong answers
Primitive types have surprising edge cases (integer division, overflow, NaN/Infinity); prefer immutability where possible

Open this lesson

Mahmoud AbasSoftware Construction Week 1

Type

Meaning

int

integers, roughly ±2^31

long

larger integers, roughly ±2^63

boolean

true or false

double

floating-point numbers

char

single characters, e.g. A and $