A short presentation about design patterns in GoLang

1. Design Patterns are not the rocket
science!
Kamil Mówiński

2. Agenda
• Design Patterns – still valuable?
• The world without spam – chain of responsibility
• Level designer - builder
• Watch out for walls – object pool

3. Design Patterns – still valuable?
definitely yes

4. The world without spam
• Have you ever consider how filtering in mailboxes works?
• What happens when you receive a new mail?
[
{
"title": "Test message",
"body": "Lorem ipsum",
"date": "2018-07-20 09:38:12",
"from": "example@example.com",
"to": "my_mail@example.com"
},
{
"title": "Test message with Spam title",
"body": "Lorem ipsum",
"date": "2018-07-20 09:18:12",
"from": "example@example.com",
"to": "my_mail@example.com"
},
{
"title": "Test message with weird body",
"body": "Lorem ipsum spam and another",
"date": "2018-07-20 09:38:12",
"from": "example@example.com",
"to": "my_mail@example.com"
}
]

5. Chain of responsibility
Problem
Solution

6. Chain of responsibility in scientific perspective

7. Filtering
• There is a “spam” word in a message title?
• There is a “spam” word in a message body?
• There is a message for me?
• There is a sender on a blacklist?
type Validator interface {
IsSpam(message.Message) bool
}
type Filter struct {
validator Validator
next *Filter
}
func NewFilter(filter Validator) *Filter {
return &Filter{validator: filter, next: nil}
}

8. Filtering in goroutines
func (f Filter) ValidateAllMessages(messages []message.Message) {
var wg sync.WaitGroup
for index := range messages {
wg.Add(1)
go f.validateMessage(&messages[index], &wg)
}
wg.Wait()
if f.isNextHandler() {
f.next.ValidateAllMessages(messages)
}
}
func (f Filter) isNextHandler() bool {
return f.next != nil
}
func (f Filter) validateMessage(msg *message.Message, wg *sync.WaitGroup) {
defer wg.Done()
if f.validator.IsSpam(*msg) {
msg.Spam = true
}
}

9. Title filtering
type TitleFilter struct {
Validator
}
func (TitleFilter) IsSpam(msg message.Message) bool {
return strings.Contains(strings.ToLower(msg.Title), "spam")
}

10. Recipient filter
type RecipientFilter struct {
Validator
}
func (RecipientFilter) IsSpam(msg message.Message) bool {
return strings.Compare(strings.ToLower(msg.To), "my_mail@example.com") != 0
}

11. Inbox
type Inbox struct {
Messages []message.Message
filters []*filters.Filter
}
func NewInbox(fileName string) (Inbox, error) {
var inbox Inbox
messages, err := message.ReadMessagesFromJson(fileName)
inbox.Messages = messages
return inbox, err
}
func (i *Inbox) AddFilter(filter *filters.Filter) {
if len(i.filters) != 0 {
i.filters[len(i.filters)-1].AddNextFilter(filter)
}
i.filters = append(i.filters, filter)
}
func (i Inbox) Filter() {
if len(i.filters) == 0 {
return
}
i.filters[0].ValidateAllMessages(i.Messages)
}
func (i Inbox) DisplayAllMessagesOnConsole() {
for _, message := range i.Messages {
message.DisplayOnConsole()
}
}
Structure
Constructor
Add filter (handler)
Filter (handle)
Display messages on console

12. Main function
func main() {
if len(os.Args) < 2 {
fmt.Printf("Necessary parameter <file_name> is missing")
return
}
messagesFile := os.Args[1]
incomingMessageBox, err := inbox.NewInbox(messagesFile)
if err != nil {
panic(err)
}
incomingMessageBox.AddFilter(filters.NewFilter(filters.TitleFilter{}))
incomingMessageBox.AddFilter(filters.NewFilter(filters.BodyFilter{}))
incomingMessageBox.AddFilter(filters.NewFilter(filters.RecipientFilter{}))
incomingMessageBox.AddFilter(filters.NewFilter(filters.SenderFilter{}))
incomingMessageBox.Filter()
incomingMessageBox.DisplayAllMessagesOnConsole()
}

