diff --git a/docs/src/lecture_04/Lab04Ecosystem.jl b/docs/src/lecture_04/Lab04Ecosystem.jl
new file mode 100644
index 00000000..54a03db0
--- /dev/null
+++ b/docs/src/lecture_04/Lab04Ecosystem.jl
@@ -0,0 +1,198 @@
+using StatsBase
+
+abstract type Species end
+
+abstract type PlantSpecies <: Species end
+abstract type Grass <: PlantSpecies end
+
+abstract type AnimalSpecies <: Species end
+abstract type Sheep <: AnimalSpecies end
+abstract type Wolf <: AnimalSpecies end
+
+abstract type Agent{S<:Species} end
+
+# instead of Symbols we can use an Enum for the sex field
+# using an Enum here makes things easier to extend in case you
+# need more than just binary sexes and is also more explicit than
+# just a boolean
+@enum Sex female male
+
+########## World #############################################################
+
+mutable struct World{A<:Agent}
+ agents::Dict{Int,A}
+ max_id::Int
+end
+
+function World(agents::Vector{<:Agent})
+ max_id = maximum(a.id for a in agents)
+ World(Dict(a.id=>a for a in agents), max_id)
+end
+
+# optional: overload Base.show
+function Base.show(io::IO, w::World)
+ println(io, typeof(w))
+ for (_,a) in w.agents
+ println(io," $a")
+ end
+end
+
+
+########## Animals ###########################################################
+
+mutable struct Animal{A<:AnimalSpecies} <: Agent{A}
+ const id::Int
+ energy::Float64
+ const Δenergy::Float64
+ const reprprob::Float64
+ const foodprob::Float64
+ const sex::Sex
+end
+
+function (A::Type{<:AnimalSpecies})(id::Int,E::T,ΔE::T,pr::T,pf::T,s::Sex) where T
+ Animal{A}(id,E,ΔE,pr,pf,s)
+end
+
+# get the per species defaults back
+randsex() = rand(instances(Sex))
+Sheep(id; E=4.0, ΔE=0.2, pr=0.8, pf=0.6, s=randsex()) = Sheep(id, E, ΔE, pr, pf, s)
+Wolf(id; E=10.0, ΔE=8.0, pr=0.1, pf=0.2, s=randsex()) = Wolf(id, E, ΔE, pr, pf, s)
+
+
+function Base.show(io::IO, a::Animal{A}) where {A<:AnimalSpecies}
+ e = a.energy
+ d = a.Δenergy
+ pr = a.reprprob
+ pf = a.foodprob
+ s = a.sex == female ? "♀" : "♂"
+ print(io, "$A$s #$(a.id) E=$e ΔE=$d pr=$pr pf=$pf")
+end
+
+# note that for new species we will only have to overload `show` on the
+# abstract species/sex types like below!
+Base.show(io::IO, ::Type{Sheep}) = print(io,"🐑")
+Base.show(io::IO, ::Type{Wolf}) = print(io,"🐺")
+
+
+########## Plants #############################################################
+
+mutable struct Plant{P<:PlantSpecies} <: Agent{P}
+ const id::Int
+ size::Int
+ const max_size::Int
+end
+
+# constructor for all Plant{<:PlantSpecies} callable as PlantSpecies(...)
+(A::Type{<:PlantSpecies})(id, s, m) = Plant{A}(id,s,m)
+(A::Type{<:PlantSpecies})(id, m) = (A::Type{<:PlantSpecies})(id,rand(1:m),m)
+
+# default specific for Grass
+Grass(id; max_size=10) = Grass(id, rand(1:max_size), max_size)
+
+function Base.show(io::IO, p::Plant{P}) where P
+ x = p.size/p.max_size * 100
+ print(io,"$P #$(p.id) $(round(Int,x))% grown")
+end
+
+Base.show(io::IO, ::Type{Grass}) = print(io,"🌿")
+
+
+########## Eating / Dying / Reproducing ########################################
+
+function eat!(wolf::Animal{Wolf}, sheep::Animal{Sheep}, w::World)
+ wolf.energy += sheep.energy * wolf.Δenergy
+ kill_agent!(sheep,w)
+end
+function eat!(sheep::Animal{Sheep}, grass::Plant{Grass}, ::World)
+ sheep.energy += grass.size * sheep.Δenergy
+ grass.size = 0
+end
+eat!(::Animal, ::Nothing, ::World) = nothing
+
+kill_agent!(a::Agent, w::World) = delete!(w.agents, a.id)
+
+function find_mate(a::Animal, w::World)
+ ms = filter(x->mates(x,a), w.agents |> values |> collect)
+ isempty(ms) ? nothing : sample(ms)
+end
+mates(a::Animal{A}, b::Animal{A}) where A<:AnimalSpecies = a.sex != b.sex
+mates(::Agent, ::Agent) = false
+
+function reproduce!(a::Animal{A}, w::World) where A
+ m = find_mate(a,w)
+ if !isnothing(m)
+ a.energy = a.energy / 2
+ vals = [getproperty(a,n) for n in fieldnames(Animal) if n ∉ [:id, :sex]]
+ new_id = w.max_id + 1
+ ŝ = Animal{A}(new_id, vals..., randsex())
+ w.agents[ŝ.id] = ŝ
+ w.max_id = new_id
+ end
+end
+
+# finding food / who eats who
+function find_food(a::Animal, w::World)
+ as = filter(x -> eats(a,x), w.agents |> values |> collect)
+ isempty(as) ? nothing : sample(as)
+end
+eats(::Animal{Sheep},g::Plant{Grass}) = g.size > 0
+eats(::Animal{Wolf},::Animal{Sheep}) = true
+eats(::Agent,::Agent) = false
+
+
+########## Stepping through time #############################################
+
+function agent_step!(p::Plant, ::World)
+ if p.size < p.max_size
+ p.size += 1
+ end
+end
+function agent_step!(a::Animal, w::World)
+ a.energy -= 1
+ if rand() <= a.foodprob
+ dinner = find_food(a,w)
+ eat!(a, dinner, w)
+ end
+ if a.energy <= 0
+ kill_agent!(a,w)
+ return
+ end
+ if rand() <= a.reprprob
+ reproduce!(a,w)
+ end
+ return a
+end
+
+function world_step!(world::World)
+ # make sure that we only iterate over IDs that already exist in the
+ # current timestep this lets us safely add agents
+ ids = copy(keys(world.agents))
+
+ for id in ids
+ # agents can be killed by other agents, so make sure that we are
+ # not stepping dead agents forward
+ !haskey(world.agents,id) && continue
+
+ a = world.agents[id]
+ agent_step!(a,world)
+ end
+end
+
+
+########## Counting agents ####################################################
+
+agent_count(p::Plant) = p.size / p.max_size
+agent_count(::Animal) = 1
+agent_count(as::Vector{<:Agent}) = sum(agent_count,as)
+
+function agent_count(w::World)
+ function op(d::Dict,a::A) where A<:Agent
+ if A in keys(d)
+ d[A] += agent_count(a)
+ else
+ d[A] = agent_count(a)
+ end
+ return d
+ end
+ foldl(op, w.agents |> values |> collect, init=Dict())
+end
diff --git a/docs/src/lecture_04/grass-sheep-wolf.jl b/docs/src/lecture_04/grass-sheep-wolf.jl
new file mode 100644
index 00000000..0dab503e
--- /dev/null
+++ b/docs/src/lecture_04/grass-sheep-wolf.jl
@@ -0,0 +1,39 @@
+using Plots
+include("Lab04Ecosystem.jl")
+
+function make_counter()
+ n = 0
+ counter() = n += 1
+end
+
+function create_world()
+ n_grass = 1_000
+ n_sheep = 40
+ n_wolves = 4
+
+ nextid = make_counter()
+
+ World(vcat(
+ [Grass(nextid()) for _ in 1:n_grass],
+ [Sheep(nextid()) for _ in 1:n_sheep],
+ [Wolf(nextid()) for _ in 1:n_wolves],
+ ))
+end
+world = create_world();
+
+counts = Dict(n=>[c] for (n,c) in agent_count(world))
+for _ in 1:100
+ world_step!(world)
+ for (n,c) in agent_count(world)
+ push!(counts[n],c)
+ end
+end
+
+plt = plot()
+tolabel(::Type{Animal{Sheep}}) = "Sheep"
+tolabel(::Type{Animal{Wolf}}) = "Wolf"
+tolabel(::Type{Plant{Grass}}) = "Grass"
+for (A,c) in counts
+ plot!(plt, c, label=tolabel(A), lw=2)
+end
+display(plt)
diff --git a/docs/src/lecture_04/hw.md b/docs/src/lecture_04/hw.md
new file mode 100644
index 00000000..133f7556
--- /dev/null
+++ b/docs/src/lecture_04/hw.md
@@ -0,0 +1,61 @@
+# Homework 4
+
+In this homework you will have to write two additional `@testset`s for the
+Ecosystem. One testset should be contained in a file `test/sheep.jl` and verify
+that the function `eat!(::Animal{Sheep}, ::Plant{Grass}, ::World)` works correctly. Another
+testset should be in the file `test/wolf.jl` and veryfiy that the function
+`eat!(::Animal{Wolf}, ::Animal{Sheep}, ::World)` works correctly.
+
+## How to submit?
+
+Zip the whole package folder `Ecosystem.jl` and upload it to BRUTE.
+The package has to include at least the following files:
+
+```
+├── src
+│ └── Ecosystem.jl
+└── test
+ ├── sheep.jl # contains only a single @testset
+ ├── wolf.jl # contains only a single @testset
+ └── runtests.jl
+```
+Thet `test/runtests.jl` file can look like this:
+```
+using Test
+using Ecosystem
+
+include("sheep.jl")
+include("wolf.jl")
+# ...
+```
+
+## Test `Sheep`
+
+```@raw html
+
+
+
+```
+1. Create a `Sheep` with food probability $p_f=1$
+2. Create *fully grown* `Grass` and a `World` with the two agents.
+3. Execute `eat!(::Animal{Sheep}, ::Plant{Grass}, ::World)`
+4. `@test` that the size of the `Grass` now has `size == 0`
+```@raw html
+
+
+
+```
+1. Create a `Wolf` with food probability $p_f=1$
+2. Create a `Sheep` and a `World` with the two agents.
+3. Execute `eat!(::Animal{Wolf}, ::Animal{Sheep}, ::World)`
+4. `@test` that the World only has one agent left in the agents dictionary
+```@raw html
+
+
+
+```
+1. Implement a method `agent_step!(::Animal,::World)` which performs the following steps:
+ - Decrement $E$ of agent by `1.0`.
+ - With $p_f$, try to find some food and eat it.
+ - If $E<0$, the animal dies.
+ - With $p_r$, try to reproduce.
+2. Implement a method `agent_step!(::Plant,::World)` which performs the following steps:
+ - If the size of the plant is smaller than `max_size`, increment the plant's size by one.
+```@raw html
+
+
+```
+```@example block
+function agent_step!(p::Plant, w::World)
+ if p.size < p.max_size
+ p.size += 1
+ end
+end
+
+function agent_step!(a::Animal, w::World)
+ a.energy -= 1
+ if rand() <= a.foodprob
+ dinner = find_food(a,w)
+ eat!(a, dinner, w)
+ end
+ if a.energy < 0
+ kill_agent!(a,w)
+ return
+ end
+ if rand() <= a.reprprob
+ reproduce!(a,w)
+ end
+end
+
+nothing # hide
+```
+```@raw html
+
+```
+An `agent_step!` of a sheep in a world with a single grass should make it consume the grass,
+let it reproduce, and eventually die if there is no more food and its energy is at zero:
+```@repl block
+sheep = Sheep(1,2.0,2.0,1.0,1.0,male);
+grass = Grass(2,2,2);
+world = World([sheep, grass])
+agent_step!(sheep, world); world
+# NOTE: The second agent step leads to an error.
+# Can you figure out what is the problem here?
+agent_step!(sheep, world); world
+```
+
+```@raw html
+
+
+
+```
+Finally, lets implement a function `world_step!` which performs one
+`agent_step!` for each agent. Note that simply iterating over all agents could
+lead to problems because we are mutating the agent dictionary. One solution for
+this is to iterate over a copy of all agent IDs that are present when starting
+to iterate over agents. Additionally, it could happen that an agent is killed
+by another one before we apply `agent_step!` to it. To solve this you can check
+if a given ID is currently present in the `World`.
+```@raw html
+
+
+```
+```@example block
+# make it possible to eat nothing
+eat!(::Animal, ::Nothing, ::World) = nothing
+
+function world_step!(world::World)
+ # make sure that we only iterate over IDs that already exist in the
+ # current timestep this lets us safely add agents
+ ids = copy(keys(world.agents))
+
+ for id in ids
+ # agents can be killed by other agents, so make sure that we are
+ # not stepping dead agents forward
+ !haskey(world.agents,id) && continue
+
+ a = world.agents[id]
+ agent_step!(a,world)
+ end
+end
+```
+```@raw html
+
+```
+```@repl block
+w = World([Sheep(1), Sheep(2), Wolf(3)])
+world_step!(w); w
+world_step!(w); w
+world_step!(w); w
+```
+
+Finally, lets run a few simulation steps and plot the solution
+```@example block
+n_grass = 1_000
+n_sheep = 40
+n_wolves = 4
+
+gs = [Grass(id) for id in 1:n_grass]
+ss = [Sheep(id) for id in (n_grass+1):(n_grass+n_sheep)]
+ws = [Wolf(id) for id in (n_grass+n_sheep+1):(n_grass+n_sheep+n_wolves)]
+w = World(vcat(gs,ss,ws))
+
+counts = Dict(n=>[c] for (n,c) in agent_count(w))
+for _ in 1:100
+ world_step!(w)
+ for (n,c) in agent_count(w)
+ push!(counts[n],c)
+ end
+end
+
+using Plots
+plt = plot()
+tolabel(::Type{Animal{Sheep}}) = "Sheep"
+tolabel(::Type{Animal{Wolf}}) = "Wolf"
+tolabel(::Type{Plant{Grass}}) = "Grass"
+for (A,c) in counts
+ plot!(plt, c, label=tolabel(A), lw=2)
+end
+plt
+```
+
+
+## Package: `Ecosystem.jl`
+
+In the main section of this lab you will create your own `Ecosystem.jl` package
+to organize *and test (!)* the code that we have written so far.
+
+### `PkgTemplates.jl`
+
+```@raw html
+
+
+
+```
+The simplest way to create a new package in Julia is to use `PkgTemplates.jl`.
+`]add PkgTemplates` to your global julia env and create a new package by running:
+```julia
+using PkgTemplates
+Template(interactive=true)("Ecosystem")
+```
+to interactively specify various options for your new package or use the following
+snippet to generate it programmatically:
+```julia
+using PkgTemplates
+
+# define the package template
+template = Template(;
+ user = "GithubUserName", # github user name
+ authors = ["Author1", "Author2"], # list of authors
+ dir = "/path/to/folder/", # dir in which the package will be created
+ julia = v"1.8", # compat version of Julia
+ plugins = [
+ !CompatHelper, # disable CompatHelper
+ !TagBot, # disable TagBot
+ Readme(; inline_badges = true), # added readme file with badges
+ Tests(; project = true), # added Project.toml file for unit tests
+ Git(; manifest = false), # add manifest.toml to .gitignore
+ License(; name = "MIT") # addedMIT licence
+ ],
+)
+
+# execute the package template (this creates all files/folders)
+template("Ecosystem")
+```
+```@raw html
+
+
+```
+This should have created a new folder `Ecosystem` which looks like below.
+```
+.
+├── LICENSE
+├── Project.toml
+├── README.md
+├── src
+│ └── Ecosystem.jl
+└── test
+ ├── Manifest.toml
+ ├── Project.toml
+ └── runtests.jl
+```
+If you `]activate /path/to/Ecosystem` you should be able to run `]test` to run the autogenerated test (which is not doing anything)
+and get the following output:
+```
+(Ecosystem) pkg> test
+ Testing Ecosystem
+ Status `/private/var/folders/6h/l9_skfms2v3dt8z3zfnd2jr00000gn/T/jl_zd5Uai/Project.toml`
+ [e77cd98c] Ecosystem v0.1.0 `~/repos/Ecosystem`
+ [8dfed614] Test `@stdlib/Test`
+ Status `/private/var/folders/6h/l9_skfms2v3dt8z3zfnd2jr00000gn/T/jl_zd5Uai/Manifest.toml`
+ [e77cd98c] Ecosystem v0.1.0 `~/repos/Ecosystem`
+ [2a0f44e3] Base64 `@stdlib/Base64`
+ [b77e0a4c] InteractiveUtils `@stdlib/InteractiveUtils`
+ [56ddb016] Logging `@stdlib/Logging`
+ [d6f4376e] Markdown `@stdlib/Markdown`
+ [9a3f8284] Random `@stdlib/Random`
+ [ea8e919c] SHA v0.7.0 `@stdlib/SHA`
+ [9e88b42a] Serialization `@stdlib/Serialization`
+ [8dfed614] Test `@stdlib/Test`
+ Testing Running tests...
+Test Summary: |Time
+Ecosystem.jl | None 0.0s
+ Testing Ecosystem tests passed
+```
+```@raw html
+
+```
+
+!!! warning
+ From now on make sure that you **always** have the `Ecosystem` enviroment
+ enabled. Otherwise you will not end up with the correct dependencies in your
+ packages
+
+### Adding content to `Ecosystem.jl`
+```@raw html
+
+
+
+```
+Next, let's add the types and functions we have defined so
+far. You can use `include("path/to/file.jl")` in the main module file at
+`src/Ecosystem.jl` to bring some structure in your code. An exemplary
+file structure could look like below.
+```
+.
+├── LICENSE
+├── Manifest.toml
+├── Project.toml
+├── README.md
+├── src
+│ ├── Ecosystem.jl
+│ ├── animal.jl
+│ ├── plant.jl
+│ └── world.jl
+└── test
+ └── runtests.jl
+```
+While you are adding functionality to your package you can make great use of
+`Revise.jl`. Loading `Revise.jl` before your `Ecosystem.jl` will automatically
+recompile (and invalidate old methods!) while you develop. You can install it
+in your global environment and and create a `$HOME/.config/startup.jl` which always loads
+`Revise`. It can look like this:
+```julia
+# try/catch block to make sure you can start julia if Revise should not be installed
+try
+ using Revise
+catch e
+ @warn(e.msg)
+end
+```
+```@raw html
+
+
+
+```
+In order to use your new types/functions like below
+```julia
+using Ecosystem
+
+Sheep(2)
+```
+you have to `export` them from your module. Add exports for all important types
+and functions.
+```@raw html
+
+
+```
+```julia
+# src/Ecosystem.jl
+module Ecosystem
+
+using StatsBase
+
+export World
+export Species, PlantSpecies, AnimalSpecies, Grass, Sheep, Wolf
+export Agent, Plant, Animal
+export agent_step!, eat!, eats, find_food, reproduce!, world_step!, agent_count
+
+# ....
+
+end
+```
+```@raw html
+
+```
+
+
+### Unit tests
+
+Every package should have tests which verify the correctness of your
+implementation, such that you can make changes to your codebase and remain
+confident that you did not break anything.
+
+Julia's `Test` package provides you functionality to easily write [unit
+tests](https://docs.julialang.org/en/v1/stdlib/Test/).
+
+```@raw html
+
+
+
+```
+In the file `test/runtests.jl`, create a new `@testset` and write three `@test`s
+which check that the `show` methods we defined for `Grass`, `Sheep`, and `Wolf` work as expected.
+
+The function `repr(x) == "some string"` to check if the string representation we
+defined in the `Base.show` overload returns what you expect.
+```@raw html
+
+
+```
+```@repl block
+# using Ecosystem
+using Test
+
+@testset "Base.show" begin
+ g = Grass(1,1,1)
+ s = Animal{Sheep}(2,1,1,1,1,male)
+ w = Animal{Wolf}(3,1,1,1,1,female)
+ @test repr(g) == "🌿 #1 100% grown"
+ @test repr(s) == "🐑♂ #2 E=1.0 ΔE=1.0 pr=1.0 pf=1.0"
+ @test repr(w) == "🐺♀ #3 E=1.0 ΔE=1.0 pr=1.0 pf=1.0"
+end
+```
+```@raw html
+
+```
+
+
+### Github CI
+```@raw html
+
+
+
+```
+If you want you can upload you package to Github and add the `julia-runtest`
+[Github Action](https://github.com/julia-actions/julia-runtest) to automatically
+test your code for every new push you make to the repository.
+```@raw html
+