13. Presentation time
https://github.com/Mowinski/go-design-patterns/tree/master/chain-of-responsibility

14. Map generator
• Let’s build a game level.
• A simple survive game needs generated maps (e.g. height maps).
• Blueprints of different kind of buildings:
• Heating building
• Smith building
• Shop building
• All buildings contains rooms

15. Example of level
Heating
Smith
Shop
Candy shop

16. Clever idea time

17. Builder in UML Charts
Class diagram
Sequence diagram

18. IBuilding
type IBuilding interface {
Build() (Building, error)
getOwner() player.Player
buildRooms() ([]Room, error)
}
type HeatingBuilding struct {
IBuilding
Owner player.Player
X int
Y int
}
type ShopBuilding struct {
IBuilding
Owner player.Player
X int
Y int
}
type SmithBuilding struct {
IBuilding
Owner player.Player
X int
Y int
}
func (_ ________) getOwner() player.Player {
return hb.Owner
}
type Room struct {
Map []Point
RoomLetter rune
}

19. Lets build a rooms
func (hb HeatingBuilding) buildRooms() ([]Room, error) {
mainRoom := Room{
Map: []Point{GetPoint(0, 0), GetPoint(10, 0), GetPoint(10, 10), GetPoint(0, 10)},
RoomLetter: 'm',
}
ovenRoom := Room{
Map: []Point{GetPoint(0, 10), GetPoint(10, 10), GetPoint(10, 15), GetPoint(0, 15)},
RoomLetter: 'o',
}
return []Room{mainRoom, ovenRoom}, nil
}
func (sb SmithBuilding) buildRooms() ([]Room, error) {
mainRoom := Room{
Map: []Point{GetPoint(0, 0), GetPoint(10, 0), GetPoint(10, 10), GetPoint(0, 10)},
RoomLetter: 'm',
}
smithRoom := Room{
Map: []Point{GetPoint(10, 0), GetPoint(20, 0), GetPoint(20, 5), GetPoint(10, 5)},
RoomLetter: 's',
}
anvilRoom := Room{
Map: []Point{GetPoint(0, 10), GetPoint(5, 10), GetPoint(5, 15), GetPoint(0, 15)},
RoomLetter: 'a',
}
return []Room{mainRoom, smithRoom, anvilRoom}, nil
}

20. Lets build a build!
func (sb ShopBuilding) Build() (Building, error) {
var building Building
var err error
building.Rooms, err = sb.buildRooms()
building.Endurance = 700.00
building.Owner = sb.getOwner()
building.X = sb.X
building.Y = sb.Y
return building, err
}
func (hb HeatingBuilding) Build() (Building, error) {
var building Building
var err error
building.Rooms, err = hb.buildRooms()
building.Endurance = 350.99
building.Owner = hb.getOwner()
building.X = hb.X
building.Y = hb.Y
return building, err
}
func (sb SmithBuilding) Build() (Building, error) {
var building Building
var err error
building.Rooms, err = sb.buildRooms()
building.Endurance = 900.00
building.Owner = sb.getOwner()
building.X = sb.X
building.Y = sb.Y
return building, err
}

21. Who is the boss?
type MapDirector struct {
Level level.Level
err error
}
func NewMapDirector(sizeX, sizeY int, player player.Player) (MapDirector, error) {
var mapDesigner MapDirector
heating := mapDesigner.buildWithErrorChecking(buildings.HeatingBuilding{Owner: player, X: 0, Y: 0})
smith := mapDesigner.buildWithErrorChecking(buildings.SmithBuilding{Owner: player , X: 15, Y: 15})
shop := mapDesigner.buildWithErrorChecking(buildings.ShopBuilding{Owner: player, X: 50, Y: 50})
candyShop := mapDesigner.buildWithErrorChecking(buildings.ShopBuilding{Owner: player, X: 0, Y: 50})
buildingsInMaps := []buildings.Building{*heating, *smith, *shop, *candyShop}
mapDesigner.Level = level.NewLevel(sizeX, sizeY, buildingsInMaps)
return mapDesigner, mapDesigner.err
}
func (md MapDirector) buildWithErrorChecking(builder buildings.IBuilding) *buildings.Building {
var building buildings.Building
if md.err != nil {
return nil
}
building, md.err = builder.Build()
return &building
}

22. func main() {
}
playerOne := player.NewPlayer("TestPlayer")
mapDirector, err := director.NewMapDirector(100, 100, playerOne)
if err != nil {
fmt.Printf("Error occure: %v", err)
os.Exit(1)
}
mapCharacters := mapDirector.Level.Render()
mapCharacters.ShowInConsole()
err = mapCharacters.SaveToFile("map.jpeg", mapDirector.Level.SizeX, mapDirector.Level.SizeY)
if err != nil {
fmt.Printf("Error occure: %v", err)
os.Exit(2)
}

23. Presentation time
https://github.com/Mowinski/go-design-patterns/tree/master/builder

24. Frogger style game

25. Frogger style game

26. Level
type Level struct {
Board [][]rune
XSize, YSize uint
wallPool *object_pool.WallPool
actors []interfaces.Actor
nextWallWidth uint
}
func NewLevel(XSize, YSize uint, wallPool *object_pool.WallPool) Level {
board := make([][]rune, XSize)
for i := range board {
board[i] = make([]rune, YSize)
}
level := Level{Board: board, XSize: XSize, YSize: YSize, wallPool: wallPool}
level.clear()
return level
}
func (l *Level) clear() {
for x := range l.Board {
for y := range l.Board[x] {
l.Board[x][y] = ' '
}
}
}
func (l *Level) printRenderedBoardOnConsole() {
for x := range l.Board {
for y := range l.Board[x] {
fmt.Printf("%c", l.Board[x][y])
}
fmt.Printf("n")
}
}
func (l *Level) RenderOnConsole() {
l.clear()
l.addWall()
l.renderActors()
l.printWallStatsSummary()
l.printRenderedBoardOnConsole()
}

27. Player and actors
type Actor interface {
Render(ILevel)
}
type Player struct {
interfaces.Actor
X, Y uint
currentLevel interfaces.ILevel
}
type Wall struct {
interfaces.Actor
X, Y uint
Width uint
}

28. Walls
func NewWall(x, y, width uint) Wall {
return Wall{X: x, Y: y, Width: width}
}
func GenerateRandomWidthWall(xLevelSize, yLevelSize uint) Wall {
time.Sleep(time.Second * 2)
randomX := uint(rand.Int31n(int32(xLevelSize - MAXSIZE)))
randomY := uint(rand.Int31n(int32(yLevelSize)))
randomWidth := uint(rand.Int31n(MAXSIZE + 1))
return NewWall(randomX, randomY, randomWidth)
}
func (w Wall) Render(level interfaces.ILevel) {
for i := uint(0); i < w.Width; i++ {
level.SetObjectOnBoard(w.X + i, w.Y, '-')
}
}

29. How to implement it?

30. Wall-pool structure
type WallPool struct {
walls map[uint][]actors.Wall
generatingWall bool
}
func (wp WallPool) GetInstanceWithWidth(width uint) actors.Wall {
wall := wp.walls[width][0]
wp.walls[width] = wp.walls[width][1:]
return wall
}
func (wp *WallPool) StopGeneratingWalls() {
wp.generatingWall = false
}
func (l *Level) addWall() {
l.nextWallWidth = (l.nextWallWidth + 1) % (actors.MAXSIZE + 1)
wall := l.wallPool.GetInstanceWithWidth(l.nextWallWidth)
l.AddActorToRenderList(&wall)
}

31. Presentation time
https://github.com/Mowinski/go-design-patterns/tree/master/object-pool

32. The End